Chinese: add translation of oops-tracing.txt
[pv_ops_mirror.git] / drivers / net / wan / cycx_x25.c
blobd3b28b01b9f91c5e5e52cfb5eb9a60940cb07531
1 /*
2 * cycx_x25.c Cyclom 2X WAN Link Driver. X.25 module.
4 * Author: Arnaldo Carvalho de Melo <acme@conectiva.com.br>
6 * Copyright: (c) 1998-2003 Arnaldo Carvalho de Melo
8 * Based on sdla_x25.c by Gene Kozin <genek@compuserve.com>
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
14 * ============================================================================
15 * 2001/01/12 acme use dev_kfree_skb_irq on interrupt context
16 * 2000/04/02 acme dprintk, cycx_debug
17 * fixed the bug introduced in get_dev_by_lcn and
18 * get_dev_by_dte_addr by the anonymous hacker
19 * that converted this driver to softnet
20 * 2000/01/08 acme cleanup
21 * 1999/10/27 acme use ARPHRD_HWX25 so that the X.25 stack know
22 * that we have a X.25 stack implemented in
23 * firmware onboard
24 * 1999/10/18 acme support for X.25 sockets in if_send,
25 * beware: socket(AF_X25...) IS WORK IN PROGRESS,
26 * TCP/IP over X.25 via wanrouter not affected,
27 * working.
28 * 1999/10/09 acme chan_disc renamed to chan_disconnect,
29 * began adding support for X.25 sockets:
30 * conf->protocol in new_if
31 * 1999/10/05 acme fixed return E... to return -E...
32 * 1999/08/10 acme serialized access to the card thru a spinlock
33 * in x25_exec
34 * 1999/08/09 acme removed per channel spinlocks
35 * removed references to enable_tx_int
36 * 1999/05/28 acme fixed nibble_to_byte, ackvc now properly treated
37 * if_send simplified
38 * 1999/05/25 acme fixed t1, t2, t21 & t23 configuration
39 * use spinlocks instead of cli/sti in some points
40 * 1999/05/24 acme finished the x25_get_stat function
41 * 1999/05/23 acme dev->type = ARPHRD_X25 (tcpdump only works,
42 * AFAIT, with ARPHRD_ETHER). This seems to be
43 * needed to use socket(AF_X25)...
44 * Now the config file must specify a peer media
45 * address for svc channels over a crossover cable.
46 * Removed hold_timeout from x25_channel_t,
47 * not used.
48 * A little enhancement in the DEBUG processing
49 * 1999/05/22 acme go to DISCONNECTED in disconnect_confirm_intr,
50 * instead of chan_disc.
51 * 1999/05/16 marcelo fixed timer initialization in SVCs
52 * 1999/01/05 acme x25_configure now get (most of) all
53 * parameters...
54 * 1999/01/05 acme pktlen now (correctly) uses log2 (value
55 * configured)
56 * 1999/01/03 acme judicious use of data types (u8, u16, u32, etc)
57 * 1999/01/03 acme cyx_isr: reset dpmbase to acknowledge
58 * indication (interrupt from cyclom 2x)
59 * 1999/01/02 acme cyx_isr: first hackings...
60 * 1999/01/0203 acme when initializing an array don't give less
61 * elements than declared...
62 * example: char send_cmd[6] = "?\xFF\x10";
63 * you'll gonna lose a couple hours, 'cause your
64 * brain won't admit that there's an error in the
65 * above declaration... the side effect is that
66 * memset is put into the unresolved symbols
67 * instead of using the inline memset functions...
68 * 1999/01/02 acme began chan_connect, chan_send, x25_send
69 * 1998/12/31 acme x25_configure
70 * this code can be compiled as non module
71 * 1998/12/27 acme code cleanup
72 * IPX code wiped out! let's decrease code
73 * complexity for now, remember: I'm learning! :)
74 * bps_to_speed_code OK
75 * 1998/12/26 acme Minimal debug code cleanup
76 * 1998/08/08 acme Initial version.
79 #define CYCLOMX_X25_DEBUG 1
81 #include <linux/ctype.h> /* isdigit() */
82 #include <linux/errno.h> /* return codes */
83 #include <linux/if_arp.h> /* ARPHRD_HWX25 */
84 #include <linux/kernel.h> /* printk(), and other useful stuff */
85 #include <linux/module.h>
86 #include <linux/string.h> /* inline memset(), etc. */
87 #include <linux/slab.h> /* kmalloc(), kfree() */
88 #include <linux/stddef.h> /* offsetof(), etc. */
89 #include <linux/wanrouter.h> /* WAN router definitions */
91 #include <asm/byteorder.h> /* htons(), etc. */
93 #include <linux/cyclomx.h> /* Cyclom 2X common user API definitions */
94 #include <linux/cycx_x25.h> /* X.25 firmware API definitions */
96 #include <net/x25device.h>
98 /* Defines & Macros */
99 #define CYCX_X25_MAX_CMD_RETRY 5
100 #define CYCX_X25_CHAN_MTU 2048 /* unfragmented logical channel MTU */
102 /* Data Structures */
103 /* This is an extension of the 'struct net_device' we create for each network
104 interface to keep the rest of X.25 channel-specific data. */
105 struct cycx_x25_channel {
106 /* This member must be first. */
107 struct net_device *slave; /* WAN slave */
109 char name[WAN_IFNAME_SZ+1]; /* interface name, ASCIIZ */
110 char addr[WAN_ADDRESS_SZ+1]; /* media address, ASCIIZ */
111 char *local_addr; /* local media address, ASCIIZ -
112 svc thru crossover cable */
113 s16 lcn; /* logical channel number/conn.req.key*/
114 u8 link;
115 struct timer_list timer; /* timer used for svc channel disc. */
116 u16 protocol; /* ethertype, 0 - multiplexed */
117 u8 svc; /* 0 - permanent, 1 - switched */
118 u8 state; /* channel state */
119 u8 drop_sequence; /* mark sequence for dropping */
120 u32 idle_tmout; /* sec, before disconnecting */
121 struct sk_buff *rx_skb; /* receive socket buffer */
122 struct cycx_device *card; /* -> owner */
123 struct net_device_stats ifstats;/* interface statistics */
126 /* Function Prototypes */
127 /* WAN link driver entry points. These are called by the WAN router module. */
128 static int cycx_wan_update(struct wan_device *wandev),
129 cycx_wan_new_if(struct wan_device *wandev, struct net_device *dev,
130 wanif_conf_t *conf),
131 cycx_wan_del_if(struct wan_device *wandev, struct net_device *dev);
133 /* Network device interface */
134 static int cycx_netdevice_init(struct net_device *dev);
135 static int cycx_netdevice_open(struct net_device *dev);
136 static int cycx_netdevice_stop(struct net_device *dev);
137 static int cycx_netdevice_hard_header(struct sk_buff *skb,
138 struct net_device *dev, u16 type,
139 const void *daddr, const void *saddr,
140 unsigned len);
141 static int cycx_netdevice_rebuild_header(struct sk_buff *skb);
142 static int cycx_netdevice_hard_start_xmit(struct sk_buff *skb,
143 struct net_device *dev);
145 static struct net_device_stats *
146 cycx_netdevice_get_stats(struct net_device *dev);
148 /* Interrupt handlers */
149 static void cycx_x25_irq_handler(struct cycx_device *card),
150 cycx_x25_irq_tx(struct cycx_device *card, struct cycx_x25_cmd *cmd),
151 cycx_x25_irq_rx(struct cycx_device *card, struct cycx_x25_cmd *cmd),
152 cycx_x25_irq_log(struct cycx_device *card,
153 struct cycx_x25_cmd *cmd),
154 cycx_x25_irq_stat(struct cycx_device *card,
155 struct cycx_x25_cmd *cmd),
156 cycx_x25_irq_connect_confirm(struct cycx_device *card,
157 struct cycx_x25_cmd *cmd),
158 cycx_x25_irq_disconnect_confirm(struct cycx_device *card,
159 struct cycx_x25_cmd *cmd),
160 cycx_x25_irq_connect(struct cycx_device *card,
161 struct cycx_x25_cmd *cmd),
162 cycx_x25_irq_disconnect(struct cycx_device *card,
163 struct cycx_x25_cmd *cmd),
164 cycx_x25_irq_spurious(struct cycx_device *card,
165 struct cycx_x25_cmd *cmd);
167 /* X.25 firmware interface functions */
168 static int cycx_x25_configure(struct cycx_device *card,
169 struct cycx_x25_config *conf),
170 cycx_x25_get_stats(struct cycx_device *card),
171 cycx_x25_send(struct cycx_device *card, u8 link, u8 lcn, u8 bitm,
172 int len, void *buf),
173 cycx_x25_connect_response(struct cycx_device *card,
174 struct cycx_x25_channel *chan),
175 cycx_x25_disconnect_response(struct cycx_device *card, u8 link,
176 u8 lcn);
178 /* channel functions */
179 static int cycx_x25_chan_connect(struct net_device *dev),
180 cycx_x25_chan_send(struct net_device *dev, struct sk_buff *skb);
182 static void cycx_x25_chan_disconnect(struct net_device *dev),
183 cycx_x25_chan_send_event(struct net_device *dev, u8 event);
185 /* Miscellaneous functions */
186 static void cycx_x25_set_chan_state(struct net_device *dev, u8 state),
187 cycx_x25_chan_timer(unsigned long d);
189 static void nibble_to_byte(u8 *s, u8 *d, u8 len, u8 nibble),
190 reset_timer(struct net_device *dev);
192 static u8 bps_to_speed_code(u32 bps);
193 static u8 cycx_log2(u32 n);
195 static unsigned dec_to_uint(u8 *str, int len);
197 static struct net_device *cycx_x25_get_dev_by_lcn(struct wan_device *wandev,
198 s16 lcn);
199 static struct net_device *
200 cycx_x25_get_dev_by_dte_addr(struct wan_device *wandev, char *dte);
202 #ifdef CYCLOMX_X25_DEBUG
203 static void hex_dump(char *msg, unsigned char *p, int len);
204 static void cycx_x25_dump_config(struct cycx_x25_config *conf);
205 static void cycx_x25_dump_stats(struct cycx_x25_stats *stats);
206 static void cycx_x25_dump_devs(struct wan_device *wandev);
207 #else
208 #define hex_dump(msg, p, len)
209 #define cycx_x25_dump_config(conf)
210 #define cycx_x25_dump_stats(stats)
211 #define cycx_x25_dump_devs(wandev)
212 #endif
213 /* Public Functions */
215 /* X.25 Protocol Initialization routine.
217 * This routine is called by the main Cyclom 2X module during setup. At this
218 * point adapter is completely initialized and X.25 firmware is running.
219 * o configure adapter
220 * o initialize protocol-specific fields of the adapter data space.
222 * Return: 0 o.k.
223 * < 0 failure. */
224 int cycx_x25_wan_init(struct cycx_device *card, wandev_conf_t *conf)
226 struct cycx_x25_config cfg;
228 /* Verify configuration ID */
229 if (conf->config_id != WANCONFIG_X25) {
230 printk(KERN_INFO "%s: invalid configuration ID %u!\n",
231 card->devname, conf->config_id);
232 return -EINVAL;
235 /* Initialize protocol-specific fields */
236 card->mbox = card->hw.dpmbase + X25_MBOX_OFFS;
237 card->u.x.connection_keys = 0;
238 spin_lock_init(&card->u.x.lock);
240 /* Configure adapter. Here we set reasonable defaults, then parse
241 * device configuration structure and set configuration options.
242 * Most configuration options are verified and corrected (if
243 * necessary) since we can't rely on the adapter to do so and don't
244 * want it to fail either. */
245 memset(&cfg, 0, sizeof(cfg));
246 cfg.link = 0;
247 cfg.clock = conf->clocking == WANOPT_EXTERNAL ? 8 : 55;
248 cfg.speed = bps_to_speed_code(conf->bps);
249 cfg.n3win = 7;
250 cfg.n2win = 2;
251 cfg.n2 = 5;
252 cfg.nvc = 1;
253 cfg.npvc = 1;
254 cfg.flags = 0x02; /* default = V35 */
255 cfg.t1 = 10; /* line carrier timeout */
256 cfg.t2 = 29; /* tx timeout */
257 cfg.t21 = 180; /* CALL timeout */
258 cfg.t23 = 180; /* CLEAR timeout */
260 /* adjust MTU */
261 if (!conf->mtu || conf->mtu >= 512)
262 card->wandev.mtu = 512;
263 else if (conf->mtu >= 256)
264 card->wandev.mtu = 256;
265 else if (conf->mtu >= 128)
266 card->wandev.mtu = 128;
267 else
268 card->wandev.mtu = 64;
270 cfg.pktlen = cycx_log2(card->wandev.mtu);
272 if (conf->station == WANOPT_DTE) {
273 cfg.locaddr = 3; /* DTE */
274 cfg.remaddr = 1; /* DCE */
275 } else {
276 cfg.locaddr = 1; /* DCE */
277 cfg.remaddr = 3; /* DTE */
280 if (conf->interface == WANOPT_RS232)
281 cfg.flags = 0; /* FIXME just reset the 2nd bit */
283 if (conf->u.x25.hi_pvc) {
284 card->u.x.hi_pvc = min_t(unsigned int, conf->u.x25.hi_pvc, 4095);
285 card->u.x.lo_pvc = min_t(unsigned int, conf->u.x25.lo_pvc, card->u.x.hi_pvc);
288 if (conf->u.x25.hi_svc) {
289 card->u.x.hi_svc = min_t(unsigned int, conf->u.x25.hi_svc, 4095);
290 card->u.x.lo_svc = min_t(unsigned int, conf->u.x25.lo_svc, card->u.x.hi_svc);
293 if (card->u.x.lo_pvc == 255)
294 cfg.npvc = 0;
295 else
296 cfg.npvc = card->u.x.hi_pvc - card->u.x.lo_pvc + 1;
298 cfg.nvc = card->u.x.hi_svc - card->u.x.lo_svc + 1 + cfg.npvc;
300 if (conf->u.x25.hdlc_window)
301 cfg.n2win = min_t(unsigned int, conf->u.x25.hdlc_window, 7);
303 if (conf->u.x25.pkt_window)
304 cfg.n3win = min_t(unsigned int, conf->u.x25.pkt_window, 7);
306 if (conf->u.x25.t1)
307 cfg.t1 = min_t(unsigned int, conf->u.x25.t1, 30);
309 if (conf->u.x25.t2)
310 cfg.t2 = min_t(unsigned int, conf->u.x25.t2, 30);
312 if (conf->u.x25.t11_t21)
313 cfg.t21 = min_t(unsigned int, conf->u.x25.t11_t21, 30);
315 if (conf->u.x25.t13_t23)
316 cfg.t23 = min_t(unsigned int, conf->u.x25.t13_t23, 30);
318 if (conf->u.x25.n2)
319 cfg.n2 = min_t(unsigned int, conf->u.x25.n2, 30);
321 /* initialize adapter */
322 if (cycx_x25_configure(card, &cfg))
323 return -EIO;
325 /* Initialize protocol-specific fields of adapter data space */
326 card->wandev.bps = conf->bps;
327 card->wandev.interface = conf->interface;
328 card->wandev.clocking = conf->clocking;
329 card->wandev.station = conf->station;
330 card->isr = cycx_x25_irq_handler;
331 card->exec = NULL;
332 card->wandev.update = cycx_wan_update;
333 card->wandev.new_if = cycx_wan_new_if;
334 card->wandev.del_if = cycx_wan_del_if;
335 card->wandev.state = WAN_DISCONNECTED;
337 return 0;
340 /* WAN Device Driver Entry Points */
341 /* Update device status & statistics. */
342 static int cycx_wan_update(struct wan_device *wandev)
344 /* sanity checks */
345 if (!wandev || !wandev->private)
346 return -EFAULT;
348 if (wandev->state == WAN_UNCONFIGURED)
349 return -ENODEV;
351 cycx_x25_get_stats(wandev->private);
353 return 0;
356 /* Create new logical channel.
357 * This routine is called by the router when ROUTER_IFNEW IOCTL is being
358 * handled.
359 * o parse media- and hardware-specific configuration
360 * o make sure that a new channel can be created
361 * o allocate resources, if necessary
362 * o prepare network device structure for registration.
364 * Return: 0 o.k.
365 * < 0 failure (channel will not be created) */
366 static int cycx_wan_new_if(struct wan_device *wandev, struct net_device *dev,
367 wanif_conf_t *conf)
369 struct cycx_device *card = wandev->private;
370 struct cycx_x25_channel *chan;
371 int err = 0;
373 if (!conf->name[0] || strlen(conf->name) > WAN_IFNAME_SZ) {
374 printk(KERN_INFO "%s: invalid interface name!\n",
375 card->devname);
376 return -EINVAL;
379 /* allocate and initialize private data */
380 chan = kzalloc(sizeof(struct cycx_x25_channel), GFP_KERNEL);
381 if (!chan)
382 return -ENOMEM;
384 strcpy(chan->name, conf->name);
385 chan->card = card;
386 chan->link = conf->port;
387 chan->protocol = conf->protocol ? ETH_P_X25 : ETH_P_IP;
388 chan->rx_skb = NULL;
389 /* only used in svc connected thru crossover cable */
390 chan->local_addr = NULL;
392 if (conf->addr[0] == '@') { /* SVC */
393 int len = strlen(conf->local_addr);
395 if (len) {
396 if (len > WAN_ADDRESS_SZ) {
397 printk(KERN_ERR "%s: %s local addr too long!\n",
398 wandev->name, chan->name);
399 kfree(chan);
400 return -EINVAL;
401 } else {
402 chan->local_addr = kmalloc(len + 1, GFP_KERNEL);
404 if (!chan->local_addr) {
405 kfree(chan);
406 return -ENOMEM;
410 strncpy(chan->local_addr, conf->local_addr,
411 WAN_ADDRESS_SZ);
414 chan->svc = 1;
415 strncpy(chan->addr, &conf->addr[1], WAN_ADDRESS_SZ);
416 init_timer(&chan->timer);
417 chan->timer.function = cycx_x25_chan_timer;
418 chan->timer.data = (unsigned long)dev;
420 /* Set channel timeouts (default if not specified) */
421 chan->idle_tmout = conf->idle_timeout ? conf->idle_timeout : 90;
422 } else if (isdigit(conf->addr[0])) { /* PVC */
423 s16 lcn = dec_to_uint(conf->addr, 0);
425 if (lcn >= card->u.x.lo_pvc && lcn <= card->u.x.hi_pvc)
426 chan->lcn = lcn;
427 else {
428 printk(KERN_ERR
429 "%s: PVC %u is out of range on interface %s!\n",
430 wandev->name, lcn, chan->name);
431 err = -EINVAL;
433 } else {
434 printk(KERN_ERR "%s: invalid media address on interface %s!\n",
435 wandev->name, chan->name);
436 err = -EINVAL;
439 if (err) {
440 kfree(chan->local_addr);
441 kfree(chan);
442 return err;
445 /* prepare network device data space for registration */
446 strcpy(dev->name, chan->name);
447 dev->init = cycx_netdevice_init;
448 dev->priv = chan;
450 return 0;
453 /* Delete logical channel. */
454 static int cycx_wan_del_if(struct wan_device *wandev, struct net_device *dev)
456 if (dev->priv) {
457 struct cycx_x25_channel *chan = dev->priv;
459 if (chan->svc) {
460 kfree(chan->local_addr);
461 if (chan->state == WAN_CONNECTED)
462 del_timer(&chan->timer);
465 kfree(chan);
466 dev->priv = NULL;
469 return 0;
473 /* Network Device Interface */
475 static const struct header_ops cycx_header_ops = {
476 .create = cycx_netdevice_hard_header,
477 .rebuild = cycx_netdevice_rebuild_header,
480 /* Initialize Linux network interface.
482 * This routine is called only once for each interface, during Linux network
483 * interface registration. Returning anything but zero will fail interface
484 * registration. */
485 static int cycx_netdevice_init(struct net_device *dev)
487 struct cycx_x25_channel *chan = dev->priv;
488 struct cycx_device *card = chan->card;
489 struct wan_device *wandev = &card->wandev;
491 /* Initialize device driver entry points */
492 dev->open = cycx_netdevice_open;
493 dev->stop = cycx_netdevice_stop;
494 dev->header_ops = &cycx_header_ops;
496 dev->hard_start_xmit = cycx_netdevice_hard_start_xmit;
497 dev->get_stats = cycx_netdevice_get_stats;
499 /* Initialize media-specific parameters */
500 dev->mtu = CYCX_X25_CHAN_MTU;
501 dev->type = ARPHRD_HWX25; /* ARP h/w type */
502 dev->hard_header_len = 0; /* media header length */
503 dev->addr_len = 0; /* hardware address length */
505 if (!chan->svc)
506 *(__be16*)dev->dev_addr = htons(chan->lcn);
508 /* Initialize hardware parameters (just for reference) */
509 dev->irq = wandev->irq;
510 dev->dma = wandev->dma;
511 dev->base_addr = wandev->ioport;
512 dev->mem_start = (unsigned long)wandev->maddr;
513 dev->mem_end = (unsigned long)(wandev->maddr +
514 wandev->msize - 1);
515 dev->flags |= IFF_NOARP;
517 /* Set transmit buffer queue length */
518 dev->tx_queue_len = 10;
520 /* Initialize socket buffers */
521 cycx_x25_set_chan_state(dev, WAN_DISCONNECTED);
523 return 0;
526 /* Open network interface.
527 * o prevent module from unloading by incrementing use count
528 * o if link is disconnected then initiate connection
530 * Return 0 if O.k. or errno. */
531 static int cycx_netdevice_open(struct net_device *dev)
533 if (netif_running(dev))
534 return -EBUSY; /* only one open is allowed */
536 netif_start_queue(dev);
537 return 0;
540 /* Close network interface.
541 * o reset flags.
542 * o if there's no more open channels then disconnect physical link. */
543 static int cycx_netdevice_stop(struct net_device *dev)
545 struct cycx_x25_channel *chan = dev->priv;
547 netif_stop_queue(dev);
549 if (chan->state == WAN_CONNECTED || chan->state == WAN_CONNECTING)
550 cycx_x25_chan_disconnect(dev);
552 return 0;
555 /* Build media header.
556 * o encapsulate packet according to encapsulation type.
558 * The trick here is to put packet type (Ethertype) into 'protocol' field of
559 * the socket buffer, so that we don't forget it. If encapsulation fails,
560 * set skb->protocol to 0 and discard packet later.
562 * Return: media header length. */
563 static int cycx_netdevice_hard_header(struct sk_buff *skb,
564 struct net_device *dev, u16 type,
565 const void *daddr, const void *saddr,
566 unsigned len)
568 skb->protocol = htons(type);
570 return dev->hard_header_len;
573 /* * Re-build media header.
574 * Return: 1 physical address resolved.
575 * 0 physical address not resolved */
576 static int cycx_netdevice_rebuild_header(struct sk_buff *skb)
578 return 1;
581 /* Send a packet on a network interface.
582 * o set busy flag (marks start of the transmission).
583 * o check link state. If link is not up, then drop the packet.
584 * o check channel status. If it's down then initiate a call.
585 * o pass a packet to corresponding WAN device.
586 * o free socket buffer
588 * Return: 0 complete (socket buffer must be freed)
589 * non-0 packet may be re-transmitted (tbusy must be set)
591 * Notes:
592 * 1. This routine is called either by the protocol stack or by the "net
593 * bottom half" (with interrupts enabled).
594 * 2. Setting tbusy flag will inhibit further transmit requests from the
595 * protocol stack and can be used for flow control with protocol layer. */
596 static int cycx_netdevice_hard_start_xmit(struct sk_buff *skb,
597 struct net_device *dev)
599 struct cycx_x25_channel *chan = dev->priv;
600 struct cycx_device *card = chan->card;
602 if (!chan->svc)
603 chan->protocol = ntohs(skb->protocol);
605 if (card->wandev.state != WAN_CONNECTED)
606 ++chan->ifstats.tx_dropped;
607 else if (chan->svc && chan->protocol &&
608 chan->protocol != ntohs(skb->protocol)) {
609 printk(KERN_INFO
610 "%s: unsupported Ethertype 0x%04X on interface %s!\n",
611 card->devname, ntohs(skb->protocol), dev->name);
612 ++chan->ifstats.tx_errors;
613 } else if (chan->protocol == ETH_P_IP) {
614 switch (chan->state) {
615 case WAN_DISCONNECTED:
616 if (cycx_x25_chan_connect(dev)) {
617 netif_stop_queue(dev);
618 return -EBUSY;
620 /* fall thru */
621 case WAN_CONNECTED:
622 reset_timer(dev);
623 dev->trans_start = jiffies;
624 netif_stop_queue(dev);
626 if (cycx_x25_chan_send(dev, skb))
627 return -EBUSY;
629 break;
630 default:
631 ++chan->ifstats.tx_dropped;
632 ++card->wandev.stats.tx_dropped;
634 } else { /* chan->protocol == ETH_P_X25 */
635 switch (skb->data[0]) {
636 case 0: break;
637 case 1: /* Connect request */
638 cycx_x25_chan_connect(dev);
639 goto free_packet;
640 case 2: /* Disconnect request */
641 cycx_x25_chan_disconnect(dev);
642 goto free_packet;
643 default:
644 printk(KERN_INFO
645 "%s: unknown %d x25-iface request on %s!\n",
646 card->devname, skb->data[0], dev->name);
647 ++chan->ifstats.tx_errors;
648 goto free_packet;
651 skb_pull(skb, 1); /* Remove control byte */
652 reset_timer(dev);
653 dev->trans_start = jiffies;
654 netif_stop_queue(dev);
656 if (cycx_x25_chan_send(dev, skb)) {
657 /* prepare for future retransmissions */
658 skb_push(skb, 1);
659 return -EBUSY;
663 free_packet:
664 dev_kfree_skb(skb);
666 return 0;
669 /* Get Ethernet-style interface statistics.
670 * Return a pointer to struct net_device_stats */
671 static struct net_device_stats *cycx_netdevice_get_stats(struct net_device *dev)
673 struct cycx_x25_channel *chan = dev->priv;
675 return chan ? &chan->ifstats : NULL;
678 /* Interrupt Handlers */
679 /* X.25 Interrupt Service Routine. */
680 static void cycx_x25_irq_handler(struct cycx_device *card)
682 struct cycx_x25_cmd cmd;
683 u16 z = 0;
685 card->in_isr = 1;
686 card->buff_int_mode_unbusy = 0;
687 cycx_peek(&card->hw, X25_RXMBOX_OFFS, &cmd, sizeof(cmd));
689 switch (cmd.command) {
690 case X25_DATA_INDICATION:
691 cycx_x25_irq_rx(card, &cmd);
692 break;
693 case X25_ACK_FROM_VC:
694 cycx_x25_irq_tx(card, &cmd);
695 break;
696 case X25_LOG:
697 cycx_x25_irq_log(card, &cmd);
698 break;
699 case X25_STATISTIC:
700 cycx_x25_irq_stat(card, &cmd);
701 break;
702 case X25_CONNECT_CONFIRM:
703 cycx_x25_irq_connect_confirm(card, &cmd);
704 break;
705 case X25_CONNECT_INDICATION:
706 cycx_x25_irq_connect(card, &cmd);
707 break;
708 case X25_DISCONNECT_INDICATION:
709 cycx_x25_irq_disconnect(card, &cmd);
710 break;
711 case X25_DISCONNECT_CONFIRM:
712 cycx_x25_irq_disconnect_confirm(card, &cmd);
713 break;
714 case X25_LINE_ON:
715 cycx_set_state(card, WAN_CONNECTED);
716 break;
717 case X25_LINE_OFF:
718 cycx_set_state(card, WAN_DISCONNECTED);
719 break;
720 default:
721 cycx_x25_irq_spurious(card, &cmd);
722 break;
725 cycx_poke(&card->hw, 0, &z, sizeof(z));
726 cycx_poke(&card->hw, X25_RXMBOX_OFFS, &z, sizeof(z));
727 card->in_isr = 0;
730 /* Transmit interrupt handler.
731 * o Release socket buffer
732 * o Clear 'tbusy' flag */
733 static void cycx_x25_irq_tx(struct cycx_device *card, struct cycx_x25_cmd *cmd)
735 struct net_device *dev;
736 struct wan_device *wandev = &card->wandev;
737 u8 lcn;
739 cycx_peek(&card->hw, cmd->buf, &lcn, sizeof(lcn));
741 /* unbusy device and then dev_tint(); */
742 dev = cycx_x25_get_dev_by_lcn(wandev, lcn);
743 if (dev) {
744 card->buff_int_mode_unbusy = 1;
745 netif_wake_queue(dev);
746 } else
747 printk(KERN_ERR "%s:ackvc for inexistent lcn %d\n",
748 card->devname, lcn);
751 /* Receive interrupt handler.
752 * This routine handles fragmented IP packets using M-bit according to the
753 * RFC1356.
754 * o map logical channel number to network interface.
755 * o allocate socket buffer or append received packet to the existing one.
756 * o if M-bit is reset (i.e. it's the last packet in a sequence) then
757 * decapsulate packet and pass socket buffer to the protocol stack.
759 * Notes:
760 * 1. When allocating a socket buffer, if M-bit is set then more data is
761 * coming and we have to allocate buffer for the maximum IP packet size
762 * expected on this channel.
763 * 2. If something goes wrong and X.25 packet has to be dropped (e.g. no
764 * socket buffers available) the whole packet sequence must be discarded. */
765 static void cycx_x25_irq_rx(struct cycx_device *card, struct cycx_x25_cmd *cmd)
767 struct wan_device *wandev = &card->wandev;
768 struct net_device *dev;
769 struct cycx_x25_channel *chan;
770 struct sk_buff *skb;
771 u8 bitm, lcn;
772 int pktlen = cmd->len - 5;
774 cycx_peek(&card->hw, cmd->buf, &lcn, sizeof(lcn));
775 cycx_peek(&card->hw, cmd->buf + 4, &bitm, sizeof(bitm));
776 bitm &= 0x10;
778 dev = cycx_x25_get_dev_by_lcn(wandev, lcn);
779 if (!dev) {
780 /* Invalid channel, discard packet */
781 printk(KERN_INFO "%s: receiving on orphaned LCN %d!\n",
782 card->devname, lcn);
783 return;
786 chan = dev->priv;
787 reset_timer(dev);
789 if (chan->drop_sequence) {
790 if (!bitm)
791 chan->drop_sequence = 0;
792 else
793 return;
796 if ((skb = chan->rx_skb) == NULL) {
797 /* Allocate new socket buffer */
798 int bufsize = bitm ? dev->mtu : pktlen;
800 if ((skb = dev_alloc_skb((chan->protocol == ETH_P_X25 ? 1 : 0) +
801 bufsize +
802 dev->hard_header_len)) == NULL) {
803 printk(KERN_INFO "%s: no socket buffers available!\n",
804 card->devname);
805 chan->drop_sequence = 1;
806 ++chan->ifstats.rx_dropped;
807 return;
810 if (chan->protocol == ETH_P_X25) /* X.25 socket layer control */
811 /* 0 = data packet (dev_alloc_skb zeroed skb->data) */
812 skb_put(skb, 1);
814 skb->dev = dev;
815 skb->protocol = htons(chan->protocol);
816 chan->rx_skb = skb;
819 if (skb_tailroom(skb) < pktlen) {
820 /* No room for the packet. Call off the whole thing! */
821 dev_kfree_skb_irq(skb);
822 chan->rx_skb = NULL;
824 if (bitm)
825 chan->drop_sequence = 1;
827 printk(KERN_INFO "%s: unexpectedly long packet sequence "
828 "on interface %s!\n", card->devname, dev->name);
829 ++chan->ifstats.rx_length_errors;
830 return;
833 /* Append packet to the socket buffer */
834 cycx_peek(&card->hw, cmd->buf + 5, skb_put(skb, pktlen), pktlen);
836 if (bitm)
837 return; /* more data is coming */
839 chan->rx_skb = NULL; /* dequeue packet */
841 ++chan->ifstats.rx_packets;
842 chan->ifstats.rx_bytes += pktlen;
844 skb_reset_mac_header(skb);
845 netif_rx(skb);
846 dev->last_rx = jiffies; /* timestamp */
849 /* Connect interrupt handler. */
850 static void cycx_x25_irq_connect(struct cycx_device *card,
851 struct cycx_x25_cmd *cmd)
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;
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);
865 sizerem = sizeloc >> 4;
866 sizeloc &= 0x0F;
868 loc[0] = rem[0] = '\0';
870 if (sizeloc)
871 nibble_to_byte(d, loc, sizeloc, 0);
873 if (sizerem)
874 nibble_to_byte(d + (sizeloc >> 1), rem, sizerem, sizeloc & 1);
876 dprintk(1, KERN_INFO "%s:lcn=%d, local=%s, remote=%s\n",
877 __FUNCTION__, lcn, loc, rem);
879 dev = cycx_x25_get_dev_by_dte_addr(wandev, rem);
880 if (!dev) {
881 /* Invalid channel, discard packet */
882 printk(KERN_INFO "%s: connect not expected: remote %s!\n",
883 card->devname, rem);
884 return;
887 chan = dev->priv;
888 chan->lcn = lcn;
889 cycx_x25_connect_response(card, chan);
890 cycx_x25_set_chan_state(dev, WAN_CONNECTED);
893 /* Connect confirm interrupt handler. */
894 static void cycx_x25_irq_connect_confirm(struct cycx_device *card,
895 struct cycx_x25_cmd *cmd)
897 struct wan_device *wandev = &card->wandev;
898 struct net_device *dev;
899 struct cycx_x25_channel *chan;
900 u8 lcn, key;
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, __FUNCTION__, lcn, key);
907 dev = cycx_x25_get_dev_by_lcn(wandev, -key);
908 if (!dev) {
909 /* Invalid channel, discard packet */
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;
916 clear_bit(--key, (void*)&card->u.x.connection_keys);
917 chan = dev->priv;
918 chan->lcn = lcn;
919 cycx_x25_set_chan_state(dev, WAN_CONNECTED);
922 /* Disconnect confirm interrupt handler. */
923 static void cycx_x25_irq_disconnect_confirm(struct cycx_device *card,
924 struct cycx_x25_cmd *cmd)
926 struct wan_device *wandev = &card->wandev;
927 struct net_device *dev;
928 u8 lcn;
930 cycx_peek(&card->hw, cmd->buf, &lcn, sizeof(lcn));
931 dprintk(1, KERN_INFO "%s: %s:lcn=%d\n",
932 card->devname, __FUNCTION__, lcn);
933 dev = cycx_x25_get_dev_by_lcn(wandev, lcn);
934 if (!dev) {
935 /* Invalid channel, discard packet */
936 printk(KERN_INFO "%s:disconnect confirm not expected!:lcn %d\n",
937 card->devname, lcn);
938 return;
941 cycx_x25_set_chan_state(dev, WAN_DISCONNECTED);
944 /* disconnect interrupt handler. */
945 static void cycx_x25_irq_disconnect(struct cycx_device *card,
946 struct cycx_x25_cmd *cmd)
948 struct wan_device *wandev = &card->wandev;
949 struct net_device *dev;
950 u8 lcn;
952 cycx_peek(&card->hw, cmd->buf, &lcn, sizeof(lcn));
953 dprintk(1, KERN_INFO "%s:lcn=%d\n", __FUNCTION__, lcn);
955 dev = cycx_x25_get_dev_by_lcn(wandev, lcn);
956 if (dev) {
957 struct cycx_x25_channel *chan = dev->priv;
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);
965 /* LOG interrupt handler. */
966 static void cycx_x25_irq_log(struct cycx_device *card, struct cycx_x25_cmd *cmd)
968 #if CYCLOMX_X25_DEBUG
969 char bf[20];
970 u16 size, toread, link, msg_code;
971 u8 code, routine;
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 /* at most 20 bytes are available... thanks to Daniela :) */
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);
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
993 /* STATISTIC interrupt handler. */
994 static void cycx_x25_irq_stat(struct cycx_device *card,
995 struct cycx_x25_cmd *cmd)
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);
1005 /* Spurious interrupt handler.
1006 * o print a warning
1007 * If number of spurious interrupts exceeded some limit, then ??? */
1008 static void cycx_x25_irq_spurious(struct cycx_device *card,
1009 struct cycx_x25_cmd *cmd)
1011 printk(KERN_INFO "%s: spurious interrupt (0x%X)!\n",
1012 card->devname, cmd->command);
1014 #ifdef CYCLOMX_X25_DEBUG
1015 static void hex_dump(char *msg, unsigned char *p, int len)
1017 unsigned char hex[1024],
1018 * phex = hex;
1020 if (len >= (sizeof(hex) / 2))
1021 len = (sizeof(hex) / 2) - 1;
1023 while (len--) {
1024 sprintf(phex, "%02x", *p++);
1025 phex += 2;
1028 printk(KERN_INFO "%s: %s\n", msg, hex);
1030 #endif
1032 /* Cyclom 2X Firmware-Specific Functions */
1033 /* Exec X.25 command. */
1034 static int x25_exec(struct cycx_device *card, int command, int link,
1035 void *d1, int len1, void *d2, int len2)
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;
1043 c.command = command;
1044 c.link = link;
1045 c.len = len1 + len2;
1047 spin_lock_irqsave(&card->u.x.lock, flags);
1049 /* write command */
1050 cycx_poke(&card->hw, X25_MBOX_OFFS, &c, sizeof(c) - sizeof(c.buf));
1052 /* write X.25 data */
1053 if (d1) {
1054 cycx_poke(&card->hw, addr, d1, len1);
1056 if (d2) {
1057 if (len2 > 254) {
1058 u32 addr1 = 0xA00 + 0x400 * link;
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);
1068 /* generate interruption, executing command */
1069 cycx_intr(&card->hw);
1071 /* wait till card->mbox == 0 */
1072 do {
1073 err = cycx_exec(card->mbox);
1074 } while (retry-- && err);
1076 spin_unlock_irqrestore(&card->u.x.lock, flags);
1078 return err;
1081 /* Configure adapter. */
1082 static int cycx_x25_configure(struct cycx_device *card,
1083 struct cycx_x25_config *conf)
1085 struct {
1086 u16 nlinks;
1087 struct cycx_x25_config conf[2];
1088 } x25_cmd_conf;
1090 memset(&x25_cmd_conf, 0, sizeof(x25_cmd_conf));
1091 x25_cmd_conf.nlinks = 2;
1092 x25_cmd_conf.conf[0] = *conf;
1093 /* FIXME: we need to find a way in the wanrouter framework
1094 to configure the second link, for now lets use it
1095 with the same config from the first link, fixing
1096 the interface type to RS232, the speed in 38400 and
1097 the clock to external */
1098 x25_cmd_conf.conf[1] = *conf;
1099 x25_cmd_conf.conf[1].link = 1;
1100 x25_cmd_conf.conf[1].speed = 5; /* 38400 */
1101 x25_cmd_conf.conf[1].clock = 8;
1102 x25_cmd_conf.conf[1].flags = 0; /* default = RS232 */
1104 cycx_x25_dump_config(&x25_cmd_conf.conf[0]);
1105 cycx_x25_dump_config(&x25_cmd_conf.conf[1]);
1107 return x25_exec(card, X25_CONFIG, 0,
1108 &x25_cmd_conf, sizeof(x25_cmd_conf), NULL, 0);
1111 /* Get protocol statistics. */
1112 static int cycx_x25_get_stats(struct cycx_device *card)
1114 /* the firmware expects 20 in the size field!!!
1115 thanks to Daniela */
1116 int err = x25_exec(card, X25_STATISTIC, 0, NULL, 20, NULL, 0);
1118 if (err)
1119 return err;
1121 interruptible_sleep_on(&card->wait_stats);
1123 if (signal_pending(current))
1124 return -EINTR;
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; /* not available from fw */
1130 card->wandev.stats.rx_frame_errors = 0; /* not available from fw */
1131 card->wandev.stats.rx_missed_errors = card->u.x.stats.rx_aborts;
1132 card->wandev.stats.rx_dropped = 0; /* not available from fw */
1133 card->wandev.stats.rx_errors = 0; /* not available from fw */
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; /* not available from fw */
1137 card->wandev.stats.collisions = 0; /* not available from fw */
1138 card->wandev.stats.tx_errors = 0; /* not available from fw */
1140 cycx_x25_dump_devs(&card->wandev);
1142 return 0;
1145 /* return the number of nibbles */
1146 static int byte_to_nibble(u8 *s, u8 *d, char *nibble)
1148 int i = 0;
1150 if (*nibble && *s) {
1151 d[i] |= *s++ - '0';
1152 *nibble = 0;
1153 ++i;
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;
1164 ++i;
1165 s += 2;
1168 return i;
1171 static void nibble_to_byte(u8 *s, u8 *d, u8 len, u8 nibble)
1173 if (nibble) {
1174 *d++ = '0' + (*s++ & 0x0F);
1175 --len;
1178 while (len) {
1179 *d++ = '0' + (*s >> 4);
1181 if (--len) {
1182 *d++ = '0' + (*s & 0x0F);
1183 --len;
1184 } else break;
1186 ++s;
1189 *d = '\0';
1192 /* Place X.25 call. */
1193 static int x25_place_call(struct cycx_device *card,
1194 struct cycx_x25_channel *chan)
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;
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;
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; /* user key */
1216 d[2] = 0x10;
1217 d[4] = 0x0B;
1219 len = byte_to_nibble(chan->addr, d + 6, &nibble);
1221 if (chan->local_addr)
1222 len += byte_to_nibble(chan->local_addr, d + 6 + len, &nibble);
1224 if (nibble)
1225 ++len;
1227 d[5] = mylen << 4 | remotelen;
1228 d[6 + len + 1] = 0xCC; /* TCP/IP over X.25, thanks to Daniela :) */
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;
1236 return err;
1239 /* Place X.25 CONNECT RESPONSE. */
1240 static int cycx_x25_connect_response(struct cycx_device *card,
1241 struct cycx_x25_channel *chan)
1243 u8 d[8];
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; /* TCP/IP over X.25, thanks Daniela */
1251 return x25_exec(card, X25_CONNECT_RESPONSE, chan->link, &d, 8, NULL, 0);
1254 /* Place X.25 DISCONNECT RESPONSE. */
1255 static int cycx_x25_disconnect_response(struct cycx_device *card, u8 link,
1256 u8 lcn)
1258 char d[5];
1260 memset(d, 0, sizeof(d));
1261 d[0] = d[3] = lcn;
1262 d[2] = 0x10;
1263 d[4] = 0x17;
1265 return x25_exec(card, X25_DISCONNECT_RESPONSE, link, &d, 5, NULL, 0);
1268 /* Clear X.25 call. */
1269 static int x25_clear_call(struct cycx_device *card, u8 link, u8 lcn, u8 cause,
1270 u8 diagn)
1272 u8 d[7];
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;
1281 return x25_exec(card, X25_DISCONNECT_REQUEST, link, d, 7, NULL, 0);
1284 /* Send X.25 data packet. */
1285 static int cycx_x25_send(struct cycx_device *card, u8 link, u8 lcn, u8 bitm,
1286 int len, void *buf)
1288 u8 d[] = "?\xFF\x10??";
1290 d[0] = d[3] = lcn;
1291 d[4] = bitm;
1293 return x25_exec(card, X25_DATA_REQUEST, link, &d, 5, buf, len);
1296 /* Miscellaneous */
1297 /* Find network device by its channel number. */
1298 static struct net_device *cycx_x25_get_dev_by_lcn(struct wan_device *wandev,
1299 s16 lcn)
1301 struct net_device *dev = wandev->dev;
1302 struct cycx_x25_channel *chan;
1304 while (dev) {
1305 chan = (struct cycx_x25_channel*)dev->priv;
1307 if (chan->lcn == lcn)
1308 break;
1309 dev = chan->slave;
1311 return dev;
1314 /* Find network device by its remote dte address. */
1315 static struct net_device *
1316 cycx_x25_get_dev_by_dte_addr(struct wan_device *wandev, char *dte)
1318 struct net_device *dev = wandev->dev;
1319 struct cycx_x25_channel *chan;
1321 while (dev) {
1322 chan = (struct cycx_x25_channel*)dev->priv;
1324 if (!strcmp(chan->addr, dte))
1325 break;
1326 dev = chan->slave;
1328 return dev;
1331 /* Initiate connection on the logical channel.
1332 * o for PVC we just get channel configuration
1333 * o for SVCs place an X.25 call
1335 * Return: 0 connected
1336 * >0 connection in progress
1337 * <0 failure */
1338 static int cycx_x25_chan_connect(struct net_device *dev)
1340 struct cycx_x25_channel *chan = dev->priv;
1341 struct cycx_device *card = chan->card;
1343 if (chan->svc) {
1344 if (!chan->addr[0])
1345 return -EINVAL; /* no destination address */
1347 dprintk(1, KERN_INFO "%s: placing X.25 call to %s...\n",
1348 card->devname, chan->addr);
1350 if (x25_place_call(card, chan))
1351 return -EIO;
1353 cycx_x25_set_chan_state(dev, WAN_CONNECTING);
1354 return 1;
1355 } else
1356 cycx_x25_set_chan_state(dev, WAN_CONNECTED);
1358 return 0;
1361 /* Disconnect logical channel.
1362 * o if SVC then clear X.25 call */
1363 static void cycx_x25_chan_disconnect(struct net_device *dev)
1365 struct cycx_x25_channel *chan = dev->priv;
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);
1374 /* Called by kernel timer */
1375 static void cycx_x25_chan_timer(unsigned long d)
1377 struct net_device *dev = (struct net_device *)d;
1378 struct cycx_x25_channel *chan = dev->priv;
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, __FUNCTION__, dev->name);
1387 /* Set logical channel state. */
1388 static void cycx_x25_set_chan_state(struct net_device *dev, u8 state)
1390 struct cycx_x25_channel *chan = dev->priv;
1391 struct cycx_device *card = chan->card;
1392 unsigned long flags;
1393 char *string_state = NULL;
1395 spin_lock_irqsave(&card->lock, flags);
1397 if (chan->state != state) {
1398 if (chan->svc && chan->state == WAN_CONNECTED)
1399 del_timer(&chan->timer);
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);
1408 if (chan->protocol == ETH_P_X25)
1409 cycx_x25_chan_send_event(dev, 1);
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!";
1421 if (chan->svc) {
1422 *(unsigned short*)dev->dev_addr = 0;
1423 chan->lcn = 0;
1426 if (chan->protocol == ETH_P_X25)
1427 cycx_x25_chan_send_event(dev, 2);
1429 netif_wake_queue(dev);
1430 break;
1433 printk(KERN_INFO "%s: interface %s %s\n", card->devname,
1434 dev->name, string_state);
1435 chan->state = state;
1438 spin_unlock_irqrestore(&card->lock, flags);
1441 /* Send packet on a logical channel.
1442 * When this function is called, tx_skb field of the channel data space
1443 * points to the transmit socket buffer. When transmission is complete,
1444 * release socket buffer and reset 'tbusy' flag.
1446 * Return: 0 - transmission complete
1447 * 1 - busy
1449 * Notes:
1450 * 1. If packet length is greater than MTU for this channel, we'll fragment
1451 * the packet into 'complete sequence' using M-bit.
1452 * 2. When transmission is complete, an event notification should be issued
1453 * to the router. */
1454 static int cycx_x25_chan_send(struct net_device *dev, struct sk_buff *skb)
1456 struct cycx_x25_channel *chan = dev->priv;
1457 struct cycx_device *card = chan->card;
1458 int bitm = 0; /* final packet */
1459 unsigned len = skb->len;
1461 if (skb->len > card->wandev.mtu) {
1462 len = card->wandev.mtu;
1463 bitm = 0x10; /* set M-bit (more data) */
1466 if (cycx_x25_send(card, chan->link, chan->lcn, bitm, len, skb->data))
1467 return 1;
1469 if (bitm) {
1470 skb_pull(skb, len);
1471 return 1;
1474 ++chan->ifstats.tx_packets;
1475 chan->ifstats.tx_bytes += len;
1477 return 0;
1480 /* Send event (connection, disconnection, etc) to X.25 socket layer */
1482 static void cycx_x25_chan_send_event(struct net_device *dev, u8 event)
1484 struct sk_buff *skb;
1485 unsigned char *ptr;
1487 if ((skb = dev_alloc_skb(1)) == NULL) {
1488 printk(KERN_ERR "%s: out of memory\n", __FUNCTION__);
1489 return;
1492 ptr = skb_put(skb, 1);
1493 *ptr = event;
1495 skb->protocol = x25_type_trans(skb, dev);
1496 netif_rx(skb);
1497 dev->last_rx = jiffies; /* timestamp */
1500 /* Convert line speed in bps to a number used by cyclom 2x code. */
1501 static u8 bps_to_speed_code(u32 bps)
1503 u8 number = 0; /* defaults to the lowest (1200) speed ;> */
1505 if (bps >= 512000) number = 8;
1506 else if (bps >= 256000) number = 7;
1507 else if (bps >= 64000) number = 6;
1508 else if (bps >= 38400) number = 5;
1509 else if (bps >= 19200) number = 4;
1510 else if (bps >= 9600) number = 3;
1511 else if (bps >= 4800) number = 2;
1512 else if (bps >= 2400) number = 1;
1514 return number;
1517 /* log base 2 */
1518 static u8 cycx_log2(u32 n)
1520 u8 log = 0;
1522 if (!n)
1523 return 0;
1525 while (n > 1) {
1526 n >>= 1;
1527 ++log;
1530 return log;
1533 /* Convert decimal string to unsigned integer.
1534 * If len != 0 then only 'len' characters of the string are converted. */
1535 static unsigned dec_to_uint(u8 *str, int len)
1537 unsigned val = 0;
1539 if (!len)
1540 len = strlen(str);
1542 for (; len && isdigit(*str); ++str, --len)
1543 val = (val * 10) + (*str - (unsigned) '0');
1545 return val;
1548 static void reset_timer(struct net_device *dev)
1550 struct cycx_x25_channel *chan = dev->priv;
1552 if (chan->svc)
1553 mod_timer(&chan->timer, jiffies+chan->idle_tmout*HZ);
1555 #ifdef CYCLOMX_X25_DEBUG
1556 static void cycx_x25_dump_config(struct cycx_x25_config *conf)
1558 printk(KERN_INFO "X.25 configuration\n");
1559 printk(KERN_INFO "-----------------\n");
1560 printk(KERN_INFO "link number=%d\n", conf->link);
1561 printk(KERN_INFO "line speed=%d\n", conf->speed);
1562 printk(KERN_INFO "clock=%sternal\n", conf->clock == 8 ? "Ex" : "In");
1563 printk(KERN_INFO "# level 2 retransm.=%d\n", conf->n2);
1564 printk(KERN_INFO "level 2 window=%d\n", conf->n2win);
1565 printk(KERN_INFO "level 3 window=%d\n", conf->n3win);
1566 printk(KERN_INFO "# logical channels=%d\n", conf->nvc);
1567 printk(KERN_INFO "level 3 pkt len=%d\n", conf->pktlen);
1568 printk(KERN_INFO "my address=%d\n", conf->locaddr);
1569 printk(KERN_INFO "remote address=%d\n", conf->remaddr);
1570 printk(KERN_INFO "t1=%d seconds\n", conf->t1);
1571 printk(KERN_INFO "t2=%d seconds\n", conf->t2);
1572 printk(KERN_INFO "t21=%d seconds\n", conf->t21);
1573 printk(KERN_INFO "# PVCs=%d\n", conf->npvc);
1574 printk(KERN_INFO "t23=%d seconds\n", conf->t23);
1575 printk(KERN_INFO "flags=0x%x\n", conf->flags);
1578 static void cycx_x25_dump_stats(struct cycx_x25_stats *stats)
1580 printk(KERN_INFO "X.25 statistics\n");
1581 printk(KERN_INFO "--------------\n");
1582 printk(KERN_INFO "rx_crc_errors=%d\n", stats->rx_crc_errors);
1583 printk(KERN_INFO "rx_over_errors=%d\n", stats->rx_over_errors);
1584 printk(KERN_INFO "n2_tx_frames=%d\n", stats->n2_tx_frames);
1585 printk(KERN_INFO "n2_rx_frames=%d\n", stats->n2_rx_frames);
1586 printk(KERN_INFO "tx_timeouts=%d\n", stats->tx_timeouts);
1587 printk(KERN_INFO "rx_timeouts=%d\n", stats->rx_timeouts);
1588 printk(KERN_INFO "n3_tx_packets=%d\n", stats->n3_tx_packets);
1589 printk(KERN_INFO "n3_rx_packets=%d\n", stats->n3_rx_packets);
1590 printk(KERN_INFO "tx_aborts=%d\n", stats->tx_aborts);
1591 printk(KERN_INFO "rx_aborts=%d\n", stats->rx_aborts);
1594 static void cycx_x25_dump_devs(struct wan_device *wandev)
1596 struct net_device *dev = wandev->dev;
1598 printk(KERN_INFO "X.25 dev states\n");
1599 printk(KERN_INFO "name: addr: txoff: protocol:\n");
1600 printk(KERN_INFO "---------------------------------------\n");
1602 while(dev) {
1603 struct cycx_x25_channel *chan = dev->priv;
1605 printk(KERN_INFO "%-5.5s %-15.15s %d ETH_P_%s\n",
1606 chan->name, chan->addr, netif_queue_stopped(dev),
1607 chan->protocol == ETH_P_IP ? "IP" : "X25");
1608 dev = chan->slave;
1612 #endif /* CYCLOMX_X25_DEBUG */
1613 /* End */