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
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,
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
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
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,
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
54 * 1999/01/05 acme pktlen now (correctly) uses log2 (value
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/sched.h>
88 #include <linux/slab.h> /* kmalloc(), kfree() */
89 #include <linux/stddef.h> /* offsetof(), etc. */
90 #include <linux/wanrouter.h> /* WAN router definitions */
92 #include <asm/byteorder.h> /* htons(), etc. */
94 #include <linux/cyclomx.h> /* Cyclom 2X common user API definitions */
95 #include <linux/cycx_x25.h> /* X.25 firmware API definitions */
97 #include <net/x25device.h>
99 /* Defines & Macros */
100 #define CYCX_X25_MAX_CMD_RETRY 5
101 #define CYCX_X25_CHAN_MTU 2048 /* unfragmented logical channel MTU */
103 /* Data Structures */
104 /* This is an extension of the 'struct net_device' we create for each network
105 interface to keep the rest of X.25 channel-specific data. */
106 struct cycx_x25_channel
{
107 /* This member must be first. */
108 struct net_device
*slave
; /* WAN slave */
110 char name
[WAN_IFNAME_SZ
+1]; /* interface name, ASCIIZ */
111 char addr
[WAN_ADDRESS_SZ
+1]; /* media address, ASCIIZ */
112 char *local_addr
; /* local media address, ASCIIZ -
113 svc thru crossover cable */
114 s16 lcn
; /* logical channel number/conn.req.key*/
116 struct timer_list timer
; /* timer used for svc channel disc. */
117 u16 protocol
; /* ethertype, 0 - multiplexed */
118 u8 svc
; /* 0 - permanent, 1 - switched */
119 u8 state
; /* channel state */
120 u8 drop_sequence
; /* mark sequence for dropping */
121 u32 idle_tmout
; /* sec, before disconnecting */
122 struct sk_buff
*rx_skb
; /* receive socket buffer */
123 struct cycx_device
*card
; /* -> owner */
124 struct net_device_stats ifstats
;/* interface statistics */
127 /* Function Prototypes */
128 /* WAN link driver entry points. These are called by the WAN router module. */
129 static int cycx_wan_update(struct wan_device
*wandev
),
130 cycx_wan_new_if(struct wan_device
*wandev
, struct net_device
*dev
,
132 cycx_wan_del_if(struct wan_device
*wandev
, struct net_device
*dev
);
134 /* Network device interface */
135 static int cycx_netdevice_init(struct net_device
*dev
);
136 static int cycx_netdevice_open(struct net_device
*dev
);
137 static int cycx_netdevice_stop(struct net_device
*dev
);
138 static int cycx_netdevice_hard_header(struct sk_buff
*skb
,
139 struct net_device
*dev
, u16 type
,
140 const void *daddr
, const void *saddr
,
142 static int cycx_netdevice_rebuild_header(struct sk_buff
*skb
);
143 static netdev_tx_t
cycx_netdevice_hard_start_xmit(struct sk_buff
*skb
,
144 struct net_device
*dev
);
146 static struct net_device_stats
*
147 cycx_netdevice_get_stats(struct net_device
*dev
);
149 /* Interrupt handlers */
150 static 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
);
168 /* X.25 firmware interface functions */
169 static 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
,
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
,
179 /* channel functions */
180 static int cycx_x25_chan_connect(struct net_device
*dev
),
181 cycx_x25_chan_send(struct net_device
*dev
, struct sk_buff
*skb
);
183 static void cycx_x25_chan_disconnect(struct net_device
*dev
),
184 cycx_x25_chan_send_event(struct net_device
*dev
, u8 event
);
186 /* Miscellaneous functions */
187 static void cycx_x25_set_chan_state(struct net_device
*dev
, u8 state
),
188 cycx_x25_chan_timer(unsigned long d
);
190 static void nibble_to_byte(u8
*s
, u8
*d
, u8 len
, u8 nibble
),
191 reset_timer(struct net_device
*dev
);
193 static u8
bps_to_speed_code(u32 bps
);
194 static u8
cycx_log2(u32 n
);
196 static unsigned dec_to_uint(u8
*str
, int len
);
198 static struct net_device
*cycx_x25_get_dev_by_lcn(struct wan_device
*wandev
,
200 static struct net_device
*
201 cycx_x25_get_dev_by_dte_addr(struct wan_device
*wandev
, char *dte
);
203 static void cycx_x25_chan_setup(struct net_device
*dev
);
205 #ifdef CYCLOMX_X25_DEBUG
206 static void hex_dump(char *msg
, unsigned char *p
, int len
);
207 static void cycx_x25_dump_config(struct cycx_x25_config
*conf
);
208 static void cycx_x25_dump_stats(struct cycx_x25_stats
*stats
);
209 static void cycx_x25_dump_devs(struct wan_device
*wandev
);
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)
216 /* Public Functions */
218 /* X.25 Protocol Initialization routine.
220 * This routine is called by the main Cyclom 2X module during setup. At this
221 * point adapter is completely initialized and X.25 firmware is running.
222 * o configure adapter
223 * o initialize protocol-specific fields of the adapter data space.
227 int cycx_x25_wan_init(struct cycx_device
*card
, wandev_conf_t
*conf
)
229 struct cycx_x25_config cfg
;
231 /* Verify configuration ID */
232 if (conf
->config_id
!= WANCONFIG_X25
) {
233 printk(KERN_INFO
"%s: invalid configuration ID %u!\n",
234 card
->devname
, conf
->config_id
);
238 /* Initialize protocol-specific fields */
239 card
->mbox
= card
->hw
.dpmbase
+ X25_MBOX_OFFS
;
240 card
->u
.x
.connection_keys
= 0;
241 spin_lock_init(&card
->u
.x
.lock
);
243 /* Configure adapter. Here we set reasonable defaults, then parse
244 * device configuration structure and set configuration options.
245 * Most configuration options are verified and corrected (if
246 * necessary) since we can't rely on the adapter to do so and don't
247 * want it to fail either. */
248 memset(&cfg
, 0, sizeof(cfg
));
250 cfg
.clock
= conf
->clocking
== WANOPT_EXTERNAL
? 8 : 55;
251 cfg
.speed
= bps_to_speed_code(conf
->bps
);
257 cfg
.flags
= 0x02; /* default = V35 */
258 cfg
.t1
= 10; /* line carrier timeout */
259 cfg
.t2
= 29; /* tx timeout */
260 cfg
.t21
= 180; /* CALL timeout */
261 cfg
.t23
= 180; /* CLEAR timeout */
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;
271 card
->wandev
.mtu
= 64;
273 cfg
.pktlen
= cycx_log2(card
->wandev
.mtu
);
275 if (conf
->station
== WANOPT_DTE
) {
276 cfg
.locaddr
= 3; /* DTE */
277 cfg
.remaddr
= 1; /* DCE */
279 cfg
.locaddr
= 1; /* DCE */
280 cfg
.remaddr
= 3; /* DTE */
283 if (conf
->interface
== WANOPT_RS232
)
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
);
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
);
296 if (card
->u
.x
.lo_pvc
== 255)
299 cfg
.npvc
= card
->u
.x
.hi_pvc
- card
->u
.x
.lo_pvc
+ 1;
301 cfg
.nvc
= card
->u
.x
.hi_svc
- card
->u
.x
.lo_svc
+ 1 + cfg
.npvc
;
303 if (conf
->u
.x25
.hdlc_window
)
304 cfg
.n2win
= min_t(unsigned int, conf
->u
.x25
.hdlc_window
, 7);
306 if (conf
->u
.x25
.pkt_window
)
307 cfg
.n3win
= min_t(unsigned int, conf
->u
.x25
.pkt_window
, 7);
310 cfg
.t1
= min_t(unsigned int, conf
->u
.x25
.t1
, 30);
313 cfg
.t2
= min_t(unsigned int, conf
->u
.x25
.t2
, 30);
315 if (conf
->u
.x25
.t11_t21
)
316 cfg
.t21
= min_t(unsigned int, conf
->u
.x25
.t11_t21
, 30);
318 if (conf
->u
.x25
.t13_t23
)
319 cfg
.t23
= min_t(unsigned int, conf
->u
.x25
.t13_t23
, 30);
322 cfg
.n2
= min_t(unsigned int, conf
->u
.x25
.n2
, 30);
324 /* initialize adapter */
325 if (cycx_x25_configure(card
, &cfg
))
328 /* Initialize protocol-specific fields of adapter data space */
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
;
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
;
343 /* WAN Device Driver Entry Points */
344 /* Update device status & statistics. */
345 static int cycx_wan_update(struct wan_device
*wandev
)
348 if (!wandev
|| !wandev
->private)
351 if (wandev
->state
== WAN_UNCONFIGURED
)
354 cycx_x25_get_stats(wandev
->private);
359 /* Create new logical channel.
360 * This routine is called by the router when ROUTER_IFNEW IOCTL is being
362 * o parse media- and hardware-specific configuration
363 * o make sure that a new channel can be created
364 * o allocate resources, if necessary
365 * o prepare network device structure for registration.
368 * < 0 failure (channel will not be created) */
369 static int cycx_wan_new_if(struct wan_device
*wandev
, struct net_device
*dev
,
372 struct cycx_device
*card
= wandev
->private;
373 struct cycx_x25_channel
*chan
;
376 if (!conf
->name
[0] || strlen(conf
->name
) > WAN_IFNAME_SZ
) {
377 printk(KERN_INFO
"%s: invalid interface name!\n",
382 dev
= alloc_netdev(sizeof(struct cycx_x25_channel
), conf
->name
,
383 cycx_x25_chan_setup
);
387 chan
= netdev_priv(dev
);
388 strcpy(chan
->name
, conf
->name
);
390 chan
->link
= conf
->port
;
391 chan
->protocol
= conf
->protocol
? ETH_P_X25
: ETH_P_IP
;
393 /* only used in svc connected thru crossover cable */
394 chan
->local_addr
= NULL
;
396 if (conf
->addr
[0] == '@') { /* SVC */
397 int len
= strlen(conf
->local_addr
);
400 if (len
> WAN_ADDRESS_SZ
) {
401 printk(KERN_ERR
"%s: %s local addr too long!\n",
402 wandev
->name
, chan
->name
);
406 chan
->local_addr
= kmalloc(len
+ 1, GFP_KERNEL
);
408 if (!chan
->local_addr
) {
414 strncpy(chan
->local_addr
, conf
->local_addr
,
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
;
424 /* Set channel timeouts (default if not specified) */
425 chan
->idle_tmout
= conf
->idle_timeout
? conf
->idle_timeout
: 90;
426 } else if (isdigit(conf
->addr
[0])) { /* PVC */
427 s16 lcn
= dec_to_uint(conf
->addr
, 0);
429 if (lcn
>= card
->u
.x
.lo_pvc
&& lcn
<= card
->u
.x
.hi_pvc
)
433 "%s: PVC %u is out of range on interface %s!\n",
434 wandev
->name
, lcn
, chan
->name
);
439 printk(KERN_ERR
"%s: invalid media address on interface %s!\n",
440 wandev
->name
, chan
->name
);
452 /* Delete logical channel. */
453 static int cycx_wan_del_if(struct wan_device
*wandev
, struct net_device
*dev
)
455 struct cycx_x25_channel
*chan
= netdev_priv(dev
);
458 kfree(chan
->local_addr
);
459 if (chan
->state
== WAN_CONNECTED
)
460 del_timer(&chan
->timer
);
467 /* Network Device Interface */
469 static const struct header_ops cycx_header_ops
= {
470 .create
= cycx_netdevice_hard_header
,
471 .rebuild
= cycx_netdevice_rebuild_header
,
474 static 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
,
482 static void cycx_x25_chan_setup(struct net_device
*dev
)
484 /* Initialize device driver entry points */
485 dev
->netdev_ops
= &cycx_netdev_ops
;
486 dev
->header_ops
= &cycx_header_ops
;
488 /* Initialize media-specific parameters */
489 dev
->mtu
= CYCX_X25_CHAN_MTU
;
490 dev
->type
= ARPHRD_HWX25
; /* ARP h/w type */
491 dev
->hard_header_len
= 0; /* media header length */
492 dev
->addr_len
= 0; /* hardware address length */
495 /* Initialize Linux network interface.
497 * This routine is called only once for each interface, during Linux network
498 * interface registration. Returning anything but zero will fail interface
500 static int cycx_netdevice_init(struct net_device
*dev
)
502 struct cycx_x25_channel
*chan
= netdev_priv(dev
);
503 struct cycx_device
*card
= chan
->card
;
504 struct wan_device
*wandev
= &card
->wandev
;
507 *(__be16
*)dev
->dev_addr
= htons(chan
->lcn
);
509 /* Initialize hardware parameters (just for reference) */
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
+
516 dev
->flags
|= IFF_NOARP
;
518 /* Set transmit buffer queue length */
519 dev
->tx_queue_len
= 10;
521 /* Initialize socket buffers */
522 cycx_x25_set_chan_state(dev
, WAN_DISCONNECTED
);
527 /* Open network interface.
528 * o prevent module from unloading by incrementing use count
529 * o if link is disconnected then initiate connection
531 * Return 0 if O.k. or errno. */
532 static int cycx_netdevice_open(struct net_device
*dev
)
534 if (netif_running(dev
))
535 return -EBUSY
; /* only one open is allowed */
537 netif_start_queue(dev
);
541 /* Close network interface.
543 * o if there's no more open channels then disconnect physical link. */
544 static int cycx_netdevice_stop(struct net_device
*dev
)
546 struct cycx_x25_channel
*chan
= netdev_priv(dev
);
548 netif_stop_queue(dev
);
550 if (chan
->state
== WAN_CONNECTED
|| chan
->state
== WAN_CONNECTING
)
551 cycx_x25_chan_disconnect(dev
);
556 /* Build media header.
557 * o encapsulate packet according to encapsulation type.
559 * The trick here is to put packet type (Ethertype) into 'protocol' field of
560 * the socket buffer, so that we don't forget it. If encapsulation fails,
561 * set skb->protocol to 0 and discard packet later.
563 * Return: media header length. */
564 static int cycx_netdevice_hard_header(struct sk_buff
*skb
,
565 struct net_device
*dev
, u16 type
,
566 const void *daddr
, const void *saddr
,
569 skb
->protocol
= htons(type
);
571 return dev
->hard_header_len
;
574 /* * Re-build media header.
575 * Return: 1 physical address resolved.
576 * 0 physical address not resolved */
577 static int cycx_netdevice_rebuild_header(struct sk_buff
*skb
)
582 /* Send a packet on a network interface.
583 * o set busy flag (marks start of the transmission).
584 * o check link state. If link is not up, then drop the packet.
585 * o check channel status. If it's down then initiate a call.
586 * o pass a packet to corresponding WAN device.
587 * o free socket buffer
589 * Return: 0 complete (socket buffer must be freed)
590 * non-0 packet may be re-transmitted (tbusy must be set)
593 * 1. This routine is called either by the protocol stack or by the "net
594 * bottom half" (with interrupts enabled).
595 * 2. Setting tbusy flag will inhibit further transmit requests from the
596 * protocol stack and can be used for flow control with protocol layer. */
597 static netdev_tx_t
cycx_netdevice_hard_start_xmit(struct sk_buff
*skb
,
598 struct net_device
*dev
)
600 struct cycx_x25_channel
*chan
= netdev_priv(dev
);
601 struct cycx_device
*card
= chan
->card
;
604 chan
->protocol
= ntohs(skb
->protocol
);
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
)) {
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
;
624 dev
->trans_start
= jiffies
;
625 netif_stop_queue(dev
);
627 if (cycx_x25_chan_send(dev
, skb
))
628 return NETDEV_TX_BUSY
;
632 ++chan
->ifstats
.tx_dropped
;
633 ++card
->wandev
.stats
.tx_dropped
;
635 } else { /* chan->protocol == ETH_P_X25 */
636 switch (skb
->data
[0]) {
639 case X25_IFACE_CONNECT
:
640 cycx_x25_chan_connect(dev
);
642 case X25_IFACE_DISCONNECT
:
643 cycx_x25_chan_disconnect(dev
);
647 "%s: unknown %d x25-iface request on %s!\n",
648 card
->devname
, skb
->data
[0], dev
->name
);
649 ++chan
->ifstats
.tx_errors
;
653 skb_pull(skb
, 1); /* Remove control byte */
655 dev
->trans_start
= jiffies
;
656 netif_stop_queue(dev
);
658 if (cycx_x25_chan_send(dev
, skb
)) {
659 /* prepare for future retransmissions */
661 return NETDEV_TX_BUSY
;
671 /* Get Ethernet-style interface statistics.
672 * Return a pointer to struct net_device_stats */
673 static struct net_device_stats
*cycx_netdevice_get_stats(struct net_device
*dev
)
675 struct cycx_x25_channel
*chan
= netdev_priv(dev
);
677 return chan
? &chan
->ifstats
: NULL
;
680 /* Interrupt Handlers */
681 /* X.25 Interrupt Service Routine. */
682 static void cycx_x25_irq_handler(struct cycx_device
*card
)
684 struct cycx_x25_cmd cmd
;
688 card
->buff_int_mode_unbusy
= 0;
689 cycx_peek(&card
->hw
, X25_RXMBOX_OFFS
, &cmd
, sizeof(cmd
));
691 switch (cmd
.command
) {
692 case X25_DATA_INDICATION
:
693 cycx_x25_irq_rx(card
, &cmd
);
695 case X25_ACK_FROM_VC
:
696 cycx_x25_irq_tx(card
, &cmd
);
699 cycx_x25_irq_log(card
, &cmd
);
702 cycx_x25_irq_stat(card
, &cmd
);
704 case X25_CONNECT_CONFIRM
:
705 cycx_x25_irq_connect_confirm(card
, &cmd
);
707 case X25_CONNECT_INDICATION
:
708 cycx_x25_irq_connect(card
, &cmd
);
710 case X25_DISCONNECT_INDICATION
:
711 cycx_x25_irq_disconnect(card
, &cmd
);
713 case X25_DISCONNECT_CONFIRM
:
714 cycx_x25_irq_disconnect_confirm(card
, &cmd
);
717 cycx_set_state(card
, WAN_CONNECTED
);
720 cycx_set_state(card
, WAN_DISCONNECTED
);
723 cycx_x25_irq_spurious(card
, &cmd
);
727 cycx_poke(&card
->hw
, 0, &z
, sizeof(z
));
728 cycx_poke(&card
->hw
, X25_RXMBOX_OFFS
, &z
, sizeof(z
));
732 /* Transmit interrupt handler.
733 * o Release socket buffer
734 * o Clear 'tbusy' flag */
735 static void cycx_x25_irq_tx(struct cycx_device
*card
, struct cycx_x25_cmd
*cmd
)
737 struct net_device
*dev
;
738 struct wan_device
*wandev
= &card
->wandev
;
741 cycx_peek(&card
->hw
, cmd
->buf
, &lcn
, sizeof(lcn
));
743 /* unbusy device and then dev_tint(); */
744 dev
= cycx_x25_get_dev_by_lcn(wandev
, lcn
);
746 card
->buff_int_mode_unbusy
= 1;
747 netif_wake_queue(dev
);
749 printk(KERN_ERR
"%s:ackvc for inexistent lcn %d\n",
753 /* Receive interrupt handler.
754 * This routine handles fragmented IP packets using M-bit according to the
756 * o map logical channel number to network interface.
757 * o allocate socket buffer or append received packet to the existing one.
758 * o if M-bit is reset (i.e. it's the last packet in a sequence) then
759 * decapsulate packet and pass socket buffer to the protocol stack.
762 * 1. When allocating a socket buffer, if M-bit is set then more data is
763 * coming and we have to allocate buffer for the maximum IP packet size
764 * expected on this channel.
765 * 2. If something goes wrong and X.25 packet has to be dropped (e.g. no
766 * socket buffers available) the whole packet sequence must be discarded. */
767 static void cycx_x25_irq_rx(struct cycx_device
*card
, struct cycx_x25_cmd
*cmd
)
769 struct wan_device
*wandev
= &card
->wandev
;
770 struct net_device
*dev
;
771 struct cycx_x25_channel
*chan
;
774 int pktlen
= cmd
->len
- 5;
776 cycx_peek(&card
->hw
, cmd
->buf
, &lcn
, sizeof(lcn
));
777 cycx_peek(&card
->hw
, cmd
->buf
+ 4, &bitm
, sizeof(bitm
));
780 dev
= cycx_x25_get_dev_by_lcn(wandev
, lcn
);
782 /* Invalid channel, discard packet */
783 printk(KERN_INFO
"%s: receiving on orphaned LCN %d!\n",
788 chan
= netdev_priv(dev
);
791 if (chan
->drop_sequence
) {
793 chan
->drop_sequence
= 0;
798 if ((skb
= chan
->rx_skb
) == NULL
) {
799 /* Allocate new socket buffer */
800 int bufsize
= bitm
? dev
->mtu
: pktlen
;
802 if ((skb
= dev_alloc_skb((chan
->protocol
== ETH_P_X25
? 1 : 0) +
804 dev
->hard_header_len
)) == NULL
) {
805 printk(KERN_INFO
"%s: no socket buffers available!\n",
807 chan
->drop_sequence
= 1;
808 ++chan
->ifstats
.rx_dropped
;
812 if (chan
->protocol
== ETH_P_X25
) /* X.25 socket layer control */
813 /* 0 = data packet (dev_alloc_skb zeroed skb->data) */
817 skb
->protocol
= htons(chan
->protocol
);
821 if (skb_tailroom(skb
) < pktlen
) {
822 /* No room for the packet. Call off the whole thing! */
823 dev_kfree_skb_irq(skb
);
827 chan
->drop_sequence
= 1;
829 printk(KERN_INFO
"%s: unexpectedly long packet sequence "
830 "on interface %s!\n", card
->devname
, dev
->name
);
831 ++chan
->ifstats
.rx_length_errors
;
835 /* Append packet to the socket buffer */
836 cycx_peek(&card
->hw
, cmd
->buf
+ 5, skb_put(skb
, pktlen
), pktlen
);
839 return; /* more data is coming */
841 chan
->rx_skb
= NULL
; /* dequeue packet */
843 ++chan
->ifstats
.rx_packets
;
844 chan
->ifstats
.rx_bytes
+= pktlen
;
846 skb_reset_mac_header(skb
);
850 /* Connect interrupt handler. */
851 static void cycx_x25_irq_connect(struct cycx_device
*card
,
852 struct cycx_x25_cmd
*cmd
)
854 struct wan_device
*wandev
= &card
->wandev
;
855 struct net_device
*dev
= NULL
;
856 struct cycx_x25_channel
*chan
;
860 u8 lcn
, sizeloc
, sizerem
;
862 cycx_peek(&card
->hw
, cmd
->buf
, &lcn
, sizeof(lcn
));
863 cycx_peek(&card
->hw
, cmd
->buf
+ 5, &sizeloc
, sizeof(sizeloc
));
864 cycx_peek(&card
->hw
, cmd
->buf
+ 6, d
, cmd
->len
- 6);
866 sizerem
= sizeloc
>> 4;
869 loc
[0] = rem
[0] = '\0';
872 nibble_to_byte(d
, loc
, sizeloc
, 0);
875 nibble_to_byte(d
+ (sizeloc
>> 1), rem
, sizerem
, sizeloc
& 1);
877 dprintk(1, KERN_INFO
"%s:lcn=%d, local=%s, remote=%s\n",
878 __func__
, lcn
, loc
, rem
);
880 dev
= cycx_x25_get_dev_by_dte_addr(wandev
, rem
);
882 /* Invalid channel, discard packet */
883 printk(KERN_INFO
"%s: connect not expected: remote %s!\n",
888 chan
= netdev_priv(dev
);
890 cycx_x25_connect_response(card
, chan
);
891 cycx_x25_set_chan_state(dev
, WAN_CONNECTED
);
894 /* Connect confirm interrupt handler. */
895 static void cycx_x25_irq_connect_confirm(struct cycx_device
*card
,
896 struct cycx_x25_cmd
*cmd
)
898 struct wan_device
*wandev
= &card
->wandev
;
899 struct net_device
*dev
;
900 struct cycx_x25_channel
*chan
;
903 cycx_peek(&card
->hw
, cmd
->buf
, &lcn
, sizeof(lcn
));
904 cycx_peek(&card
->hw
, cmd
->buf
+ 1, &key
, sizeof(key
));
905 dprintk(1, KERN_INFO
"%s: %s:lcn=%d, key=%d\n",
906 card
->devname
, __func__
, lcn
, key
);
908 dev
= cycx_x25_get_dev_by_lcn(wandev
, -key
);
910 /* Invalid channel, discard packet */
911 clear_bit(--key
, (void*)&card
->u
.x
.connection_keys
);
912 printk(KERN_INFO
"%s: connect confirm not expected: lcn %d, "
913 "key=%d!\n", card
->devname
, lcn
, key
);
917 clear_bit(--key
, (void*)&card
->u
.x
.connection_keys
);
918 chan
= netdev_priv(dev
);
920 cycx_x25_set_chan_state(dev
, WAN_CONNECTED
);
923 /* Disconnect confirm interrupt handler. */
924 static void cycx_x25_irq_disconnect_confirm(struct cycx_device
*card
,
925 struct cycx_x25_cmd
*cmd
)
927 struct wan_device
*wandev
= &card
->wandev
;
928 struct net_device
*dev
;
931 cycx_peek(&card
->hw
, cmd
->buf
, &lcn
, sizeof(lcn
));
932 dprintk(1, KERN_INFO
"%s: %s:lcn=%d\n",
933 card
->devname
, __func__
, lcn
);
934 dev
= cycx_x25_get_dev_by_lcn(wandev
, lcn
);
936 /* Invalid channel, discard packet */
937 printk(KERN_INFO
"%s:disconnect confirm not expected!:lcn %d\n",
942 cycx_x25_set_chan_state(dev
, WAN_DISCONNECTED
);
945 /* disconnect interrupt handler. */
946 static void cycx_x25_irq_disconnect(struct cycx_device
*card
,
947 struct cycx_x25_cmd
*cmd
)
949 struct wan_device
*wandev
= &card
->wandev
;
950 struct net_device
*dev
;
953 cycx_peek(&card
->hw
, cmd
->buf
, &lcn
, sizeof(lcn
));
954 dprintk(1, KERN_INFO
"%s:lcn=%d\n", __func__
, lcn
);
956 dev
= cycx_x25_get_dev_by_lcn(wandev
, lcn
);
958 struct cycx_x25_channel
*chan
= netdev_priv(dev
);
960 cycx_x25_disconnect_response(card
, chan
->link
, lcn
);
961 cycx_x25_set_chan_state(dev
, WAN_DISCONNECTED
);
963 cycx_x25_disconnect_response(card
, 0, lcn
);
966 /* LOG interrupt handler. */
967 static void cycx_x25_irq_log(struct cycx_device
*card
, struct cycx_x25_cmd
*cmd
)
969 #if CYCLOMX_X25_DEBUG
971 u16 size
, toread
, link
, msg_code
;
974 cycx_peek(&card
->hw
, cmd
->buf
, &msg_code
, sizeof(msg_code
));
975 cycx_peek(&card
->hw
, cmd
->buf
+ 2, &link
, sizeof(link
));
976 cycx_peek(&card
->hw
, cmd
->buf
+ 4, &size
, sizeof(size
));
977 /* at most 20 bytes are available... thanks to Daniela :) */
978 toread
= size
< 20 ? size
: 20;
979 cycx_peek(&card
->hw
, cmd
->buf
+ 10, &bf
, toread
);
980 cycx_peek(&card
->hw
, cmd
->buf
+ 10 + toread
, &code
, 1);
981 cycx_peek(&card
->hw
, cmd
->buf
+ 10 + toread
+ 1, &routine
, 1);
983 printk(KERN_INFO
"cycx_x25_irq_handler: X25_LOG (0x4500) indic.:\n");
984 printk(KERN_INFO
"cmd->buf=0x%X\n", cmd
->buf
);
985 printk(KERN_INFO
"Log message code=0x%X\n", msg_code
);
986 printk(KERN_INFO
"Link=%d\n", link
);
987 printk(KERN_INFO
"log code=0x%X\n", code
);
988 printk(KERN_INFO
"log routine=0x%X\n", routine
);
989 printk(KERN_INFO
"Message size=%d\n", size
);
990 hex_dump("Message", bf
, toread
);
994 /* STATISTIC interrupt handler. */
995 static void cycx_x25_irq_stat(struct cycx_device
*card
,
996 struct cycx_x25_cmd
*cmd
)
998 cycx_peek(&card
->hw
, cmd
->buf
, &card
->u
.x
.stats
,
999 sizeof(card
->u
.x
.stats
));
1000 hex_dump("cycx_x25_irq_stat", (unsigned char*)&card
->u
.x
.stats
,
1001 sizeof(card
->u
.x
.stats
));
1002 cycx_x25_dump_stats(&card
->u
.x
.stats
);
1003 wake_up_interruptible(&card
->wait_stats
);
1006 /* Spurious interrupt handler.
1008 * If number of spurious interrupts exceeded some limit, then ??? */
1009 static void cycx_x25_irq_spurious(struct cycx_device
*card
,
1010 struct cycx_x25_cmd
*cmd
)
1012 printk(KERN_INFO
"%s: spurious interrupt (0x%X)!\n",
1013 card
->devname
, cmd
->command
);
1015 #ifdef CYCLOMX_X25_DEBUG
1016 static void hex_dump(char *msg
, unsigned char *p
, int len
)
1018 unsigned char hex
[1024],
1021 if (len
>= (sizeof(hex
) / 2))
1022 len
= (sizeof(hex
) / 2) - 1;
1025 sprintf(phex
, "%02x", *p
++);
1029 printk(KERN_INFO
"%s: %s\n", msg
, hex
);
1033 /* Cyclom 2X Firmware-Specific Functions */
1034 /* Exec X.25 command. */
1035 static int x25_exec(struct cycx_device
*card
, int command
, int link
,
1036 void *d1
, int len1
, void *d2
, int len2
)
1038 struct cycx_x25_cmd c
;
1039 unsigned long flags
;
1040 u32 addr
= 0x1200 + 0x2E0 * link
+ 0x1E2;
1041 u8 retry
= CYCX_X25_MAX_CMD_RETRY
;
1044 c
.command
= command
;
1046 c
.len
= len1
+ len2
;
1048 spin_lock_irqsave(&card
->u
.x
.lock
, flags
);
1051 cycx_poke(&card
->hw
, X25_MBOX_OFFS
, &c
, sizeof(c
) - sizeof(c
.buf
));
1053 /* write X.25 data */
1055 cycx_poke(&card
->hw
, addr
, d1
, len1
);
1059 u32 addr1
= 0xA00 + 0x400 * link
;
1061 cycx_poke(&card
->hw
, addr
+ len1
, d2
, 249);
1062 cycx_poke(&card
->hw
, addr1
, ((u8
*)d2
) + 249,
1065 cycx_poke(&card
->hw
, addr
+ len1
, d2
, len2
);
1069 /* generate interruption, executing command */
1070 cycx_intr(&card
->hw
);
1072 /* wait till card->mbox == 0 */
1074 err
= cycx_exec(card
->mbox
);
1075 } while (retry
-- && err
);
1077 spin_unlock_irqrestore(&card
->u
.x
.lock
, flags
);
1082 /* Configure adapter. */
1083 static int cycx_x25_configure(struct cycx_device
*card
,
1084 struct cycx_x25_config
*conf
)
1088 struct cycx_x25_config conf
[2];
1091 memset(&x25_cmd_conf
, 0, sizeof(x25_cmd_conf
));
1092 x25_cmd_conf
.nlinks
= 2;
1093 x25_cmd_conf
.conf
[0] = *conf
;
1094 x25_cmd_conf
.conf
[1] = *conf
;
1095 x25_cmd_conf
.conf
[1].link
= 1;
1096 x25_cmd_conf
.conf
[1].speed
= 5; /* 38400 */
1097 x25_cmd_conf
.conf
[1].clock
= 8;
1098 x25_cmd_conf
.conf
[1].flags
= 0; /* default = RS232 */
1100 cycx_x25_dump_config(&x25_cmd_conf
.conf
[0]);
1101 cycx_x25_dump_config(&x25_cmd_conf
.conf
[1]);
1103 return x25_exec(card
, X25_CONFIG
, 0,
1104 &x25_cmd_conf
, sizeof(x25_cmd_conf
), NULL
, 0);
1107 /* Get protocol statistics. */
1108 static int cycx_x25_get_stats(struct cycx_device
*card
)
1110 /* the firmware expects 20 in the size field!!!
1111 thanks to Daniela */
1112 int err
= x25_exec(card
, X25_STATISTIC
, 0, NULL
, 20, NULL
, 0);
1117 interruptible_sleep_on(&card
->wait_stats
);
1119 if (signal_pending(current
))
1122 card
->wandev
.stats
.rx_packets
= card
->u
.x
.stats
.n2_rx_frames
;
1123 card
->wandev
.stats
.rx_over_errors
= card
->u
.x
.stats
.rx_over_errors
;
1124 card
->wandev
.stats
.rx_crc_errors
= card
->u
.x
.stats
.rx_crc_errors
;
1125 card
->wandev
.stats
.rx_length_errors
= 0; /* not available from fw */
1126 card
->wandev
.stats
.rx_frame_errors
= 0; /* not available from fw */
1127 card
->wandev
.stats
.rx_missed_errors
= card
->u
.x
.stats
.rx_aborts
;
1128 card
->wandev
.stats
.rx_dropped
= 0; /* not available from fw */
1129 card
->wandev
.stats
.rx_errors
= 0; /* not available from fw */
1130 card
->wandev
.stats
.tx_packets
= card
->u
.x
.stats
.n2_tx_frames
;
1131 card
->wandev
.stats
.tx_aborted_errors
= card
->u
.x
.stats
.tx_aborts
;
1132 card
->wandev
.stats
.tx_dropped
= 0; /* not available from fw */
1133 card
->wandev
.stats
.collisions
= 0; /* not available from fw */
1134 card
->wandev
.stats
.tx_errors
= 0; /* not available from fw */
1136 cycx_x25_dump_devs(&card
->wandev
);
1141 /* return the number of nibbles */
1142 static int byte_to_nibble(u8
*s
, u8
*d
, char *nibble
)
1146 if (*nibble
&& *s
) {
1153 d
[i
] = (*s
- '0') << 4;
1155 d
[i
] |= *(s
+ 1) - '0';
1167 static void nibble_to_byte(u8
*s
, u8
*d
, u8 len
, u8 nibble
)
1170 *d
++ = '0' + (*s
++ & 0x0F);
1175 *d
++ = '0' + (*s
>> 4);
1178 *d
++ = '0' + (*s
& 0x0F);
1188 /* Place X.25 call. */
1189 static int x25_place_call(struct cycx_device
*card
,
1190 struct cycx_x25_channel
*chan
)
1196 mylen
= chan
->local_addr
? strlen(chan
->local_addr
) : 0,
1197 remotelen
= strlen(chan
->addr
);
1200 if (card
->u
.x
.connection_keys
== ~0U) {
1201 printk(KERN_INFO
"%s: too many simultaneous connection "
1202 "requests!\n", card
->devname
);
1206 key
= ffz(card
->u
.x
.connection_keys
);
1207 set_bit(key
, (void*)&card
->u
.x
.connection_keys
);
1209 dprintk(1, KERN_INFO
"%s:x25_place_call:key=%d\n", card
->devname
, key
);
1210 memset(d
, 0, sizeof(d
));
1211 d
[1] = key
; /* user key */
1215 len
= byte_to_nibble(chan
->addr
, d
+ 6, &nibble
);
1217 if (chan
->local_addr
)
1218 len
+= byte_to_nibble(chan
->local_addr
, d
+ 6 + len
, &nibble
);
1223 d
[5] = mylen
<< 4 | remotelen
;
1224 d
[6 + len
+ 1] = 0xCC; /* TCP/IP over X.25, thanks to Daniela :) */
1226 if ((err
= x25_exec(card
, X25_CONNECT_REQUEST
, chan
->link
,
1227 &d
, 7 + len
+ 1, NULL
, 0)) != 0)
1228 clear_bit(--key
, (void*)&card
->u
.x
.connection_keys
);
1235 /* Place X.25 CONNECT RESPONSE. */
1236 static int cycx_x25_connect_response(struct cycx_device
*card
,
1237 struct cycx_x25_channel
*chan
)
1241 memset(d
, 0, sizeof(d
));
1242 d
[0] = d
[3] = chan
->lcn
;
1245 d
[7] = 0xCC; /* TCP/IP over X.25, thanks Daniela */
1247 return x25_exec(card
, X25_CONNECT_RESPONSE
, chan
->link
, &d
, 8, NULL
, 0);
1250 /* Place X.25 DISCONNECT RESPONSE. */
1251 static int cycx_x25_disconnect_response(struct cycx_device
*card
, u8 link
,
1256 memset(d
, 0, sizeof(d
));
1261 return x25_exec(card
, X25_DISCONNECT_RESPONSE
, link
, &d
, 5, NULL
, 0);
1264 /* Clear X.25 call. */
1265 static int x25_clear_call(struct cycx_device
*card
, u8 link
, u8 lcn
, u8 cause
,
1270 memset(d
, 0, sizeof(d
));
1277 return x25_exec(card
, X25_DISCONNECT_REQUEST
, link
, d
, 7, NULL
, 0);
1280 /* Send X.25 data packet. */
1281 static int cycx_x25_send(struct cycx_device
*card
, u8 link
, u8 lcn
, u8 bitm
,
1284 u8 d
[] = "?\xFF\x10??";
1289 return x25_exec(card
, X25_DATA_REQUEST
, link
, &d
, 5, buf
, len
);
1293 /* Find network device by its channel number. */
1294 static struct net_device
*cycx_x25_get_dev_by_lcn(struct wan_device
*wandev
,
1297 struct net_device
*dev
= wandev
->dev
;
1298 struct cycx_x25_channel
*chan
;
1301 chan
= netdev_priv(dev
);
1303 if (chan
->lcn
== lcn
)
1310 /* Find network device by its remote dte address. */
1311 static struct net_device
*
1312 cycx_x25_get_dev_by_dte_addr(struct wan_device
*wandev
, char *dte
)
1314 struct net_device
*dev
= wandev
->dev
;
1315 struct cycx_x25_channel
*chan
;
1318 chan
= netdev_priv(dev
);
1320 if (!strcmp(chan
->addr
, dte
))
1327 /* Initiate connection on the logical channel.
1328 * o for PVC we just get channel configuration
1329 * o for SVCs place an X.25 call
1331 * Return: 0 connected
1332 * >0 connection in progress
1334 static int cycx_x25_chan_connect(struct net_device
*dev
)
1336 struct cycx_x25_channel
*chan
= netdev_priv(dev
);
1337 struct cycx_device
*card
= chan
->card
;
1341 return -EINVAL
; /* no destination address */
1343 dprintk(1, KERN_INFO
"%s: placing X.25 call to %s...\n",
1344 card
->devname
, chan
->addr
);
1346 if (x25_place_call(card
, chan
))
1349 cycx_x25_set_chan_state(dev
, WAN_CONNECTING
);
1352 cycx_x25_set_chan_state(dev
, WAN_CONNECTED
);
1357 /* Disconnect logical channel.
1358 * o if SVC then clear X.25 call */
1359 static void cycx_x25_chan_disconnect(struct net_device
*dev
)
1361 struct cycx_x25_channel
*chan
= netdev_priv(dev
);
1364 x25_clear_call(chan
->card
, chan
->link
, chan
->lcn
, 0, 0);
1365 cycx_x25_set_chan_state(dev
, WAN_DISCONNECTING
);
1367 cycx_x25_set_chan_state(dev
, WAN_DISCONNECTED
);
1370 /* Called by kernel timer */
1371 static void cycx_x25_chan_timer(unsigned long d
)
1373 struct net_device
*dev
= (struct net_device
*)d
;
1374 struct cycx_x25_channel
*chan
= netdev_priv(dev
);
1376 if (chan
->state
== WAN_CONNECTED
)
1377 cycx_x25_chan_disconnect(dev
);
1379 printk(KERN_ERR
"%s: %s for svc (%s) not connected!\n",
1380 chan
->card
->devname
, __func__
, dev
->name
);
1383 /* Set logical channel state. */
1384 static void cycx_x25_set_chan_state(struct net_device
*dev
, u8 state
)
1386 struct cycx_x25_channel
*chan
= netdev_priv(dev
);
1387 struct cycx_device
*card
= chan
->card
;
1388 unsigned long flags
;
1389 char *string_state
= NULL
;
1391 spin_lock_irqsave(&card
->lock
, flags
);
1393 if (chan
->state
!= state
) {
1394 if (chan
->svc
&& chan
->state
== WAN_CONNECTED
)
1395 del_timer(&chan
->timer
);
1399 string_state
= "connected!";
1400 *(__be16
*)dev
->dev_addr
= htons(chan
->lcn
);
1401 netif_wake_queue(dev
);
1404 if (chan
->protocol
== ETH_P_X25
)
1405 cycx_x25_chan_send_event(dev
,
1409 case WAN_CONNECTING
:
1410 string_state
= "connecting...";
1412 case WAN_DISCONNECTING
:
1413 string_state
= "disconnecting...";
1415 case WAN_DISCONNECTED
:
1416 string_state
= "disconnected!";
1419 *(unsigned short*)dev
->dev_addr
= 0;
1423 if (chan
->protocol
== ETH_P_X25
)
1424 cycx_x25_chan_send_event(dev
,
1425 X25_IFACE_DISCONNECT
);
1427 netif_wake_queue(dev
);
1431 printk(KERN_INFO
"%s: interface %s %s\n", card
->devname
,
1432 dev
->name
, string_state
);
1433 chan
->state
= state
;
1436 spin_unlock_irqrestore(&card
->lock
, flags
);
1439 /* Send packet on a logical channel.
1440 * When this function is called, tx_skb field of the channel data space
1441 * points to the transmit socket buffer. When transmission is complete,
1442 * release socket buffer and reset 'tbusy' flag.
1444 * Return: 0 - transmission complete
1448 * 1. If packet length is greater than MTU for this channel, we'll fragment
1449 * the packet into 'complete sequence' using M-bit.
1450 * 2. When transmission is complete, an event notification should be issued
1452 static int cycx_x25_chan_send(struct net_device
*dev
, struct sk_buff
*skb
)
1454 struct cycx_x25_channel
*chan
= netdev_priv(dev
);
1455 struct cycx_device
*card
= chan
->card
;
1456 int bitm
= 0; /* final packet */
1457 unsigned len
= skb
->len
;
1459 if (skb
->len
> card
->wandev
.mtu
) {
1460 len
= card
->wandev
.mtu
;
1461 bitm
= 0x10; /* set M-bit (more data) */
1464 if (cycx_x25_send(card
, chan
->link
, chan
->lcn
, bitm
, len
, skb
->data
))
1472 ++chan
->ifstats
.tx_packets
;
1473 chan
->ifstats
.tx_bytes
+= len
;
1478 /* Send event (connection, disconnection, etc) to X.25 socket layer */
1480 static void cycx_x25_chan_send_event(struct net_device
*dev
, u8 event
)
1482 struct sk_buff
*skb
;
1485 if ((skb
= dev_alloc_skb(1)) == NULL
) {
1486 printk(KERN_ERR
"%s: out of memory\n", __func__
);
1490 ptr
= skb_put(skb
, 1);
1493 skb
->protocol
= x25_type_trans(skb
, dev
);
1497 /* Convert line speed in bps to a number used by cyclom 2x code. */
1498 static u8
bps_to_speed_code(u32 bps
)
1500 u8 number
= 0; /* defaults to the lowest (1200) speed ;> */
1502 if (bps
>= 512000) number
= 8;
1503 else if (bps
>= 256000) number
= 7;
1504 else if (bps
>= 64000) number
= 6;
1505 else if (bps
>= 38400) number
= 5;
1506 else if (bps
>= 19200) number
= 4;
1507 else if (bps
>= 9600) number
= 3;
1508 else if (bps
>= 4800) number
= 2;
1509 else if (bps
>= 2400) number
= 1;
1515 static u8
cycx_log2(u32 n
)
1530 /* Convert decimal string to unsigned integer.
1531 * If len != 0 then only 'len' characters of the string are converted. */
1532 static unsigned dec_to_uint(u8
*str
, int len
)
1539 for (; len
&& isdigit(*str
); ++str
, --len
)
1540 val
= (val
* 10) + (*str
- (unsigned) '0');
1545 static void reset_timer(struct net_device
*dev
)
1547 struct cycx_x25_channel
*chan
= netdev_priv(dev
);
1550 mod_timer(&chan
->timer
, jiffies
+chan
->idle_tmout
*HZ
);
1552 #ifdef CYCLOMX_X25_DEBUG
1553 static void cycx_x25_dump_config(struct cycx_x25_config
*conf
)
1555 printk(KERN_INFO
"X.25 configuration\n");
1556 printk(KERN_INFO
"-----------------\n");
1557 printk(KERN_INFO
"link number=%d\n", conf
->link
);
1558 printk(KERN_INFO
"line speed=%d\n", conf
->speed
);
1559 printk(KERN_INFO
"clock=%sternal\n", conf
->clock
== 8 ? "Ex" : "In");
1560 printk(KERN_INFO
"# level 2 retransm.=%d\n", conf
->n2
);
1561 printk(KERN_INFO
"level 2 window=%d\n", conf
->n2win
);
1562 printk(KERN_INFO
"level 3 window=%d\n", conf
->n3win
);
1563 printk(KERN_INFO
"# logical channels=%d\n", conf
->nvc
);
1564 printk(KERN_INFO
"level 3 pkt len=%d\n", conf
->pktlen
);
1565 printk(KERN_INFO
"my address=%d\n", conf
->locaddr
);
1566 printk(KERN_INFO
"remote address=%d\n", conf
->remaddr
);
1567 printk(KERN_INFO
"t1=%d seconds\n", conf
->t1
);
1568 printk(KERN_INFO
"t2=%d seconds\n", conf
->t2
);
1569 printk(KERN_INFO
"t21=%d seconds\n", conf
->t21
);
1570 printk(KERN_INFO
"# PVCs=%d\n", conf
->npvc
);
1571 printk(KERN_INFO
"t23=%d seconds\n", conf
->t23
);
1572 printk(KERN_INFO
"flags=0x%x\n", conf
->flags
);
1575 static void cycx_x25_dump_stats(struct cycx_x25_stats
*stats
)
1577 printk(KERN_INFO
"X.25 statistics\n");
1578 printk(KERN_INFO
"--------------\n");
1579 printk(KERN_INFO
"rx_crc_errors=%d\n", stats
->rx_crc_errors
);
1580 printk(KERN_INFO
"rx_over_errors=%d\n", stats
->rx_over_errors
);
1581 printk(KERN_INFO
"n2_tx_frames=%d\n", stats
->n2_tx_frames
);
1582 printk(KERN_INFO
"n2_rx_frames=%d\n", stats
->n2_rx_frames
);
1583 printk(KERN_INFO
"tx_timeouts=%d\n", stats
->tx_timeouts
);
1584 printk(KERN_INFO
"rx_timeouts=%d\n", stats
->rx_timeouts
);
1585 printk(KERN_INFO
"n3_tx_packets=%d\n", stats
->n3_tx_packets
);
1586 printk(KERN_INFO
"n3_rx_packets=%d\n", stats
->n3_rx_packets
);
1587 printk(KERN_INFO
"tx_aborts=%d\n", stats
->tx_aborts
);
1588 printk(KERN_INFO
"rx_aborts=%d\n", stats
->rx_aborts
);
1591 static void cycx_x25_dump_devs(struct wan_device
*wandev
)
1593 struct net_device
*dev
= wandev
->dev
;
1595 printk(KERN_INFO
"X.25 dev states\n");
1596 printk(KERN_INFO
"name: addr: txoff: protocol:\n");
1597 printk(KERN_INFO
"---------------------------------------\n");
1600 struct cycx_x25_channel
*chan
= netdev_priv(dev
);
1602 printk(KERN_INFO
"%-5.5s %-15.15s %d ETH_P_%s\n",
1603 chan
->name
, chan
->addr
, netif_queue_stopped(dev
),
1604 chan
->protocol
== ETH_P_IP
? "IP" : "X25");
1609 #endif /* CYCLOMX_X25_DEBUG */