c5f5e62aab8b8c31814fea2fa900799db0c061c3
[linux-3.10.git] / drivers / net / wan / sdla_fr.c
1 /*****************************************************************************
2 * sdla_fr.c     WANPIPE(tm) Multiprotocol WAN Link Driver. Frame relay module.
3 *
4 * Author(s):    Nenad Corbic  <ncorbic@sangoma.com>
5 *               Gideon Hack
6 *
7 * Copyright:    (c) 1995-2001 Sangoma Technologies Inc.
8 *
9 *               This program is free software; you can redistribute it and/or
10 *               modify it under the terms of the GNU General Public License
11 *               as published by the Free Software Foundation; either version
12 *               2 of the License, or (at your option) any later version.
13 * ============================================================================
14 * Nov 23, 2000  Nenad Corbic    o Added support for 2.4.X kernels
15 * Nov 15, 2000  David Rokavarg  
16 *               Nenad Corbic    o Added frame relay bridging support.
17 *                                 Original code from Mark Wells and Kristian Hoffmann has
18 *                                 been integrated into the frame relay driver.
19 * Nov 13, 2000  Nenad Corbic    o Added true interface type encoding option.
20 *                                 Tcpdump doesn't support Frame Relay inteface
21 *                                 types, to fix this true type option will set
22 *                                 the interface type to RAW IP mode.
23 * Nov 07, 2000  Nenad Corbic    o Added security features for UDP debugging:
24 *                                 Deny all and specify allowed requests.
25 * Nov 06, 2000  Nenad Corbic    o Wanpipe interfaces conform to raw packet interfaces.  
26 *                                 Moved the if_header into the if_send() routine.
27 *                                 The if_header() was breaking the libpcap 
28 *                                 support. i.e. support for tcpdump, ethereal ...
29 * Oct 12. 2000  Nenad Corbic    o Added error message in fr_configure
30 * Jul 31, 2000  Nenad Corbic    o Fixed the Router UP Time.
31 * Apr 28, 2000  Nenad Corbic    o Added the option to shutdown an interface
32 *                                 when the channel gets disconnected.
33 * Apr 28, 2000  Nenad Corbic    o Added M.Grants patch: disallow duplicate
34 *                                 interface setups. 
35 * Apr 25, 2000  Nenad Corbic    o Added M.Grants patch: dynamically add/remove 
36 *                                 new dlcis/interfaces.
37 * Mar 23, 2000  Nenad Corbic    o Improved task queue, bh handling.
38 * Mar 16, 2000  Nenad Corbic    o Added Inverse ARP support
39 * Mar 13, 2000  Nenad Corbic    o Added new socket API support.
40 * Mar 06, 2000  Nenad Corbic    o Bug Fix: corrupted mbox recovery.
41 * Feb 24, 2000  Nenad Corbic    o Fixed up FT1 UDP debugging problem.
42 * Dev 15, 1999  Nenad Corbic    o Fixed up header files for 2.0.X kernels
43 *
44 * Nov 08, 1999  Nenad Corbic    o Combined all debug UDP calls into one function
45 *                               o Removed the ARP support. This has to be done
46 *                                 in the next version.
47 *                               o Only a Node can implement NO signalling.
48 *                                 Initialize DLCI during if_open() if NO 
49 *                                 signalling.
50 *                               o Took out IPX support, implement in next
51 *                                 version
52 * Sep 29, 1999  Nenad Corbic    o Added SMP support and changed the update
53 *                                 function to use timer interrupt.
54 *                               o Fixed the CIR bug:  Set the value of BC
55 *                                 to CIR when the CIR is enabled.
56 *                               o Updated comments, statistics and tracing.
57 * Jun 02, 1999  Gideon Hack     o Updated for S514 support.
58 * Sep 18, 1998  Jaspreet Singh  o Updated for 2.2.X kernels.
59 * Jul 31, 1998  Jaspreet Singh  o Removed wpf_poll routine.  The channel/DLCI 
60 *                                 status is received through an event interrupt.
61 * Jul 08, 1998  David Fong      o Added inverse ARP support.
62 * Mar 26, 1997  Jaspreet Singh  o Returning return codes for failed UDP cmds.
63 * Jan 28, 1997  Jaspreet Singh  o Improved handling of inactive DLCIs.
64 * Dec 30, 1997  Jaspreet Singh  o Replaced dev_tint() with mark_bh(NET_BH)
65 * Dec 16, 1997  Jaspreet Singh  o Implemented Multiple IPX support.
66 * Nov 26, 1997  Jaspreet Singh  o Improved load sharing with multiple boards
67 *                               o Added Cli() to protect enabling of interrupts
68 *                                 while polling is called.
69 * Nov 24, 1997  Jaspreet Singh  o Added counters to avoid enabling of interrupts
70 *                                 when they have been disabled by another
71 *                                 interface or routine (eg. wpf_poll).
72 * Nov 06, 1997  Jaspreet Singh  o Added INTR_TEST_MODE to avoid polling 
73 *                                 routine disable interrupts during interrupt
74 *                                 testing.
75 * Oct 20, 1997  Jaspreet Singh  o Added hooks in for Router UP time.
76 * Oct 16, 1997  Jaspreet Singh  o The critical flag is used to maintain flow
77 *                                 control by avoiding RACE conditions.  The
78 *                                 cli() and restore_flags() are taken out.
79 *                                 The fr_channel structure is appended for 
80 *                                 Driver Statistics.
81 * Oct 15, 1997  Farhan Thawar    o updated if_send() and receive for IPX
82 * Aug 29, 1997  Farhan Thawar    o Removed most of the cli() and sti()
83 *                                o Abstracted the UDP management stuff
84 *                                o Now use tbusy and critical more intelligently
85 * Jul 21, 1997  Jaspreet Singh   o Can configure T391, T392, N391, N392 & N393
86 *                                  through router.conf.
87 *                                o Protected calls to sdla_peek() by adDing 
88 *                                  save_flags(), cli() and restore_flags().
89 *                                o Added error message for Inactive DLCIs in
90 *                                  fr_event() and update_chan_state().
91 *                                o Fixed freeing up of buffers using kfree() 
92 *                                  when packets are received.
93 * Jul 07, 1997  Jaspreet Singh   o Added configurable TTL for UDP packets 
94 *                                o Added ability to discard multicast and 
95 *                                  broadcast source addressed packets
96 * Jun 27, 1997  Jaspreet Singh   o Added FT1 monitor capabilities 
97 *                                  New case (0x44) statement in if_send routine 
98 *                                  Added a global variable rCount to keep track
99 *                                  of FT1 status enabled on the board.
100 * May 29, 1997  Jaspreet Singh   o Fixed major Flow Control Problem
101 *                                  With multiple boards a problem was seen where
102 *                                  the second board always stopped transmitting
103 *                                  packet after running for a while. The code
104 *                                  got into a stage where the interrupts were
105 *                                  disabled and dev->tbusy was set to 1.
106 *                                  This caused the If_send() routine to get into
107 *                                  the if clause for it(0,dev->tbusy) 
108 *                                  forever.
109 *                                  The code got into this stage due to an 
110 *                                  interrupt occurring within the if clause for 
111 *                                  set_bit(0,dev->tbusy).  Since an interrupt 
112 *                                  disables furhter transmit interrupt and 
113 *                                  makes dev->tbusy = 0, this effect was undone 
114 *                                  by making dev->tbusy = 1 in the if clause.
115 *                                  The Fix checks to see if Transmit interrupts
116 *                                  are disabled then do not make dev->tbusy = 1
117 *                                  Introduced a global variable: int_occur and
118 *                                  added tx_int_enabled in the wan_device 
119 *                                  structure.   
120 * May 21, 1997  Jaspreet Singh   o Fixed UDP Management for multiple
121 *                                  boards.
122 *
123 * Apr 25, 1997  Farhan Thawar    o added UDP Management stuff
124 *                                o fixed bug in if_send() and tx_intr() to
125 *                                  sleep and wakeup all devices
126 * Mar 11, 1997  Farhan Thawar   Version 3.1.1
127 *                                o fixed (+1) bug in fr508_rx_intr()
128 *                                o changed if_send() to return 0 if
129 *                                  wandev.critical() is true
130 *                                o free socket buffer in if_send() if
131 *                                  returning 0 
132 *                                o added tx_intr() routine
133 * Jan 30, 1997  Gene Kozin      Version 3.1.0
134 *                                o implemented exec() entry point
135 *                                o fixed a bug causing driver configured as
136 *                                  a FR switch to be stuck in WAN_
137 *                                  mode
138 * Jan 02, 1997  Gene Kozin      Initial version.
139 *****************************************************************************/
140
141 #include <linux/module.h>
142 #include <linux/kernel.h>       /* printk(), and other useful stuff */
143 #include <linux/stddef.h>       /* offsetof(), etc. */
144 #include <linux/errno.h>        /* return codes */
145 #include <linux/string.h>       /* inline memset(), etc. */
146 #include <linux/slab.h> /* kmalloc(), kfree() */
147 #include <linux/wanrouter.h>    /* WAN router definitions */
148 #include <linux/wanpipe.h>      /* WANPIPE common user API definitions */
149 #include <linux/workqueue.h>
150 #include <linux/if_arp.h>       /* ARPHRD_* defines */
151 #include <asm/byteorder.h>      /* htons(), etc. */
152 #include <asm/io.h>             /* for inb(), outb(), etc. */
153 #include <linux/time.h>         /* for do_gettimeofday */       
154 #include <linux/in.h>           /* sockaddr_in */
155 #include <linux/jiffies.h>      /* time_after() macro */
156 #include <asm/errno.h>
157
158 #include <linux/ip.h>
159 #include <linux/if.h>
160
161 #include <linux/if_wanpipe_common.h>    /* Wanpipe Socket */
162 #include <linux/if_wanpipe.h>   
163
164 #include <linux/sdla_fr.h>              /* frame relay firmware API definitions */
165
166 #include <asm/uaccess.h>
167 #include <linux/inetdevice.h>
168 #include <linux/netdevice.h>
169
170 #include <net/route.h>                  /* Dynamic Route Creation */
171 #include <linux/etherdevice.h>          /* eth_type_trans() used for bridging */
172 #include <linux/random.h>
173
174 /****** Defines & Macros ****************************************************/
175
176 #define MAX_CMD_RETRY   10              /* max number of firmware retries */
177
178 #define FR_HEADER_LEN   8               /* max encapsulation header size */
179 #define FR_CHANNEL_MTU  1500            /* unfragmented logical channel MTU */
180
181 /* Q.922 frame types */
182 #define Q922_UI         0x03            /* Unnumbered Info frame */
183 #define Q922_XID        0xAF            
184
185 /* DLCI configured or not */
186 #define DLCI_NOT_CONFIGURED     0x00
187 #define DLCI_CONFIG_PENDING     0x01
188 #define DLCI_CONFIGURED         0x02
189
190 /* CIR enabled or not */
191 #define CIR_ENABLED     0x00
192 #define CIR_DISABLED    0x01
193
194 #define FRAME_RELAY_API 1
195 #define MAX_BH_BUFF     10
196
197 /* For handle_IPXWAN() */
198 #define CVHexToAscii(b) (((unsigned char)(b) > (unsigned char)9) ? ((unsigned char)'A' + ((unsigned char)(b) - (unsigned char)10)) : ((unsigned char)'0' + (unsigned char)(b)))
199  
200 /****** Data Structures *****************************************************/
201
202 /* This is an extention of the 'struct device' we create for each network
203  * interface to keep the rest of channel-specific data.
204  */
205 typedef struct fr_channel
206 {
207         wanpipe_common_t common;
208         char name[WAN_IFNAME_SZ+1];     /* interface name, ASCIIZ */
209         unsigned dlci_configured  ;     /* check whether configured or not */
210         unsigned cir_status;            /* check whether CIR enabled or not */
211         unsigned dlci;                  /* logical channel number */
212         unsigned cir;                   /* committed information rate */
213         unsigned bc;                    /* committed burst size */
214         unsigned be;                    /* excess burst size */
215         unsigned mc;                    /* multicast support on or off */
216         unsigned tx_int_status;         /* Transmit Interrupt Status */ 
217         unsigned short pkt_length;      /* Packet Length */
218         unsigned long router_start_time;/* Router start time in seconds */
219         unsigned long tick_counter;     /* counter for transmit time out */
220         char dev_pending_devtint;       /* interface pending dev_tint() */
221         void *dlci_int_interface;       /* pointer to the DLCI Interface */ 
222         unsigned long IB_addr;          /* physical address of Interface Byte */
223         unsigned long state_tick;       /* time of the last state change */
224         unsigned char enable_IPX;       /* Enable/Disable the use of IPX */
225         unsigned long network_number;   /* Internal Network Number for IPX*/
226         sdla_t *card;                   /* -> owner */
227         unsigned route_flag;            /* Add/Rem dest addr in route tables */
228         unsigned inarp;                 /* Inverse Arp Request status */ 
229         long inarp_ready;               /* Ready to send requests */
230         int inarp_interval;             /* Time between InArp Requests */
231         unsigned long inarp_tick;       /* InArp jiffies tick counter */
232         long interface_down;            /* Bring interface down on disconnect */
233         struct net_device_stats ifstats;        /* interface statistics */
234         if_send_stat_t drvstats_if_send;
235         rx_intr_stat_t drvstats_rx_intr;
236         pipe_mgmt_stat_t drvstats_gen;
237         unsigned long router_up_time;
238
239         unsigned short transmit_length;
240         struct sk_buff *delay_skb;
241
242         bh_data_t *bh_head;               /* Circular buffer for chdlc_bh */
243         unsigned long  tq_working;
244         volatile int  bh_write;
245         volatile int  bh_read;
246         atomic_t  bh_buff_used;
247
248         /* Polling task queue. Each interface
249          * has its own task queue, which is used
250          * to defer events from the interrupt */
251         struct work_struct fr_poll_work;
252         struct timer_list fr_arp_timer;
253
254         u32 ip_local;
255         u32 ip_remote;
256         long config_dlci;
257         long unconfig_dlci;
258
259         /* Whether this interface should be setup as a gateway.
260          * Used by dynamic route setup code */
261         u8  gateway;
262
263         /* True interface type */
264         u8 true_if_encoding;
265         u8 fr_header[FR_HEADER_LEN];
266         char fr_header_len;
267
268 } fr_channel_t;
269
270 /* Route Flag options */
271 #define NO_ROUTE        0x00
272 #define ADD_ROUTE       0x01
273 #define ROUTE_ADDED     0x02
274 #define REMOVE_ROUTE    0x03
275 #define ARP_REQ         0x04
276
277 /* inarp options */
278 #define INARP_NONE              0x00
279 #define INARP_REQUEST           0x01
280 #define INARP_CONFIGURED        0x02
281
282 /* reasons for enabling the timer interrupt on the adapter */
283 #define TMR_INT_ENABLED_UDP     0x01
284 #define TMR_INT_ENABLED_UPDATE  0x02
285 #define TMR_INT_ENABLED_ARP     0x04
286 #define TMR_INT_ENABLED_UPDATE_STATE    0x08
287 #define TMR_INT_ENABLED_CONFIG  0x10
288 #define TMR_INT_ENABLED_UNCONFIG        0x20
289
290
291 typedef struct dlci_status
292 {
293         unsigned short dlci     PACKED;
294         unsigned char state     PACKED;
295 } dlci_status_t;
296
297 typedef struct dlci_IB_mapping
298 {
299         unsigned short dlci             PACKED;
300         unsigned long  addr_value       PACKED;
301 } dlci_IB_mapping_t;
302
303 /* This structure is used for DLCI list Tx interrupt mode.  It is used to
304    enable interrupt bit and set the packet length for transmission
305  */
306 typedef struct fr_dlci_interface 
307 {
308         unsigned char gen_interrupt     PACKED;
309         unsigned short packet_length    PACKED;
310         unsigned char reserved          PACKED;
311 } fr_dlci_interface_t; 
312
313 /* variable for keeping track of enabling/disabling FT1 monitor status */
314 static int rCount = 0;
315
316 extern void disable_irq(unsigned int);
317 extern void enable_irq(unsigned int);
318
319 /* variable for keeping track of number of interrupts generated during 
320  * interrupt test routine 
321  */
322 static int Intr_test_counter;
323
324 /****** Function Prototypes *************************************************/
325
326 /* WAN link driver entry points. These are called by the WAN router module. */
327 static int update(struct wan_device *wandev);
328 static int new_if(struct wan_device *wandev, struct net_device *dev,
329                   wanif_conf_t *conf);
330 static int del_if(struct wan_device *wandev, struct net_device *dev);
331 static void disable_comm (sdla_t *card);
332
333 /* WANPIPE-specific entry points */
334 static int wpf_exec(struct sdla *card, void *u_cmd, void *u_data);
335
336 /* Network device interface */
337 static int if_init(struct net_device *dev);
338 static int if_open(struct net_device *dev);
339 static int if_close(struct net_device *dev);
340
341 static void if_tx_timeout(struct net_device *dev);
342
343 static int if_rebuild_hdr (struct sk_buff *skb);
344
345 static int if_send(struct sk_buff *skb, struct net_device *dev);
346 static int chk_bcast_mcast_addr(sdla_t *card, struct net_device* dev,
347                                 struct sk_buff *skb);
348 static struct net_device_stats *if_stats(struct net_device *dev);
349
350 /* Interrupt handlers */
351 static void fr_isr(sdla_t *card);
352 static void rx_intr(sdla_t *card);
353 static void tx_intr(sdla_t *card);
354 static void timer_intr(sdla_t *card);
355 static void spur_intr(sdla_t *card);
356
357 /* Frame relay firmware interface functions */
358 static int fr_read_version(sdla_t *card, char *str);
359 static int fr_configure(sdla_t *card, fr_conf_t *conf);
360 static int fr_dlci_configure(sdla_t *card, fr_dlc_conf_t *conf, unsigned dlci);
361 static int fr_init_dlci (sdla_t *card, fr_channel_t *chan);
362 static int fr_set_intr_mode (sdla_t *card, unsigned mode, unsigned mtu, unsigned short timeout);
363 static int fr_comm_enable(sdla_t *card);
364 static void fr_comm_disable(sdla_t *card);
365 static int fr_get_err_stats(sdla_t *card);
366 static int fr_get_stats(sdla_t *card);
367 static int fr_add_dlci(sdla_t *card, int dlci);
368 static int fr_activate_dlci(sdla_t *card, int dlci);
369 static int fr_delete_dlci (sdla_t* card, int dlci);
370 static int fr_issue_isf(sdla_t *card, int isf);
371 static int fr_send(sdla_t *card, int dlci, unsigned char attr, int len,
372         void *buf);
373 static int fr_send_data_header(sdla_t *card, int dlci, unsigned char attr, int len,
374         void *buf,unsigned char hdr_len);
375 static unsigned int fr_send_hdr(sdla_t *card, int dlci, unsigned int offset);
376
377 static int check_dlci_config (sdla_t *card, fr_channel_t *chan);
378 static void initialize_rx_tx_buffers (sdla_t *card);
379
380
381 /* Firmware asynchronous event handlers */
382 static int fr_event(sdla_t *card, int event, fr_mbox_t *mbox);
383 static int fr_modem_failure(sdla_t *card, fr_mbox_t *mbox);
384 static int fr_dlci_change(sdla_t *card, fr_mbox_t *mbox);
385
386 /* Miscellaneous functions */
387 static int update_chan_state(struct net_device *dev);
388 static void set_chan_state(struct net_device *dev, int state);
389 static struct net_device *find_channel(sdla_t *card, unsigned dlci);
390 static int is_tx_ready(sdla_t *card, fr_channel_t *chan);
391 static unsigned int dec_to_uint(unsigned char *str, int len);
392 static int reply_udp( unsigned char *data, unsigned int mbox_len );
393
394 static int intr_test( sdla_t* card );
395 static void init_chan_statistics( fr_channel_t* chan );
396 static void init_global_statistics( sdla_t* card );
397 static void read_DLCI_IB_mapping( sdla_t* card, fr_channel_t* chan );
398 static int setup_for_delayed_transmit(struct net_device* dev,
399                                       struct sk_buff *skb);
400
401 struct net_device *move_dev_to_next(sdla_t *card, struct net_device *dev);
402 static int check_tx_status(sdla_t *card, struct net_device *dev);
403
404 /* Frame Relay Socket API */
405 static void trigger_fr_bh (fr_channel_t *);
406 static void fr_bh(struct net_device *dev);
407 static int fr_bh_cleanup(struct net_device *dev);
408 static int bh_enqueue(struct net_device *dev, struct sk_buff *skb);
409
410 static void trigger_fr_poll(struct net_device *dev);
411 static void fr_poll(struct net_device *dev);
412 //static void add_gateway(struct net_device *dev);
413
414 static void trigger_unconfig_fr(struct net_device *dev);
415 static void unconfig_fr (sdla_t *);
416
417 static void trigger_config_fr (sdla_t *);
418 static void config_fr (sdla_t *);
419
420
421 /* Inverse ARP and Dynamic routing functions */
422 int process_ARP(arphdr_1490_t *ArpPacket, sdla_t *card, struct net_device *dev);
423 int is_arp(void *buf);
424 int send_inarp_request(sdla_t *card, struct net_device *dev);
425
426 static void trigger_fr_arp(struct net_device *dev);
427 static void fr_arp (unsigned long data);
428
429
430 /* Udp management functions */
431 static int process_udp_mgmt_pkt(sdla_t *card);
432 static int udp_pkt_type( struct sk_buff *skb, sdla_t *card );
433 static int store_udp_mgmt_pkt(int udp_type, char udp_pkt_src, sdla_t* card,
434                                 struct sk_buff *skb, int dlci);
435
436 /* IPX functions */
437 static void switch_net_numbers(unsigned char *sendpacket,
438         unsigned long network_number, unsigned char incoming);
439
440 static int handle_IPXWAN(unsigned char *sendpacket, char *devname,
441         unsigned char enable_IPX, unsigned long network_number);
442
443 /* Lock Functions: SMP supported */
444 void    s508_s514_unlock(sdla_t *card, unsigned long *smp_flags);
445 void    s508_s514_lock(sdla_t *card, unsigned long *smp_flags);
446
447 unsigned short calc_checksum (char *, int);
448 static int setup_fr_header(struct sk_buff** skb,
449                            struct net_device* dev, char op_mode);
450
451
452 /****** Public Functions ****************************************************/
453
454 /*============================================================================
455  * Frame relay protocol initialization routine.
456  *
457  * This routine is called by the main WANPIPE module during setup.  At this
458  * point adapter is completely initialized and firmware is running.
459  *  o read firmware version (to make sure it's alive)
460  *  o configure adapter
461  *  o initialize protocol-specific fields of the adapter data space.
462  *
463  * Return:      0       o.k.
464  *              < 0     failure.
465  */
466 int wpf_init(sdla_t *card, wandev_conf_t *conf)
467 {
468
469         int err;
470         fr508_flags_t* flags;
471
472         union
473         {
474                 char str[80];
475                 fr_conf_t cfg;
476         } u;
477
478         fr_buf_info_t* buf_info;
479         int i;
480
481
482         printk(KERN_INFO "\n");
483
484         /* Verify configuration ID */
485         if (conf->config_id != WANCONFIG_FR) {
486                 
487                 printk(KERN_INFO "%s: invalid configuration ID %u!\n",
488                         card->devname, conf->config_id);
489                 return -EINVAL;
490         
491         }
492
493         /* Initialize protocol-specific fields of adapter data space */
494         switch (card->hw.fwid) {
495         
496                 case SFID_FR508:
497                         card->mbox  = (void*)(card->hw.dpmbase + 
498                                         FR508_MBOX_OFFS);
499                         card->flags = (void*)(card->hw.dpmbase + 
500                                         FR508_FLAG_OFFS);
501                         if(card->hw.type == SDLA_S514) {
502                                 card->mbox += FR_MB_VECTOR;
503                                 card->flags += FR_MB_VECTOR;
504                         }
505                         card->isr = &fr_isr;
506                         break;
507
508                 default:
509                         return -EINVAL;
510         }
511
512         flags = card->flags;
513
514         /* Read firmware version.  Note that when adapter initializes, it
515          * clears the mailbox, so it may appear that the first command was
516          * executed successfully when in fact it was merely erased. To work
517          * around this, we execute the first command twice.
518          */
519
520         if (fr_read_version(card, NULL) || fr_read_version(card, u.str))
521                 return -EIO;
522
523         printk(KERN_INFO "%s: running frame relay firmware v%s\n",
524                 card->devname, u.str);
525
526         /* Adjust configuration */
527         conf->mtu += FR_HEADER_LEN;
528         conf->mtu = (conf->mtu >= MIN_LGTH_FR_DATA_CFG) ?
529                         min_t(unsigned int, conf->mtu, FR_MAX_NO_DATA_BYTES_IN_FRAME) :
530                         FR_CHANNEL_MTU + FR_HEADER_LEN;
531      
532         conf->bps = min_t(unsigned int, conf->bps, 2048000);
533
534         /* Initialze the configuration structure sent to the board to zero */
535         memset(&u.cfg, 0, sizeof(u.cfg));
536
537         memset(card->u.f.dlci_to_dev_map, 0, sizeof(card->u.f.dlci_to_dev_map));
538         
539         /* Configure adapter firmware */
540
541         u.cfg.mtu       = conf->mtu;
542         u.cfg.kbps      = conf->bps / 1000;
543
544         u.cfg.cir_fwd = u.cfg.cir_bwd = 16;
545         u.cfg.bc_fwd  = u.cfg.bc_bwd = 16;
546         
547         u.cfg.options   = 0x0000;
548         printk(KERN_INFO "%s: Global CIR enabled by Default\n", card->devname);
549         
550         switch (conf->u.fr.signalling) {
551
552                 case WANOPT_FR_ANSI:
553                         u.cfg.options = 0x0000; 
554                         break;          
555         
556                 case WANOPT_FR_Q933:    
557                         u.cfg.options |= 0x0200; 
558                         break;
559         
560                 case WANOPT_FR_LMI:     
561                         u.cfg.options |= 0x0400; 
562                         break;
563
564                 case WANOPT_NO:
565                         u.cfg.options |= 0x0800; 
566                         break;
567                 default:
568                         printk(KERN_INFO "%s: Illegal Signalling option\n",
569                                         card->wandev.name);
570                         return -EINVAL;
571         }
572
573
574         card->wandev.signalling = conf->u.fr.signalling;
575
576         if (conf->station == WANOPT_CPE) {
577
578
579                 if (conf->u.fr.signalling == WANOPT_NO){
580                         printk(KERN_INFO 
581                                 "%s: ERROR - For NO signalling, station must be set to Node!",
582                                          card->devname);
583                         return -EINVAL;
584                 }
585
586                 u.cfg.station = 0;
587                 u.cfg.options |= 0x8000;        /* auto config DLCI */
588                 card->u.f.dlci_num  = 0;
589         
590         } else {
591
592                 u.cfg.station = 1;      /* switch emulation mode */
593
594                 /* For switch emulation we have to create a list of dlci(s)
595                  * that will be sent to be global SET_DLCI_CONFIGURATION 
596                  * command in fr_configure() routine. 
597                  */
598
599                 card->u.f.dlci_num  = min_t(unsigned int, max_t(unsigned int, conf->u.fr.dlci_num, 1), 100);
600         
601                 for ( i = 0; i < card->u.f.dlci_num; i++) {
602
603                         card->u.f.node_dlci[i] = (unsigned short) 
604                                 conf->u.fr.dlci[i] ? conf->u.fr.dlci[i] : 16;
605         
606                 }
607         }
608
609         if (conf->clocking == WANOPT_INTERNAL)
610                 u.cfg.port |= 0x0001;
611
612         if (conf->interface == WANOPT_RS232)
613                 u.cfg.port |= 0x0002;
614
615         if (conf->u.fr.t391)
616                 u.cfg.t391 = min_t(unsigned int, conf->u.fr.t391, 30);
617         else
618                 u.cfg.t391 = 5;
619
620         if (conf->u.fr.t392)
621                 u.cfg.t392 = min_t(unsigned int, conf->u.fr.t392, 30);
622         else
623                 u.cfg.t392 = 15;
624
625         if (conf->u.fr.n391)
626                 u.cfg.n391 = min_t(unsigned int, conf->u.fr.n391, 255);
627         else
628                 u.cfg.n391 = 2;
629
630         if (conf->u.fr.n392)
631                 u.cfg.n392 = min_t(unsigned int, conf->u.fr.n392, 10);
632         else
633                 u.cfg.n392 = 3; 
634
635         if (conf->u.fr.n393)
636                 u.cfg.n393 = min_t(unsigned int, conf->u.fr.n393, 10);
637         else
638                 u.cfg.n393 = 4;
639
640         if (fr_configure(card, &u.cfg))
641                 return -EIO;
642
643         if (card->hw.type == SDLA_S514) {
644         
645                 buf_info = (void*)(card->hw.dpmbase + FR_MB_VECTOR +
646                         FR508_RXBC_OFFS);
647
648                 card->rxmb = (void*)(buf_info->rse_next + card->hw.dpmbase);
649
650                 card->u.f.rxmb_base =
651                         (void*)(buf_info->rse_base + card->hw.dpmbase); 
652
653                 card->u.f.rxmb_last =
654                         (void*)(buf_info->rse_base +
655                         (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) +
656                         card->hw.dpmbase);
657         }else{  
658                 buf_info = (void*)(card->hw.dpmbase + FR508_RXBC_OFFS);
659
660                 card->rxmb = (void*)(buf_info->rse_next -
661                         FR_MB_VECTOR + card->hw.dpmbase);
662                 
663                 card->u.f.rxmb_base =
664                         (void*)(buf_info->rse_base -
665                         FR_MB_VECTOR + card->hw.dpmbase);
666                 
667                 card->u.f.rxmb_last =
668                         (void*)(buf_info->rse_base +
669                         (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) -
670                         FR_MB_VECTOR + card->hw.dpmbase);
671         }
672
673         card->u.f.rx_base = buf_info->buf_base;
674         card->u.f.rx_top  = buf_info->buf_top;
675
676         card->u.f.tx_interrupts_pending = 0;
677
678         card->wandev.mtu        = conf->mtu;
679         card->wandev.bps        = conf->bps;
680         card->wandev.interface  = conf->interface;
681         card->wandev.clocking   = conf->clocking;
682         card->wandev.station    = conf->station;
683         card->poll              = NULL; 
684         card->exec              = &wpf_exec;
685         card->wandev.update     = &update;
686         card->wandev.new_if     = &new_if;
687         card->wandev.del_if     = &del_if;
688         card->wandev.state      = WAN_DISCONNECTED;
689         card->wandev.ttl        = conf->ttl;
690         card->wandev.udp_port   = conf->udp_port;       
691         card->disable_comm      = &disable_comm;        
692         card->u.f.arp_dev       = NULL;
693
694         /* Intialize global statistics for a card */
695         init_global_statistics( card );
696
697         card->TracingEnabled          = 0;
698
699         /* Interrupt Test */
700         Intr_test_counter = 0;
701         card->intr_mode = INTR_TEST_MODE;
702         err = intr_test( card );
703
704         printk(KERN_INFO "%s: End of Interrupt Test rc=0x%x  count=%i\n",
705                         card->devname,err,Intr_test_counter); 
706         
707         if (err || (Intr_test_counter < MAX_INTR_TEST_COUNTER)) {
708                 printk(KERN_ERR "%s: Interrupt Test Failed, Counter: %i\n", 
709                         card->devname, Intr_test_counter);
710                 printk(KERN_ERR "Please choose another interrupt\n");
711                 err = -EIO;
712                 return err;
713         }
714
715         printk(KERN_INFO "%s: Interrupt Test Passed, Counter: %i\n",
716                         card->devname, Intr_test_counter);
717
718
719         /* Apr 28 2000. Nenad Corbic
720          * Enable commnunications here, not in if_open or new_if, since
721          * interfaces come down when the link is disconnected. 
722          */
723          
724         /* If you enable comms and then set ints, you get a Tx int as you
725          * perform the SET_INT_TRIGGERS command. So, we only set int
726          * triggers and then adjust the interrupt mask (to disable Tx ints)
727          * before enabling comms. 
728          */     
729         if (fr_set_intr_mode(card, (FR_INTR_RXRDY | FR_INTR_TXRDY |
730                 FR_INTR_DLC | FR_INTR_TIMER | FR_INTR_TX_MULT_DLCIs) ,
731                 card->wandev.mtu, 0)) {
732                 return -EIO;
733         }
734
735         flags->imask &= ~(FR_INTR_TXRDY | FR_INTR_TIMER);
736  
737         if (fr_comm_enable(card)) {
738                 return -EIO;
739         }       
740         wanpipe_set_state(card, WAN_CONNECTED);
741         spin_lock_init(&card->u.f.if_send_lock);
742         
743         printk(KERN_INFO "\n");
744
745         return 0;
746 }
747
748 /******* WAN Device Driver Entry Points *************************************/
749
750 /*============================================================================
751  * Update device status & statistics.
752  */
753 static int update(struct wan_device* wandev)
754 {
755         volatile sdla_t* card;
756         unsigned long timeout;
757         fr508_flags_t* flags;
758
759         /* sanity checks */
760         if ((wandev == NULL) || (wandev->private == NULL))
761                 return -EFAULT;
762
763         if (wandev->state == WAN_UNCONFIGURED)
764                 return -ENODEV;
765
766         card = wandev->private;
767         flags = card->flags;
768
769
770         card->u.f.update_comms_stats = 1;
771         card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UPDATE;
772         flags->imask |= FR_INTR_TIMER;
773         timeout = jiffies;
774         for(;;) {
775                 if(card->u.f.update_comms_stats == 0)
776                         break;
777                 if (time_after(jiffies, timeout + 1 * HZ)){
778                         card->u.f.update_comms_stats = 0;
779                         return -EAGAIN;
780                 }
781         }
782
783         return 0;
784 }
785
786 /*============================================================================
787  * Create new logical channel.
788  * This routine is called by the router when ROUTER_IFNEW IOCTL is being
789  * handled.
790  * o parse media- and hardware-specific configuration
791  * o make sure that a new channel can be created
792  * o allocate resources, if necessary
793  * o prepare network device structure for registaration.
794  *
795  * Return:      0       o.k.
796  *              < 0     failure (channel will not be created)
797  */
798 static int new_if(struct wan_device* wandev, struct net_device* dev,
799                   wanif_conf_t* conf)
800 {
801         sdla_t* card = wandev->private;
802         fr_channel_t* chan;
803         int dlci = 0;
804         int err = 0;
805
806         
807         if ((conf->name[0] == '\0') || (strlen(conf->name) > WAN_IFNAME_SZ)) {
808                 
809                 printk(KERN_INFO "%s: Invalid interface name!\n",
810                         card->devname);
811                 return -EINVAL;
812         }
813
814         /* allocate and initialize private data */
815         chan = kmalloc(sizeof(fr_channel_t), GFP_KERNEL);
816
817         if (chan == NULL)
818                 return -ENOMEM;
819
820         memset(chan, 0, sizeof(fr_channel_t));
821         strcpy(chan->name, conf->name);
822         chan->card = card;
823
824         /* verify media address */
825         if (is_digit(conf->addr[0])) {
826
827                 dlci = dec_to_uint(conf->addr, 0);
828
829                 if (dlci && (dlci <= HIGHEST_VALID_DLCI)) {
830                 
831                         chan->dlci = dlci;
832                 
833                 } else {
834                 
835                         printk(KERN_ERR
836                                 "%s: Invalid DLCI %u on interface %s!\n",
837                                 wandev->name, dlci, chan->name);
838                         err = -EINVAL;
839                 }
840
841         } else {
842                 printk(KERN_ERR
843                         "%s: Invalid media address on interface %s!\n",
844                         wandev->name, chan->name);
845                 err = -EINVAL;
846         }
847
848         if ((chan->true_if_encoding = conf->true_if_encoding) == WANOPT_YES){
849                 printk(KERN_INFO 
850                         "%s: Enabling, true interface type encoding.\n",
851                         card->devname);
852         }
853         
854
855
856     /* Setup wanpipe as a router (WANPIPE) even if it is
857          * a bridged DLCI, or as an API 
858          */
859         if (strcmp(conf->usedby, "WANPIPE")  == 0  || 
860             strcmp(conf->usedby, "BRIDGE")   == 0  ||
861             strcmp(conf->usedby, "BRIDGE_N") == 0){
862                 
863                 if(strcmp(conf->usedby, "WANPIPE") == 0){
864                         chan->common.usedby = WANPIPE;
865                         
866                         printk(KERN_INFO "%s: Running in WANPIPE mode.\n", 
867                                         card->devname);
868                         
869                 }else if(strcmp(conf->usedby, "BRIDGE") == 0){
870                         
871                         chan->common.usedby = BRIDGE;
872                         
873                         printk(KERN_INFO "%s: Running in WANPIPE (BRIDGE) mode.\n", 
874                                         card->devname);
875                 }else if( strcmp(conf->usedby, "BRIDGE_N") == 0 ){
876                         
877                         chan->common.usedby = BRIDGE_NODE;
878                 
879                         printk(KERN_INFO "%s: Running in WANPIPE (BRIDGE_NODE) mode.\n", 
880                                         card->devname);
881                 }
882
883                 if (!err){
884                         /* Dynamic interface configuration option.
885                          * On disconnect, if the options is selected,
886                          * the interface will be brought down */
887                         if (conf->if_down == WANOPT_YES){ 
888                                 set_bit(DYN_OPT_ON,&chan->interface_down);
889                                 printk(KERN_INFO 
890                                     "%s: Dynamic interface configuration enabled.\n",
891                                         card->devname);
892                         }
893                 }
894
895         } else if(strcmp(conf->usedby, "API") == 0){
896
897                 chan->common.usedby = API;
898                 printk(KERN_INFO "%s: Running in API mode.\n",
899                         wandev->name);
900         }
901
902         if (err) {
903                 
904                 kfree(chan);
905                 return err;
906         }
907
908         /* place cir,be,bc and other channel specific information into the
909          * chan structure 
910          */
911         if (conf->cir) {
912
913                 chan->cir = max_t(unsigned int, 1,
914                                 min_t(unsigned int, conf->cir, 512));
915                 chan->cir_status = CIR_ENABLED; 
916
917                 
918                 /* If CIR is enabled, force BC to equal CIR
919                  * this solves number of potential problems if CIR is 
920                  * set and BC is not 
921                  */
922                 chan->bc = chan->cir;
923
924                 if (conf->be){
925                         chan->be = max_t(unsigned int,
926                                        0, min_t(unsigned int, conf->be, 511));
927                 }else{  
928                         conf->be = 0;
929                 }
930
931                 printk (KERN_INFO "%s: CIR enabled for DLCI %i \n",
932                                 wandev->name,chan->dlci);
933                 printk (KERN_INFO "%s:     CIR = %i ; BC = %i ; BE = %i\n",
934                                 wandev->name,chan->cir,chan->bc,chan->be);
935
936
937         }else{
938                 chan->cir_status = CIR_DISABLED;
939                 printk (KERN_INFO "%s: CIR disabled for DLCI %i\n",
940                                 wandev->name,chan->dlci);
941         }
942
943         chan->mc = conf->mc;
944
945         if (conf->inarp == WANOPT_YES){
946                 printk(KERN_INFO "%s: Inverse ARP Support Enabled\n",card->devname);
947                 chan->inarp = conf->inarp ? INARP_REQUEST : INARP_NONE;
948                 chan->inarp_interval = conf->inarp_interval ? conf->inarp_interval : 10;
949         }else{
950                 printk(KERN_INFO "%s: Inverse ARP Support Disabled\n",card->devname);
951                 chan->inarp = INARP_NONE;
952                 chan->inarp_interval = 10;
953         }
954
955
956         chan->dlci_configured = DLCI_NOT_CONFIGURED;    
957
958
959         /*FIXME: IPX disabled in this WANPIPE version */
960         if (conf->enable_IPX == WANOPT_YES){
961                 printk(KERN_INFO "%s: ERROR - This version of WANPIPE doesn't support IPX\n",
962                                 card->devname);
963                 kfree(chan);
964                 return -EINVAL;
965         }else{
966                 chan->enable_IPX = WANOPT_NO;
967         }       
968
969         if (conf->network_number){
970                 chan->network_number = conf->network_number;
971         }else{
972                 chan->network_number = 0xDEADBEEF;
973         }
974
975         chan->route_flag = NO_ROUTE;
976         
977         init_chan_statistics(chan);
978
979         chan->transmit_length = 0;
980
981         /* prepare network device data space for registration */
982         strcpy(dev->name,chan->name);
983         
984         dev->init = &if_init;
985         dev->priv = chan;
986
987         /* Initialize FR Polling Task Queue
988          * We need a poll routine for each network
989          * interface. 
990          */
991         INIT_WORK(&chan->fr_poll_work, (void *)fr_poll, dev);
992
993         init_timer(&chan->fr_arp_timer);
994         chan->fr_arp_timer.data=(unsigned long)dev;
995         chan->fr_arp_timer.function = fr_arp;
996
997         wandev->new_if_cnt++;
998
999         /* Tells us that if this interface is a
1000          * gateway or not */
1001         if ((chan->gateway = conf->gateway) == WANOPT_YES){
1002                 printk(KERN_INFO "%s: Interface %s is set as a gateway.\n",
1003                         card->devname,dev->name);
1004         }
1005
1006         /* M. Grant Patch Apr 28 2000 
1007          * Disallow duplicate dlci configurations. */
1008         if (card->u.f.dlci_to_dev_map[chan->dlci] != NULL) {
1009                 kfree(chan);
1010                 return -EBUSY;
1011         }
1012
1013         /* Configure this dlci at a later date, when
1014          * the interface comes up. i.e. when if_open() 
1015          * executes */
1016         set_bit(0,&chan->config_dlci);
1017         
1018         printk(KERN_INFO "\n");
1019
1020         return 0;
1021 }
1022
1023 /*============================================================================
1024  * Delete logical channel.
1025  */
1026 static int del_if(struct wan_device* wandev, struct net_device* dev)
1027 {
1028         fr_channel_t* chan = dev->priv;
1029         unsigned long smp_flags=0;
1030
1031         /* This interface is dead, make sure the 
1032          * ARP timer is stopped */
1033         del_timer(&chan->fr_arp_timer);
1034         
1035         /* If we are a NODE, we must unconfigure this DLCI
1036          * Trigger an unconfigure command that will
1037          * be executed in timer interrupt. We must wait
1038          * for the command to complete. */
1039         trigger_unconfig_fr(dev);
1040
1041         lock_adapter_irq(&wandev->lock, &smp_flags);
1042         wandev->new_if_cnt--;
1043         unlock_adapter_irq(&wandev->lock, &smp_flags);
1044
1045         return 0;
1046 }
1047
1048
1049 /*=====================================================================
1050  * disable_comm
1051  *
1052  * Description:
1053  *      Disable communications.
1054  *      This code runs in shutdown (sdlamain.c)
1055  *      under critical flag. Therefore it is not
1056  *      necessary to set a critical flag here 
1057  *
1058  * Usage:
1059  *      Commnunications are disabled only on a card
1060  *      shutdown.
1061  */
1062
1063 static void disable_comm (sdla_t *card)
1064 {
1065         printk(KERN_INFO "%s: Disabling Communications!\n",
1066                         card->devname);
1067         fr_comm_disable(card);
1068 }
1069
1070 /****** WANPIPE-specific entry points ***************************************/
1071
1072 /*============================================================================
1073  * Execute adapter interface command.
1074  */
1075 static int wpf_exec (struct sdla* card, void* u_cmd, void* u_data)
1076 {
1077         fr_mbox_t* mbox = card->mbox;
1078         int retry = MAX_CMD_RETRY;
1079         int err, len;
1080         fr_cmd_t cmd;
1081
1082         if(copy_from_user((void*)&cmd, u_cmd, sizeof(cmd)))
1083                 return -EFAULT;
1084         
1085         /* execute command */
1086         do
1087         {
1088                 memcpy(&mbox->cmd, &cmd, sizeof(cmd));
1089                 
1090                 if (cmd.length){
1091                         if( copy_from_user((void*)&mbox->data, u_data, cmd.length))
1092                                 return -EFAULT;
1093                 }
1094                 
1095                 if (sdla_exec(mbox))
1096                         err = mbox->cmd.result;
1097
1098                 else return -EIO;
1099         
1100         } while (err && retry-- && fr_event(card, err, mbox));
1101
1102         /* return result */
1103         if (copy_to_user(u_cmd, (void*)&mbox->cmd, sizeof(fr_cmd_t)))
1104                 return -EFAULT;
1105
1106         len = mbox->cmd.length;
1107
1108         if (len && u_data && !copy_to_user(u_data, (void*)&mbox->data, len))
1109                 return -EFAULT;
1110         return 0;
1111 }
1112
1113 /****** Network Device Interface ********************************************/
1114
1115 /*============================================================================
1116  * Initialize Linux network interface.
1117  *
1118  * This routine is called only once for each interface, during Linux network
1119  * interface registration.  Returning anything but zero will fail interface
1120  * registration.
1121  */
1122 static int if_init(struct net_device* dev)
1123 {
1124         fr_channel_t* chan = dev->priv;
1125         sdla_t* card = chan->card;
1126         struct wan_device* wandev = &card->wandev;
1127
1128         /* Initialize device driver entry points */
1129         dev->open               = &if_open;
1130         dev->stop               = &if_close;
1131         dev->hard_header        = NULL;
1132         dev->rebuild_header     = &if_rebuild_hdr;
1133         dev->hard_start_xmit    = &if_send;
1134         dev->get_stats          = &if_stats;
1135         dev->tx_timeout         = &if_tx_timeout;
1136         dev->watchdog_timeo     = TX_TIMEOUT;
1137         
1138         if (chan->common.usedby == WANPIPE || chan->common.usedby == API){
1139
1140                 /* Initialize media-specific parameters */
1141                 if (chan->true_if_encoding){
1142                         dev->type               = ARPHRD_DLCI;  /* This breaks tcpdump */
1143                 }else{
1144                         dev->type               = ARPHRD_PPP;   /* ARP h/w type */
1145                 }
1146                 
1147                 dev->flags              |= IFF_POINTOPOINT;
1148                 dev->flags              |= IFF_NOARP;
1149
1150                 /* Enable Multicast addressing */
1151                 if (chan->mc == WANOPT_YES){
1152                         dev->flags      |= IFF_MULTICAST;
1153                 }
1154
1155                 dev->mtu                = wandev->mtu - FR_HEADER_LEN;
1156                 /* For an API, the maximum number of bytes that the stack will pass
1157                    to the driver is (dev->mtu + dev->hard_header_len). So, adjust the
1158                    mtu so that a frame of maximum size can be transmitted by the API. 
1159                 */
1160                 if(chan->common.usedby == API) {
1161                         dev->mtu += (sizeof(api_tx_hdr_t) - FR_HEADER_LEN);
1162                 }
1163                 
1164                 dev->hard_header_len    = FR_HEADER_LEN;/* media header length */
1165                 dev->addr_len           = 2;            /* hardware address length */
1166                 *(unsigned short*)dev->dev_addr = htons(chan->dlci);
1167
1168                 /* Set transmit buffer queue length */
1169                 dev->tx_queue_len = 100;
1170
1171         }else{
1172
1173                 /* Setup the interface for Bridging */
1174                 int hw_addr=0;
1175                 ether_setup(dev);
1176                 
1177                 /* Use a random number to generate the MAC address */
1178                 memcpy(dev->dev_addr, "\xFE\xFC\x00\x00\x00\x00", 6);
1179                 get_random_bytes(&hw_addr, sizeof(hw_addr));
1180                 *(int *)(dev->dev_addr + 2) += hw_addr;
1181         }
1182                 
1183         /* Initialize hardware parameters (just for reference) */
1184         dev->irq        = wandev->irq;
1185         dev->dma        = wandev->dma;
1186         dev->base_addr  = wandev->ioport;
1187         dev->mem_start  = wandev->maddr;
1188         dev->mem_end    = wandev->maddr + wandev->msize - 1;
1189         SET_MODULE_OWNER(dev);
1190
1191         return 0;
1192 }
1193
1194 /*============================================================================
1195  * Open network interface.
1196  * o if this is the first open, then enable communications and interrupts.
1197  * o prevent module from unloading by incrementing use count
1198  *
1199  * Return 0 if O.k. or errno.
1200  */
1201 static int if_open(struct net_device* dev)
1202 {
1203         fr_channel_t* chan = dev->priv;
1204         sdla_t* card = chan->card;
1205         int err = 0;
1206         struct timeval tv;
1207
1208         if (netif_running(dev))
1209                 return -EBUSY;
1210         
1211         /* Initialize the task queue */
1212         chan->tq_working=0;
1213
1214         INIT_WORK(&chan->common.wanpipe_work, (void *)fr_bh, dev);
1215
1216         /* Allocate and initialize BH circular buffer */
1217         chan->bh_head = kmalloc((sizeof(bh_data_t)*MAX_BH_BUFF),GFP_ATOMIC);
1218         memset(chan->bh_head,0,(sizeof(bh_data_t)*MAX_BH_BUFF));
1219         atomic_set(&chan->bh_buff_used, 0);
1220
1221         netif_start_queue(dev);
1222
1223         wanpipe_open(card);
1224         do_gettimeofday( &tv );
1225         chan->router_start_time = tv.tv_sec;
1226         
1227         if (test_bit(0,&chan->config_dlci)){
1228                 trigger_config_fr (card);
1229         }else if (chan->inarp == INARP_REQUEST){
1230                 trigger_fr_arp(dev);
1231         }
1232         
1233         return err;
1234 }
1235
1236 /*============================================================================
1237  * Close network interface.
1238  * o if this is the last open, then disable communications and interrupts.
1239  * o reset flags.
1240  */
1241 static int if_close(struct net_device* dev)
1242 {
1243         fr_channel_t* chan = dev->priv;
1244         sdla_t* card = chan->card;
1245
1246         if (chan->inarp == INARP_CONFIGURED) {
1247                 chan->inarp = INARP_REQUEST;
1248         }
1249
1250         netif_stop_queue(dev);
1251         wanpipe_close(card);
1252
1253         return 0;
1254 }
1255
1256 /*============================================================================
1257  * Re-build media header.
1258  *
1259  * Return:      1       physical address resolved.
1260  *              0       physical address not resolved
1261  */
1262 static int if_rebuild_hdr (struct sk_buff* skb)
1263 {
1264         struct net_device *dev = skb->dev;
1265         fr_channel_t* chan = dev->priv;
1266         sdla_t* card = chan->card;
1267
1268         printk(KERN_INFO "%s: rebuild_header() called for interface %s!\n",
1269                 card->devname, dev->name);
1270         return 1;
1271 }
1272
1273 /*============================================================================
1274  * Handle transmit timeout event from netif watchdog
1275  */
1276 static void if_tx_timeout(struct net_device *dev)
1277 {
1278         fr_channel_t* chan = dev->priv;
1279         sdla_t *card = chan->card;
1280
1281         /* If our device stays busy for at least 5 seconds then we will
1282          * kick start the device by making dev->tbusy = 0.  We expect
1283          * that our device never stays busy more than 5 seconds. So this                 
1284          * is only used as a last resort.
1285          */
1286
1287         chan->drvstats_if_send.if_send_tbusy++;
1288         ++chan->ifstats.collisions;
1289
1290         printk (KERN_INFO "%s: Transmit timed out on %s\n", 
1291                         card->devname, dev->name);
1292         chan->drvstats_if_send.if_send_tbusy_timeout++;
1293         netif_wake_queue (dev);
1294
1295 }
1296
1297
1298 /*============================================================================
1299  * Send a packet on a network interface.
1300  * o set tbusy flag (marks start of the transmission) to block a timer-based
1301  *   transmit from overlapping.
1302  * o set critical flag when accessing board.
1303  * o check link state. If link is not up, then drop the packet.
1304  * o check channel status. If it's down then initiate a call.
1305  * o pass a packet to corresponding WAN device.
1306  * o free socket buffer
1307  *
1308  * Return:      0       complete (socket buffer must be freed)
1309  *              non-0   packet may be re-transmitted (tbusy must be set)
1310  *
1311  * Notes:
1312  * 1. This routine is called either by the protocol stack or by the "net
1313  *    bottom half" (with interrupts enabled).
1314  * 
1315  * 2. Using netif_start_queue() and netif_stop_queue()
1316  *    will inhibit further transmit requests from the protocol stack 
1317  *    and can be used for flow control with protocol layer.
1318  */
1319 static int if_send(struct sk_buff* skb, struct net_device* dev)
1320 {
1321         fr_channel_t* chan = dev->priv;
1322         sdla_t* card = chan->card;
1323         int err;
1324         unsigned char *sendpacket;
1325         fr508_flags_t* adptr_flags = card->flags;
1326         int udp_type;
1327         long delay_tx_queued = 0;
1328         unsigned long smp_flags=0;
1329         unsigned char attr = 0;
1330
1331         chan->drvstats_if_send.if_send_entry++;
1332
1333         netif_stop_queue(dev);
1334         
1335         if (skb == NULL) {             
1336                 /* if we get here, some higher layer thinks we've missed an
1337                  * tx-done interrupt.
1338                  */
1339                 printk(KERN_INFO "%s: interface %s got kicked!\n", 
1340                         card->devname, dev->name);
1341                 chan->drvstats_if_send.if_send_skb_null ++;
1342
1343                 netif_wake_queue(dev);
1344                 return 0;
1345         }
1346
1347         /* If a peripheral task is running just drop packets */
1348         if (test_bit(PERI_CRIT, &card->wandev.critical)){
1349                 
1350                 printk(KERN_INFO "%s: Critical in if_send(): Peripheral running!\n",
1351                                 card->devname);
1352                 
1353                 dev_kfree_skb_any(skb);
1354                 netif_start_queue(dev);
1355                 return 0;
1356         }
1357
1358         /* We must set the 'tbusy' flag if we already have a packet queued for
1359            transmission in the transmit interrupt handler. However, we must
1360            ensure that the transmit interrupt does not reset the 'tbusy' flag
1361            just before we set it, as this will result in a "transmit timeout".
1362         */
1363         set_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical);
1364         if(chan->transmit_length) {
1365                 netif_stop_queue(dev);
1366                 chan->tick_counter = jiffies;
1367                 clear_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical);
1368                 return 1;
1369         }
1370         clear_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical);
1371  
1372         /* Move the if_header() code to here. By inserting frame
1373          * relay header in if_header() we would break the
1374          * tcpdump and other packet sniffers */
1375         chan->fr_header_len = setup_fr_header(&skb,dev,chan->common.usedby);
1376         if (chan->fr_header_len < 0 ){
1377                 ++chan->ifstats.tx_dropped;
1378                 ++card->wandev.stats.tx_dropped;
1379                 
1380                 dev_kfree_skb_any(skb);
1381                 netif_start_queue(dev); 
1382                 return 0;
1383         }
1384
1385         sendpacket = skb->data;
1386
1387         udp_type = udp_pkt_type(skb, card);
1388
1389         if(udp_type != UDP_INVALID_TYPE) {
1390                 if(store_udp_mgmt_pkt(udp_type, UDP_PKT_FRM_STACK, card, skb,
1391                         chan->dlci)) {
1392                         adptr_flags->imask |= FR_INTR_TIMER;
1393                         if (udp_type == UDP_FPIPE_TYPE){
1394                                 chan->drvstats_if_send.
1395                                         if_send_PIPE_request ++;
1396                         }
1397                 }
1398                 netif_start_queue(dev);
1399                 return 0;
1400         }
1401
1402         //FIXME: can we do better than sendpacket[2]?
1403         if ((chan->common.usedby == WANPIPE) && (sendpacket[2] == 0x45)) {
1404                 
1405                 /* check to see if the source IP address is a broadcast or */
1406                 /* multicast IP address */
1407                 if(chk_bcast_mcast_addr(card, dev, skb)){
1408                         ++chan->ifstats.tx_dropped;
1409                         ++card->wandev.stats.tx_dropped;
1410                         dev_kfree_skb_any(skb);
1411                         netif_start_queue(dev);
1412                         return 0;
1413                 }
1414         }
1415
1416         
1417         /* Lock the S514/S508 card: SMP Supported */
1418         s508_s514_lock(card,&smp_flags);
1419
1420         if (test_and_set_bit(SEND_CRIT, (void*)&card->wandev.critical)) {
1421                 
1422                 chan->drvstats_if_send.if_send_critical_non_ISR ++;
1423                 chan->ifstats.tx_dropped ++;
1424                 printk(KERN_INFO "%s Critical in IF_SEND: if_send() already running!\n", 
1425                                 card->devname);
1426                 goto if_send_start_and_exit;
1427         }
1428         
1429         /* API packet check: minimum packet size must be greater than 
1430          * 16 byte API header */
1431         if((chan->common.usedby == API) && (skb->len <= sizeof(api_tx_hdr_t))) {
1432                 ++chan->ifstats.tx_dropped;
1433                 ++card->wandev.stats.tx_dropped;
1434             
1435                 
1436                 goto if_send_start_and_exit;
1437
1438         }else{
1439                 /* During API transmission, get rid of the API header */
1440                 if (chan->common.usedby == API) {
1441                         api_tx_hdr_t* api_tx_hdr;
1442                         api_tx_hdr = (api_tx_hdr_t*)&skb->data[0x00];
1443                         attr = api_tx_hdr->attr;
1444                         skb_pull(skb,sizeof(api_tx_hdr_t));
1445                 }
1446         }
1447
1448         if (card->wandev.state != WAN_CONNECTED) {
1449                 chan->drvstats_if_send.if_send_wan_disconnected ++;
1450                 ++chan->ifstats.tx_dropped;
1451                 ++card->wandev.stats.tx_dropped;
1452         
1453         } else if (chan->common.state != WAN_CONNECTED) {
1454                 chan->drvstats_if_send.if_send_dlci_disconnected ++;
1455
1456                 /* Update the DLCI state in timer interrupt */
1457                 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UPDATE_STATE;    
1458                 adptr_flags->imask |= FR_INTR_TIMER;
1459
1460                 ++chan->ifstats.tx_dropped;
1461                 ++card->wandev.stats.tx_dropped;
1462                 
1463         } else if (!is_tx_ready(card, chan)) {
1464                 /* No tx buffers available, store for delayed transmit */
1465                 if (!setup_for_delayed_transmit(dev, skb)){
1466                         set_bit(1,&delay_tx_queued);
1467                 }
1468                 chan->drvstats_if_send.if_send_no_bfrs++;
1469                 
1470         } else if (!skb->protocol) {
1471                 /* No protocols drop packet */
1472                 chan->drvstats_if_send.if_send_protocol_error ++;
1473                 ++card->wandev.stats.tx_errors;
1474         
1475         } else if (test_bit(ARP_CRIT,&card->wandev.critical)){
1476                 /* We are trying to send an ARP Packet, block IP data until
1477                  * ARP is sent */
1478                 ++chan->ifstats.tx_dropped;
1479                 ++card->wandev.stats.tx_dropped;
1480                 
1481         } else {
1482                 //FIXME: IPX is not implemented in this version of Frame Relay ?
1483                 if((chan->common.usedby == WANPIPE) &&
1484                         sendpacket[1] == 0x00 &&
1485                         sendpacket[2] == 0x80 &&
1486                         sendpacket[6] == 0x81 &&
1487                         sendpacket[7] == 0x37) {
1488                         
1489                         if( chan->enable_IPX ) {
1490                                 switch_net_numbers(sendpacket, 
1491                                                 chan->network_number, 0);
1492                         } else {
1493                                 //FIXME: Take this out when IPX is fixed 
1494                                 printk(KERN_INFO 
1495                                 "%s: WARNING: Unsupported IPX data in send, packet dropped\n",
1496                                         card->devname);
1497                         }
1498                         
1499                 }else{
1500                         err = fr_send_data_header(card, chan->dlci, attr, skb->len, skb->data, chan->fr_header_len);
1501                         if (err) {
1502                                 switch(err) {
1503                                 case FRRES_CIR_OVERFLOW:
1504                                 case FRRES_BUFFER_OVERFLOW:
1505                                         if (!setup_for_delayed_transmit(dev, skb)){
1506                                                 set_bit(1,&delay_tx_queued);
1507                                         }
1508                                         chan->drvstats_if_send.
1509                                                 if_send_adptr_bfrs_full ++;
1510                                         break;
1511                                         
1512                                 case FRRES_TOO_LONG:
1513                                         if (net_ratelimit()){
1514                                                 printk(KERN_INFO 
1515                                                 "%s: Error: Frame too long, transmission failed %i\n",
1516                                                  card->devname, (unsigned int)skb->len);
1517                                         }
1518                                         /* Drop down to default */
1519                                 default:
1520                                         chan->drvstats_if_send.
1521                                                 if_send_dlci_disconnected ++;
1522                                         ++chan->ifstats.tx_dropped;
1523                                         ++card->wandev.stats.tx_dropped;
1524                                         break;
1525                                 }
1526                         } else {
1527                                 chan->drvstats_if_send.
1528                                         if_send_bfr_passed_to_adptr++;
1529                                 ++chan->ifstats.tx_packets;
1530                                 ++card->wandev.stats.tx_packets;
1531                                 
1532                                 chan->ifstats.tx_bytes += skb->len;
1533                                 card->wandev.stats.tx_bytes += skb->len;
1534                                 dev->trans_start = jiffies;
1535                         }
1536                 }
1537         }
1538
1539 if_send_start_and_exit:
1540
1541         netif_start_queue(dev);
1542         
1543         /* If we queued the packet for transmission, we must not
1544          * deallocate it. The packet is unlinked from the IP stack
1545          * not copied. Therefore, we must keep the original packet */
1546         if (!test_bit(1,&delay_tx_queued)) {
1547                 dev_kfree_skb_any(skb);
1548         }else{
1549                 adptr_flags->imask |= FR_INTR_TXRDY;
1550                 card->u.f.tx_interrupts_pending ++;
1551         }
1552
1553         clear_bit(SEND_CRIT, (void*)&card->wandev.critical);
1554
1555         s508_s514_unlock(card,&smp_flags);
1556
1557         return 0;
1558 }
1559
1560
1561
1562 /*============================================================================
1563  * Setup so that a frame can be transmitted on the occurrence of a transmit
1564  * interrupt.
1565  */
1566 static int setup_for_delayed_transmit(struct net_device* dev,
1567                                       struct sk_buff *skb)
1568 {
1569         fr_channel_t* chan = dev->priv;
1570         sdla_t* card = chan->card;
1571         fr_dlci_interface_t* dlci_interface;
1572         int len = skb->len;
1573
1574         /* Check that the dlci is properly configured,
1575          * before using tx interrupt */
1576         if (!chan->dlci_int_interface){
1577                 if (net_ratelimit()){ 
1578                         printk(KERN_INFO 
1579                                 "%s: ERROR on DLCI %i: Not configured properly !\n",
1580                                         card->devname, chan->dlci);
1581                         printk(KERN_INFO "%s: Please contact Sangoma Technologies\n",
1582                                         card->devname);
1583                 }
1584                 return 1;
1585         }
1586                 
1587         dlci_interface = chan->dlci_int_interface;
1588
1589         if(chan->transmit_length) {
1590                 printk(KERN_INFO "%s: Big mess in setup_for_del...\n",
1591                                 card->devname);
1592                 return 1;
1593         }
1594
1595         if(len > FR_MAX_NO_DATA_BYTES_IN_FRAME) {
1596                 //FIXME: increment some statistic */
1597                 return 1;
1598         }
1599
1600         skb_unlink(skb);
1601         
1602         chan->transmit_length = len;
1603         chan->delay_skb = skb;
1604         
1605         dlci_interface->gen_interrupt |= FR_INTR_TXRDY;
1606         dlci_interface->packet_length = len;
1607
1608         /* Turn on TX interrupt at the end of if_send */
1609         return 0;
1610 }
1611
1612
1613 /*============================================================================
1614  * Check to see if the packet to be transmitted contains a broadcast or
1615  * multicast source IP address.
1616  * Return 0 if not broadcast/multicast address, otherwise return 1.
1617  */
1618
1619 static int chk_bcast_mcast_addr(sdla_t *card, struct net_device* dev,
1620                                 struct sk_buff *skb)
1621 {
1622         u32 src_ip_addr;
1623         u32 broadcast_ip_addr = 0;
1624         struct in_device *in_dev;
1625         fr_channel_t* chan = dev->priv;
1626  
1627         /* read the IP source address from the outgoing packet */
1628         src_ip_addr = *(u32 *)(skb->data + 14);
1629
1630         /* read the IP broadcast address for the device */
1631         in_dev = dev->ip_ptr;
1632         if(in_dev != NULL) {
1633                 struct in_ifaddr *ifa= in_dev->ifa_list;
1634                 if(ifa != NULL)
1635                         broadcast_ip_addr = ifa->ifa_broadcast;
1636                 else
1637                         return 0;
1638         }
1639
1640         /* check if the IP Source Address is a Broadcast address */
1641         if((dev->flags & IFF_BROADCAST) && (src_ip_addr == broadcast_ip_addr)) {
1642                 printk(KERN_INFO
1643                         "%s: Broadcast Source Address silently discarded\n",
1644                         card->devname);
1645                 return 1;
1646         }
1647
1648         /* check if the IP Source Address is a Multicast address */
1649         if((chan->mc == WANOPT_NO) && (ntohl(src_ip_addr) >= 0xE0000001) &&
1650                 (ntohl(src_ip_addr) <= 0xFFFFFFFE)) {
1651                 printk(KERN_INFO
1652                         "%s: Multicast Source Address silently discarded\n",
1653                         card->devname);
1654                 return 1;
1655         }
1656
1657         return 0;
1658 }
1659
1660 /*============================================================================
1661  * Reply to UDP Management system.
1662  * Return nothing.
1663  */
1664 static int reply_udp( unsigned char *data, unsigned int mbox_len ) 
1665 {
1666         unsigned short len, udp_length, temp, ip_length;
1667         unsigned long ip_temp;
1668         int even_bound = 0;
1669
1670   
1671         fr_udp_pkt_t *fr_udp_pkt = (fr_udp_pkt_t *)data; 
1672
1673         /* Set length of packet */
1674         len = //sizeof(fr_encap_hdr_t)+
1675               sizeof(ip_pkt_t)+ 
1676               sizeof(udp_pkt_t)+
1677               sizeof(wp_mgmt_t)+
1678               sizeof(cblock_t)+
1679               mbox_len;
1680  
1681
1682         /* fill in UDP reply */
1683         fr_udp_pkt->wp_mgmt.request_reply = UDPMGMT_REPLY;
1684   
1685         /* fill in UDP length */
1686         udp_length = sizeof(udp_pkt_t)+ 
1687                      sizeof(wp_mgmt_t)+
1688                      sizeof(cblock_t)+
1689                      mbox_len; 
1690
1691
1692         /* put it on an even boundary */
1693         if ( udp_length & 0x0001 ) {
1694                 udp_length += 1;
1695                 len += 1;
1696                 even_bound = 1;
1697         }
1698
1699         temp = (udp_length<<8)|(udp_length>>8);
1700         fr_udp_pkt->udp_pkt.udp_length = temp;
1701          
1702         /* swap UDP ports */
1703         temp = fr_udp_pkt->udp_pkt.udp_src_port;
1704         fr_udp_pkt->udp_pkt.udp_src_port = 
1705                         fr_udp_pkt->udp_pkt.udp_dst_port; 
1706         fr_udp_pkt->udp_pkt.udp_dst_port = temp;
1707
1708
1709
1710         /* add UDP pseudo header */
1711         temp = 0x1100;
1712         *((unsigned short *)
1713                 (fr_udp_pkt->data+mbox_len+even_bound)) = temp; 
1714         temp = (udp_length<<8)|(udp_length>>8);
1715         *((unsigned short *)
1716                 (fr_udp_pkt->data+mbox_len+even_bound+2)) = temp;
1717                  
1718         /* calculate UDP checksum */
1719         fr_udp_pkt->udp_pkt.udp_checksum = 0;
1720
1721         fr_udp_pkt->udp_pkt.udp_checksum = 
1722                 calc_checksum(&data[UDP_OFFSET/*+sizeof(fr_encap_hdr_t)*/],
1723                               udp_length+UDP_OFFSET);
1724
1725         /* fill in IP length */
1726         ip_length = udp_length + sizeof(ip_pkt_t);
1727         temp = (ip_length<<8)|(ip_length>>8);
1728         fr_udp_pkt->ip_pkt.total_length = temp;
1729   
1730         /* swap IP addresses */
1731         ip_temp = fr_udp_pkt->ip_pkt.ip_src_address;
1732         fr_udp_pkt->ip_pkt.ip_src_address = 
1733                                 fr_udp_pkt->ip_pkt.ip_dst_address;
1734         fr_udp_pkt->ip_pkt.ip_dst_address = ip_temp;
1735
1736                  
1737         /* fill in IP checksum */
1738         fr_udp_pkt->ip_pkt.hdr_checksum = 0;
1739         fr_udp_pkt->ip_pkt.hdr_checksum = 
1740                 calc_checksum(&data[/*sizeof(fr_encap_hdr_t)*/0],
1741                               sizeof(ip_pkt_t));
1742
1743         return len;
1744 } /* reply_udp */
1745
1746 unsigned short calc_checksum (char *data, int len)
1747 {
1748         unsigned short temp; 
1749         unsigned long sum=0;
1750         int i;
1751
1752         for( i = 0; i <len; i+=2 ) {
1753                 memcpy(&temp,&data[i],2);
1754                 sum += (unsigned long)temp;
1755         }
1756
1757         while (sum >> 16 ) {
1758                 sum = (sum & 0xffffUL) + (sum >> 16);
1759         }
1760
1761         temp = (unsigned short)sum;
1762         temp = ~temp;
1763
1764         if( temp == 0 ) 
1765                 temp = 0xffff;
1766
1767         return temp;    
1768 }
1769
1770 /*
1771    If incoming is 0 (outgoing)- if the net numbers is ours make it 0
1772    if incoming is 1 - if the net number is 0 make it ours 
1773
1774 */
1775 static void switch_net_numbers(unsigned char *sendpacket, unsigned long network_number, unsigned char incoming)
1776 {
1777         unsigned long pnetwork_number;
1778
1779         pnetwork_number = (unsigned long)((sendpacket[14] << 24) + 
1780                           (sendpacket[15] << 16) + (sendpacket[16] << 8) + 
1781                           sendpacket[17]);
1782
1783         if (!incoming) {
1784                 /* If the destination network number is ours, make it 0 */
1785                 if( pnetwork_number == network_number) {
1786                         sendpacket[14] = sendpacket[15] = sendpacket[16] = 
1787                                          sendpacket[17] = 0x00;
1788                 }
1789         } else {
1790                 /* If the incoming network is 0, make it ours */
1791                 if( pnetwork_number == 0) {
1792                         sendpacket[14] = (unsigned char)(network_number >> 24);
1793                         sendpacket[15] = (unsigned char)((network_number & 
1794                                          0x00FF0000) >> 16);
1795                         sendpacket[16] = (unsigned char)((network_number & 
1796                                          0x0000FF00) >> 8);
1797                         sendpacket[17] = (unsigned char)(network_number & 
1798                                          0x000000FF);
1799                 }
1800         }
1801
1802
1803         pnetwork_number = (unsigned long)((sendpacket[26] << 24) + 
1804                           (sendpacket[27] << 16) + (sendpacket[28] << 8) + 
1805                           sendpacket[29]);
1806
1807         if( !incoming ) {
1808                 /* If the source network is ours, make it 0 */
1809                 if( pnetwork_number == network_number) {
1810                         sendpacket[26] = sendpacket[27] = sendpacket[28] = 
1811                                          sendpacket[29] = 0x00;
1812                 }
1813         } else {
1814                 /* If the source network is 0, make it ours */
1815                 if( pnetwork_number == 0 ) {
1816                         sendpacket[26] = (unsigned char)(network_number >> 24);
1817                         sendpacket[27] = (unsigned char)((network_number & 
1818                                          0x00FF0000) >> 16);
1819                         sendpacket[28] = (unsigned char)((network_number & 
1820                                          0x0000FF00) >> 8);
1821                         sendpacket[29] = (unsigned char)(network_number & 
1822                                          0x000000FF);
1823                 }
1824         }
1825 } /* switch_net_numbers */
1826
1827 /*============================================================================
1828  * Get ethernet-style interface statistics.
1829  * Return a pointer to struct enet_statistics.
1830  */
1831 static struct net_device_stats *if_stats(struct net_device *dev)
1832 {
1833         fr_channel_t* chan = dev->priv;
1834         
1835         if(chan == NULL)
1836                 return NULL;
1837
1838         return &chan->ifstats;
1839 }
1840
1841 /****** Interrupt Handlers **************************************************/
1842
1843 /*============================================================================
1844  * fr_isr:      S508 frame relay interrupt service routine.
1845  *
1846  * Description:
1847  *      Frame relay main interrupt service route. This
1848  *      function check the interrupt type and takes
1849  *      the appropriate action.
1850  */
1851 static void fr_isr (sdla_t* card)
1852 {
1853         fr508_flags_t* flags = card->flags;
1854         char *ptr = &flags->iflag;
1855         int i,err;
1856         fr_mbox_t* mbox = card->mbox;
1857
1858         /* This flag prevents nesting of interrupts.  See sdla_isr() routine
1859          * in sdlamain.c.  */
1860         card->in_isr = 1;
1861         
1862         ++card->statistics.isr_entry;
1863
1864
1865         /* All peripheral (configuraiton, re-configuration) events
1866          * take presidence over the ISR.  Thus, retrigger */
1867         if (test_bit(PERI_CRIT, (void*)&card->wandev.critical)) {
1868                 ++card->statistics.isr_already_critical;
1869                 goto fr_isr_exit;
1870         }
1871         
1872         if(card->hw.type != SDLA_S514) {
1873                 if (test_bit(SEND_CRIT, (void*)&card->wandev.critical)) {
1874                         printk(KERN_INFO "%s: Critical while in ISR: If Send Running!\n",
1875                                 card->devname);
1876                         ++card->statistics.isr_already_critical;
1877                         goto fr_isr_exit;
1878                 }
1879         }
1880
1881         switch (flags->iflag) {
1882
1883                 case FR_INTR_RXRDY:  /* receive interrupt */
1884                         ++card->statistics.isr_rx;
1885                         rx_intr(card);
1886                         break;
1887
1888
1889                 case FR_INTR_TXRDY:  /* transmit interrupt */
1890                         ++ card->statistics.isr_tx; 
1891                         tx_intr(card); 
1892                         break;
1893
1894                 case FR_INTR_READY:     
1895                         Intr_test_counter++;
1896                         ++card->statistics.isr_intr_test;
1897                         break;  
1898
1899                 case FR_INTR_DLC: /* Event interrupt occurred */
1900                         mbox->cmd.command = FR_READ_STATUS;
1901                         mbox->cmd.length = 0;
1902                         err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
1903                         if (err)
1904                                 fr_event(card, err, mbox);
1905                         break;
1906
1907                 case FR_INTR_TIMER:  /* Timer interrupt */
1908                         timer_intr(card);
1909                         break;
1910         
1911                 default:
1912                         ++card->statistics.isr_spurious;
1913                         spur_intr(card);
1914                         printk(KERN_INFO "%s: Interrupt Type 0x%02X!\n", 
1915                                 card->devname, flags->iflag);
1916             
1917                         printk(KERN_INFO "%s: ID Bytes = ",card->devname);
1918                         for(i = 0; i < 8; i ++)
1919                                 printk(KERN_INFO "0x%02X ", *(ptr + 0x28 + i));
1920                         printk(KERN_INFO "\n"); 
1921             
1922                         break;
1923         }
1924
1925 fr_isr_exit:
1926         
1927         card->in_isr = 0;
1928         flags->iflag = 0;
1929         return;
1930 }
1931
1932
1933
1934 /*===========================================================
1935  * rx_intr      Receive interrupt handler.
1936  *
1937  * Description
1938  *      Upon receiveing an interrupt: 
1939  *      1. Check that the firmware is in sync with 
1940  *         the driver. 
1941  *      2. Find an appropriate network interface
1942  *         based on the received dlci number.
1943  *      3. Check that the netowrk interface exists
1944  *         and that it's setup properly.
1945  *      4. Copy the data into an skb buffer.
1946  *      5. Check the packet type and take
1947  *         appropriate acton: UPD, API, ARP or Data.
1948  */
1949
1950 static void rx_intr (sdla_t* card)
1951 {
1952         fr_rx_buf_ctl_t* frbuf = card->rxmb;
1953         fr508_flags_t* flags = card->flags;
1954         fr_channel_t* chan;
1955         char *ptr = &flags->iflag;
1956         struct sk_buff* skb;
1957         struct net_device* dev;
1958         void* buf;
1959         unsigned dlci, len, offs, len_incl_hdr;
1960         int i, udp_type;        
1961
1962
1963         /* Check that firmware buffers are in sync */
1964         if (frbuf->flag != 0x01) {
1965
1966                 printk(KERN_INFO 
1967                         "%s: corrupted Rx buffer @ 0x%X, flag = 0x%02X!\n", 
1968                         card->devname, (unsigned)frbuf, frbuf->flag);
1969       
1970                 printk(KERN_INFO "%s: ID Bytes = ",card->devname);
1971                 for(i = 0; i < 8; i ++)
1972                         printk(KERN_INFO "0x%02X ", *(ptr + 0x28 + i));
1973                 printk(KERN_INFO "\n");
1974         
1975                 ++card->statistics.rx_intr_corrupt_rx_bfr;
1976
1977                 /* Bug Fix: Mar 6 2000
1978                  * If we get a corrupted mailbox, it means that driver 
1979                  * is out of sync with the firmware. There is no recovery.
1980                  * If we don't turn off all interrupts for this card
1981                  * the machine will crash. 
1982                  */
1983                 printk(KERN_INFO "%s: Critical router failure ...!!!\n", card->devname);
1984                 printk(KERN_INFO "Please contact Sangoma Technologies !\n");
1985                 fr_set_intr_mode(card, 0, 0, 0);        
1986                 return;
1987         }
1988
1989         len  = frbuf->length;
1990         dlci = frbuf->dlci;
1991         offs = frbuf->offset;
1992
1993         /* Find the network interface for this packet */
1994         dev = find_channel(card, dlci);
1995    
1996
1997         /* Check that the network interface is active and
1998          * properly setup */
1999         if (dev == NULL) {
2000                 if( net_ratelimit()) { 
2001                         printk(KERN_INFO "%s: received data on unconfigured DLCI %d!\n",
2002                                                 card->devname, dlci);
2003                 }
2004                 ++card->statistics.rx_intr_on_orphaned_DLCI; 
2005                 ++card->wandev.stats.rx_dropped;
2006                 goto rx_done;
2007         }
2008
2009         if ((chan = dev->priv) == NULL){
2010                 if( net_ratelimit()) { 
2011                         printk(KERN_INFO "%s: received data on unconfigured DLCI %d!\n",
2012                                                 card->devname, dlci);
2013                 }
2014                 ++card->statistics.rx_intr_on_orphaned_DLCI; 
2015                 ++card->wandev.stats.rx_dropped;
2016                 goto rx_done;
2017         }
2018
2019         skb = dev_alloc_skb(len); 
2020
2021         if (!netif_running(dev) || (skb == NULL)){
2022
2023                 ++chan->ifstats.rx_dropped;
2024         
2025                 if(skb == NULL) {
2026                         if (net_ratelimit()) { 
2027                                 printk(KERN_INFO 
2028                                         "%s: no socket buffers available!\n", 
2029                                                 card->devname);
2030                         }
2031                         chan->drvstats_rx_intr.rx_intr_no_socket ++;
2032                 } 
2033
2034                 if (!netif_running(dev)){
2035                         chan->drvstats_rx_intr.
2036                                 rx_intr_dev_not_started ++;
2037                         if (skb){
2038                                 dev_kfree_skb_any(skb);
2039                         }
2040                 }
2041                 goto rx_done;
2042         }
2043
2044         /* Copy data from the board into the socket buffer */
2045         if ((offs + len) > card->u.f.rx_top + 1) {
2046                 unsigned tmp = card->u.f.rx_top - offs + 1;
2047
2048                 buf = skb_put(skb, tmp);
2049                 sdla_peek(&card->hw, offs, buf, tmp);
2050                 offs = card->u.f.rx_base;
2051                 len -= tmp;
2052         }
2053
2054         buf = skb_put(skb, len);
2055         sdla_peek(&card->hw, offs, buf, len);
2056
2057
2058         /* We got the packet from the bard. 
2059          * Check the packet type and take appropriate action */
2060
2061         udp_type = udp_pkt_type( skb, card );
2062
2063         if(udp_type != UDP_INVALID_TYPE) {
2064
2065                 /* UDP Debug packet received, store the
2066                  * packet and handle it in timer interrupt */
2067
2068                 skb_pull(skb, 1); 
2069                 if (wanrouter_type_trans(skb, dev)){ 
2070                         if(store_udp_mgmt_pkt(udp_type,UDP_PKT_FRM_NETWORK,card,skb,dlci)){
2071
2072                                 flags->imask |= FR_INTR_TIMER;
2073
2074                                 if (udp_type == UDP_FPIPE_TYPE){
2075                                         ++chan->drvstats_rx_intr.rx_intr_PIPE_request;
2076                                 }
2077                         }
2078                 }
2079
2080         }else if (chan->common.usedby == API) {
2081
2082                 /* We are in API mode. 
2083                  * Add an API header to the RAW packet
2084                  * and queue it into a circular buffer.
2085                  * Then kick the fr_bh() bottom half handler */
2086
2087                 api_rx_hdr_t* api_rx_hdr;
2088                 chan->drvstats_rx_intr.rx_intr_bfr_passed_to_stack ++;
2089                 chan->ifstats.rx_packets ++;
2090                 card->wandev.stats.rx_packets ++;
2091
2092                 chan->ifstats.rx_bytes += skb->len;
2093                 card->wandev.stats.rx_bytes += skb->len;
2094
2095                 skb_push(skb, sizeof(api_rx_hdr_t));
2096                 api_rx_hdr = (api_rx_hdr_t*)&skb->data[0x00];
2097                 api_rx_hdr->attr = frbuf->attr;
2098                 api_rx_hdr->time_stamp = frbuf->tmstamp;
2099
2100                 skb->protocol = htons(ETH_P_IP);
2101                 skb->mac.raw  = skb->data;
2102                 skb->dev      = dev;
2103                 skb->pkt_type = WAN_PACKET_DATA;
2104
2105                 bh_enqueue(dev, skb);
2106
2107                 trigger_fr_bh(chan);
2108
2109         }else if (handle_IPXWAN(skb->data,chan->name,chan->enable_IPX, chan->network_number)){
2110
2111                 //FIXME: Frame Relay IPX is not supported, Yet !
2112                 //if (chan->enable_IPX) {
2113                 //      fr_send(card, dlci, 0, skb->len,skb->data);
2114                 //}
2115                 dev_kfree_skb_any(skb);
2116
2117         } else if (is_arp(skb->data)) {
2118
2119                 /* ARP support enabled Mar 16 2000 
2120                  * Process incoming ARP reply/request, setup
2121                  * dynamic routes. */ 
2122
2123                 if (process_ARP((arphdr_1490_t *)skb->data, card, dev)) {
2124                         if (net_ratelimit()){  
2125                                 printk (KERN_INFO 
2126                                    "%s: Error processing ARP Packet.\n", 
2127                                         card->devname);
2128                         }
2129                 }
2130                 dev_kfree_skb_any(skb);
2131
2132         } else if (skb->data[0] != 0x03) {
2133
2134                 if (net_ratelimit()) { 
2135                         printk(KERN_INFO "%s: Non IETF packet discarded.\n", 
2136                                 card->devname);
2137                 }
2138                 dev_kfree_skb_any(skb);
2139
2140         } else {
2141
2142                 len_incl_hdr = skb->len;
2143                 /* Decapsulate packet and pass it up the
2144                    protocol stack */
2145                 skb->dev = dev;
2146                 
2147                 if (chan->common.usedby == BRIDGE || chan->common.usedby == BRIDGE_NODE){
2148                 
2149                         /* Make sure it's an Ethernet frame, otherwise drop it */
2150                         if (!memcmp(skb->data, "\x03\x00\x80\x00\x80\xC2\x00\x07", 8)) {
2151                                 skb_pull(skb, 8);
2152                                 skb->protocol=eth_type_trans(skb,dev);
2153                         }else{
2154                                 ++chan->drvstats_rx_intr.rx_intr_bfr_not_passed_to_stack;
2155                                 ++chan->ifstats.rx_errors;
2156                                 ++card->wandev.stats.rx_errors;
2157                                 goto rx_done;
2158                         }
2159                 }else{
2160                 
2161                         /* remove hardware header */
2162                         buf = skb_pull(skb, 1); 
2163                         
2164                         if (!wanrouter_type_trans(skb, dev)) {
2165                                 
2166                                 /* can't decapsulate packet */
2167                                 dev_kfree_skb_any(skb);
2168
2169                                 ++chan->drvstats_rx_intr.rx_intr_bfr_not_passed_to_stack;
2170                                 ++chan->ifstats.rx_errors;
2171                                 ++card->wandev.stats.rx_errors;
2172                                 goto rx_done;   
2173                         }
2174                         skb->mac.raw = skb->data;
2175                 } 
2176                 
2177
2178                 /* Send a packet up the IP stack */
2179                 skb->dev->last_rx = jiffies;
2180                 netif_rx(skb);
2181                 ++chan->drvstats_rx_intr.rx_intr_bfr_passed_to_stack;
2182                 ++chan->ifstats.rx_packets;
2183                 ++card->wandev.stats.rx_packets;
2184
2185                 chan->ifstats.rx_bytes += len_incl_hdr;
2186                 card->wandev.stats.rx_bytes += len_incl_hdr;
2187         }
2188
2189 rx_done:
2190
2191         /* Release buffer element and calculate a pointer to the next one */ 
2192         frbuf->flag = 0;
2193         card->rxmb = ++frbuf;
2194         if ((void*)frbuf > card->u.f.rxmb_last)
2195                 card->rxmb = card->u.f.rxmb_base;
2196
2197 }
2198
2199 /*==================================================================
2200  * tx_intr:     Transmit interrupt handler.
2201  *
2202  * Rationale:
2203  *      If the board is busy transmitting, if_send() will
2204  *      buffers a single packet and turn on
2205  *      the tx interrupt. Tx interrupt will be called
2206  *      by the board, once the firmware can send more
2207  *      data. Thus, no polling is required.      
2208  *
2209  * Description:
2210  *      Tx interrupt is called for each 
2211  *      configured dlci channel. Thus: 
2212  *      1. Obtain the netowrk interface based on the
2213  *         dlci number.
2214  *      2. Check that network interface is up and
2215  *         properly setup.
2216  *      3. Check for a buffered packet.
2217  *      4. Transmit the packet.
2218  *      5. If we are in WANPIPE mode, mark the 
2219  *         NET_BH handler. 
2220  *      6. If we are in API mode, kick
2221  *         the AF_WANPIPE socket for more data. 
2222  *         
2223  */
2224 static void tx_intr(sdla_t *card)
2225 {
2226         fr508_flags_t* flags = card->flags;
2227         fr_tx_buf_ctl_t* bctl;
2228         struct net_device* dev;
2229         fr_channel_t* chan;
2230
2231         if(card->hw.type == SDLA_S514){
2232                 bctl = (void*)(flags->tse_offs + card->hw.dpmbase);
2233         }else{
2234                 bctl = (void*)(flags->tse_offs - FR_MB_VECTOR +
2235                         card->hw.dpmbase);
2236         }
2237
2238         /* Find the structure and make it unbusy */
2239         dev = find_channel(card, flags->dlci);
2240         if (dev == NULL){
2241                 printk(KERN_INFO "NO DEV IN TX Interrupt\n");   
2242                 goto end_of_tx_intr;
2243         }
2244
2245         if ((chan = dev->priv) == NULL){
2246                 printk(KERN_INFO "NO CHAN IN TX Interrupt\n");  
2247                 goto end_of_tx_intr;
2248         }
2249
2250         if(!chan->transmit_length || !chan->delay_skb) {
2251                 printk(KERN_INFO "%s: tx int error - transmit length zero\n",
2252                                 card->wandev.name);
2253                 goto end_of_tx_intr;
2254         }
2255
2256         /* If the 'if_send()' procedure is currently checking the 'tbusy'
2257            status, then we cannot transmit. Instead, we configure the microcode
2258            so as to re-issue this transmit interrupt at a later stage. 
2259         */
2260         if (test_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical)) {
2261
2262                 fr_dlci_interface_t* dlci_interface = chan->dlci_int_interface;
2263                 bctl->flag = 0xA0;
2264                 dlci_interface->gen_interrupt |= FR_INTR_TXRDY;
2265                 return;
2266
2267         }else{
2268                 bctl->dlci = flags->dlci;
2269                 bctl->length = chan->transmit_length+chan->fr_header_len;
2270                 sdla_poke(&card->hw, 
2271                           fr_send_hdr(card,bctl->dlci,bctl->offset), 
2272                           chan->delay_skb->data,
2273                           chan->delay_skb->len);
2274                 bctl->flag = 0xC0;
2275
2276                 ++chan->ifstats.tx_packets;
2277                 ++card->wandev.stats.tx_packets;
2278                 chan->ifstats.tx_bytes += chan->transmit_length;
2279                 card->wandev.stats.tx_bytes += chan->transmit_length;
2280
2281                 /* We must free an sk buffer, which we used
2282                  * for delayed transmission; Otherwise, the sock
2283                  * will run out of memory */
2284                 dev_kfree_skb_any(chan->delay_skb);
2285
2286                 chan->delay_skb = NULL;                         
2287                 chan->transmit_length = 0;
2288
2289                 dev->trans_start = jiffies;
2290
2291                 if (netif_queue_stopped(dev)){
2292                         /* If using API, than wakeup socket BH handler */
2293                         if (chan->common.usedby == API){
2294                                 netif_start_queue(dev);
2295                                 wakeup_sk_bh(dev);
2296                         }else{
2297                                 netif_wake_queue(dev);
2298                         }
2299                 }
2300         }
2301
2302 end_of_tx_intr:
2303
2304         /* if any other interfaces have transmit interrupts pending, 
2305          * do not disable the global transmit interrupt */
2306         if(!(-- card->u.f.tx_interrupts_pending))
2307                 flags->imask &= ~FR_INTR_TXRDY;
2308
2309
2310 }
2311
2312
2313 /*============================================================================
2314  * timer_intr:  Timer interrupt handler.
2315  *
2316  * Rationale:
2317  *      All commans must be executed within the timer
2318  *      interrupt since no two commands should execute
2319  *      at the same time.
2320  *
2321  * Description:
2322  *      The timer interrupt is used to:
2323  *      1. Processing udp calls from 'fpipemon'.
2324  *      2. Processing update calls from /proc file system
2325  *      3. Reading board-level statistics for 
2326  *         updating the proc file system.
2327  *      4. Sending inverse ARP request packets.
2328  *      5. Configure a dlci/channel.
2329  *      6. Unconfigure a dlci/channel. (Node only)
2330  */
2331
2332 static void timer_intr(sdla_t *card)
2333 {
2334         fr508_flags_t* flags = card->flags;
2335
2336         /* UDP Debuging: fpipemon call */
2337         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UDP) {
2338                 if(card->u.f.udp_type == UDP_FPIPE_TYPE) {
2339                         if(process_udp_mgmt_pkt(card)) {
2340                                 card->u.f.timer_int_enabled &=
2341                                         ~TMR_INT_ENABLED_UDP;
2342                         }
2343                 }
2344         }
2345
2346         /* /proc update call : triggered from update() */
2347         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UPDATE) {
2348                 fr_get_err_stats(card);
2349                 fr_get_stats(card);
2350                 card->u.f.update_comms_stats = 0;
2351                 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE;
2352         }
2353
2354         /* Update the channel state call.  This is call is
2355          * triggered by if_send() function */
2356         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UPDATE_STATE){
2357                 struct net_device *dev;
2358                 if (card->wandev.state == WAN_CONNECTED){
2359                         for (dev = card->wandev.dev; dev;
2360                              dev = *((struct net_device **)dev->priv)){
2361                                 fr_channel_t *chan = dev->priv; 
2362                                 if (chan->common.state != WAN_CONNECTED){
2363                                         update_chan_state(dev);
2364                                 }
2365                         }
2366                 }
2367                 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE_STATE;
2368         }
2369
2370         /* configure a dlci/channel */
2371         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_CONFIG){
2372                 config_fr(card);
2373                 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_CONFIG;
2374         }
2375
2376         /* unconfigure a dlci/channel */
2377         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UNCONFIG){
2378                 unconfig_fr(card);
2379                 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UNCONFIG;
2380         }
2381
2382         
2383         /* Transmit ARP packets */
2384         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_ARP){
2385                 int i=0;
2386                 struct net_device *dev;
2387
2388                 if (card->u.f.arp_dev == NULL)
2389                         card->u.f.arp_dev = card->wandev.dev;
2390
2391                 dev = card->u.f.arp_dev;
2392
2393                 for (;;){ 
2394
2395                         fr_channel_t *chan = dev->priv;
2396
2397                         /* If the interface is brought down cancel sending In-ARPs */
2398                         if (!(dev->flags&IFF_UP)){
2399                                 clear_bit(0,&chan->inarp_ready);        
2400                         }
2401
2402                         if (test_bit(0,&chan->inarp_ready)){
2403
2404                                 if (check_tx_status(card,dev)){
2405                                         set_bit(ARP_CRIT,&card->wandev.critical);
2406                                         break;
2407                                 }
2408
2409                                 if (!send_inarp_request(card,dev)){
2410                                         trigger_fr_arp(dev);
2411                                         chan->inarp_tick = jiffies;
2412                                 }
2413
2414                                 clear_bit(0,&chan->inarp_ready);
2415                                 dev = move_dev_to_next(card,dev);
2416                                 break;
2417                         }
2418                         dev = move_dev_to_next(card,dev);
2419
2420                         if (++i == card->wandev.new_if_cnt){
2421                                 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_ARP;
2422                                 break;
2423                         }
2424                 }
2425                 card->u.f.arp_dev = dev;
2426         }
2427
2428         if(!card->u.f.timer_int_enabled)
2429                 flags->imask &= ~FR_INTR_TIMER;
2430 }
2431
2432
2433 /*============================================================================
2434  * spur_intr:   Spurious interrupt handler.
2435  * 
2436  * Description:
2437  *      We don't know this interrupt.
2438  *      Print a warning.
2439  */
2440
2441 static void spur_intr (sdla_t* card)
2442 {
2443         if (net_ratelimit()){ 
2444                 printk(KERN_INFO "%s: spurious interrupt!\n", card->devname);
2445         }
2446 }
2447
2448
2449 //FIXME: Fix the IPX in next version
2450 /*===========================================================================
2451  *  Return 0 for non-IPXWAN packet
2452  *         1 for IPXWAN packet or IPX is not enabled!
2453  *  FIXME: Use a IPX structure here not offsets
2454  */
2455 static int handle_IPXWAN(unsigned char *sendpacket, 
2456                          char *devname, unsigned char enable_IPX, 
2457                          unsigned long network_number)
2458 {
2459         int i;
2460
2461         if( sendpacket[1] == 0x00 && sendpacket[2] == 0x80 &&
2462             sendpacket[6] == 0x81 && sendpacket[7] == 0x37) { 
2463
2464                 /* It's an IPX packet */
2465                 if (!enable_IPX){
2466                         /* Return 1 so we don't pass it up the stack. */
2467                         //FIXME: Take this out when IPX is fixed
2468                         if (net_ratelimit()){ 
2469                                 printk (KERN_INFO 
2470                                 "%s: WARNING: Unsupported IPX packet received and dropped\n",
2471                                         devname);
2472                         }
2473                         return 1;
2474                 }
2475         } else {
2476                 /* It's not IPX so return and pass it up the stack. */
2477                 return 0;
2478         }
2479
2480         if( sendpacket[24] == 0x90 && sendpacket[25] == 0x04){
2481                 /* It's IPXWAN */
2482
2483                 if( sendpacket[10] == 0x02 && sendpacket[42] == 0x00){
2484
2485                         /* It's a timer request packet */
2486                         printk(KERN_INFO "%s: Received IPXWAN Timer Request packet\n",
2487                                         devname);
2488
2489                         /* Go through the routing options and answer no to every
2490                          * option except Unnumbered RIP/SAP
2491                          */
2492                         for(i = 49; sendpacket[i] == 0x00; i += 5){
2493                                 /* 0x02 is the option for Unnumbered RIP/SAP */
2494                                 if( sendpacket[i + 4] != 0x02){
2495                                         sendpacket[i + 1] = 0;
2496                                 }
2497                         }
2498
2499                         /* Skip over the extended Node ID option */
2500                         if( sendpacket[i] == 0x04 ){
2501                                 i += 8;
2502                         }
2503
2504                         /* We also want to turn off all header compression opt.
2505                          */
2506                         for(; sendpacket[i] == 0x80 ;){
2507                                 sendpacket[i + 1] = 0;
2508                                 i += (sendpacket[i + 2] << 8) + (sendpacket[i + 3]) + 4;
2509                         }
2510
2511                         /* Set the packet type to timer response */
2512                         sendpacket[42] = 0x01;
2513
2514                         printk(KERN_INFO "%s: Sending IPXWAN Timer Response\n",
2515                                         devname);
2516
2517                 } else if( sendpacket[42] == 0x02 ){
2518
2519                         /* This is an information request packet */
2520                         printk(KERN_INFO 
2521                                 "%s: Received IPXWAN Information Request packet\n",
2522                                                 devname);
2523
2524                         /* Set the packet type to information response */
2525                         sendpacket[42] = 0x03;
2526
2527                         /* Set the router name */
2528                         sendpacket[59] = 'F';
2529                         sendpacket[60] = 'P';
2530                         sendpacket[61] = 'I';
2531                         sendpacket[62] = 'P';
2532                         sendpacket[63] = 'E';
2533                         sendpacket[64] = '-';
2534                         sendpacket[65] = CVHexToAscii(network_number >> 28);
2535                         sendpacket[66] = CVHexToAscii((network_number & 0x0F000000)>> 24);
2536                         sendpacket[67] = CVHexToAscii((network_number & 0x00F00000)>> 20);
2537                         sendpacket[68] = CVHexToAscii((network_number & 0x000F0000)>> 16);
2538                         sendpacket[69] = CVHexToAscii((network_number & 0x0000F000)>> 12);
2539                         sendpacket[70] = CVHexToAscii((network_number & 0x00000F00)>> 8);
2540                         sendpacket[71] = CVHexToAscii((network_number & 0x000000F0)>> 4);
2541                         sendpacket[72] = CVHexToAscii(network_number & 0x0000000F);
2542                         for(i = 73; i < 107; i+= 1)
2543                         {
2544                                 sendpacket[i] = 0;
2545                         }
2546
2547                         printk(KERN_INFO "%s: Sending IPXWAN Information Response packet\n",
2548                                         devname);
2549                 } else {
2550
2551                         printk(KERN_INFO "%s: Unknown IPXWAN packet!\n",devname);
2552                         return 0;
2553                 }
2554
2555                 /* Set the WNodeID to our network address */
2556                 sendpacket[43] = (unsigned char)(network_number >> 24);
2557                 sendpacket[44] = (unsigned char)((network_number & 0x00FF0000) >> 16);
2558                 sendpacket[45] = (unsigned char)((network_number & 0x0000FF00) >> 8);
2559                 sendpacket[46] = (unsigned char)(network_number & 0x000000FF);
2560
2561                 return 1;
2562         }
2563
2564         /* If we get here, it's an IPX-data packet so it'll get passed up the 
2565          * stack.
2566          * switch the network numbers 
2567          */
2568         switch_net_numbers(sendpacket, network_number ,1);
2569         return 0;
2570 }
2571 /*============================================================================
2572  * process_route
2573  * 
2574  * Rationale:
2575  *      If the interface goes down, or we receive an ARP request,
2576  *      we have to change the network interface ip addresses.
2577  *      This cannot be done within the interrupt.
2578  *
2579  * Description:
2580  *
2581  *      This routine is called as a polling routine to dynamically 
2582  *      add/delete routes negotiated by inverse ARP.  It is in this 
2583  *      "task" because we don't want routes to be added while in 
2584  *      interrupt context.
2585  *
2586  * Usage:
2587  *      This function is called by fr_poll() polling funtion.
2588  */
2589
2590 static void process_route(struct net_device *dev)
2591 {
2592         fr_channel_t *chan = dev->priv;
2593         sdla_t *card = chan->card;
2594
2595         struct ifreq if_info;
2596         struct sockaddr_in *if_data;
2597         mm_segment_t fs = get_fs();
2598         u32 ip_tmp;
2599         int err;
2600
2601
2602         switch(chan->route_flag){
2603
2604         case ADD_ROUTE:
2605                                 
2606                 /* Set remote addresses */
2607                 memset(&if_info, 0, sizeof(if_info));
2608                 strcpy(if_info.ifr_name, dev->name);
2609
2610                 set_fs(get_ds());     /* get user space block */ 
2611                 
2612                 if_data = (struct sockaddr_in *)&if_info.ifr_dstaddr;
2613                 if_data->sin_addr.s_addr = chan->ip_remote;
2614                 if_data->sin_family = AF_INET;
2615                 err = devinet_ioctl( SIOCSIFDSTADDR, &if_info );
2616
2617                 set_fs(fs);           /* restore old block */
2618
2619                 if (err) {
2620                         printk(KERN_INFO 
2621                                 "%s: Route Add failed.  Error: %d\n", 
2622                                         card->devname,err);
2623                         printk(KERN_INFO "%s: Address: %u.%u.%u.%u\n",
2624                                 chan->name, NIPQUAD(chan->ip_remote));
2625
2626                 }else {
2627                         printk(KERN_INFO "%s: Route Added Successfully: %u.%u.%u.%u\n",
2628                                 card->devname,NIPQUAD(chan->ip_remote));
2629                         chan->route_flag = ROUTE_ADDED;
2630                 }
2631                 break;
2632
2633         case REMOVE_ROUTE:
2634
2635                 /* Set remote addresses */
2636                 memset(&if_info, 0, sizeof(if_info));
2637                 strcpy(if_info.ifr_name, dev->name);
2638
2639                 ip_tmp = get_ip_address(dev,WAN_POINTOPOINT_IP);        
2640
2641                 set_fs(get_ds());     /* get user space block */ 
2642                 
2643                 if_data = (struct sockaddr_in *)&if_info.ifr_dstaddr;
2644                 if_data->sin_addr.s_addr = 0;
2645                 if_data->sin_family = AF_INET;
2646                 err = devinet_ioctl( SIOCSIFDSTADDR, &if_info );
2647
2648                 set_fs(fs);    
2649                 
2650                 if (err) {
2651                         printk(KERN_INFO 
2652                                 "%s: Deleting of route failed.  Error: %d\n", 
2653                                         card->devname,err);
2654                         printk(KERN_INFO "%s: Address: %u.%u.%u.%u\n",
2655                                 dev->name,NIPQUAD(chan->ip_remote) );
2656
2657                 } else {
2658                         printk(KERN_INFO "%s: Route Removed Sucessfuly: %u.%u.%u.%u\n", 
2659                                 card->devname,NIPQUAD(ip_tmp));
2660                         chan->route_flag = NO_ROUTE;
2661                 }
2662                 break;
2663
2664         } /* Case Statement */
2665
2666 }
2667
2668
2669
2670 /****** Frame Relay Firmware-Specific Functions *****************************/
2671
2672 /*============================================================================
2673  * Read firmware code version.
2674  * o fill string str with firmware version info. 
2675  */
2676 static int fr_read_version (sdla_t* card, char* str)
2677 {
2678         fr_mbox_t* mbox = card->mbox;
2679         int retry = MAX_CMD_RETRY;
2680         int err;
2681
2682         do
2683         {
2684                 mbox->cmd.command = FR_READ_CODE_VERSION;
2685                 mbox->cmd.length = 0;
2686                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2687         } while (err && retry-- && fr_event(card, err, mbox));
2688         
2689         if (!err && str) {
2690                 int len = mbox->cmd.length;
2691                 memcpy(str, mbox->data, len);
2692                 str[len] = '\0';
2693         }
2694         return err;
2695 }
2696
2697 /*============================================================================
2698  * Set global configuration.
2699  */
2700 static int fr_configure (sdla_t* card, fr_conf_t *conf)
2701 {
2702         fr_mbox_t* mbox = card->mbox;
2703         int retry = MAX_CMD_RETRY;
2704         int dlci_num = card->u.f.dlci_num;
2705         int err, i;
2706
2707         do
2708         {
2709                 memcpy(mbox->data, conf, sizeof(fr_conf_t));
2710
2711                 if (dlci_num) for (i = 0; i < dlci_num; ++i)
2712                         ((fr_conf_t*)mbox->data)->dlci[i] = 
2713                                         card->u.f.node_dlci[i]; 
2714                 
2715                 mbox->cmd.command = FR_SET_CONFIG;
2716                 mbox->cmd.length =
2717                         sizeof(fr_conf_t) + dlci_num * sizeof(short);
2718
2719                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2720         
2721         } while (err && retry-- && fr_event(card, err, mbox));
2722
2723         /*NC Oct 12 2000 */
2724         if (err != CMD_OK){
2725                 printk(KERN_ERR "%s: Frame Relay Configuration Failed: rc=0x%x\n",
2726                                 card->devname,err);
2727         }
2728         
2729         return err;
2730 }
2731
2732 /*============================================================================
2733  * Set DLCI configuration.
2734  */
2735 static int fr_dlci_configure (sdla_t* card, fr_dlc_conf_t *conf, unsigned dlci)
2736 {
2737         fr_mbox_t* mbox = card->mbox;
2738         int retry = MAX_CMD_RETRY;
2739         int err;
2740
2741         do
2742         {
2743                 memcpy(mbox->data, conf, sizeof(fr_dlc_conf_t));
2744                 mbox->cmd.dlci = (unsigned short) dlci; 
2745                 mbox->cmd.command = FR_SET_CONFIG;
2746                 mbox->cmd.length = sizeof(fr_dlc_conf_t);
2747                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2748         } while (err && retry--);
2749         
2750         return err;
2751 }
2752 /*============================================================================
2753  * Set interrupt mode.
2754  */
2755 static int fr_set_intr_mode (sdla_t* card, unsigned mode, unsigned mtu,
2756         unsigned short timeout)
2757 {
2758         fr_mbox_t* mbox = card->mbox;
2759         fr508_intr_ctl_t* ictl = (void*)mbox->data;
2760         int retry = MAX_CMD_RETRY;
2761         int err;
2762
2763         do
2764         {
2765                 memset(ictl, 0, sizeof(fr508_intr_ctl_t));
2766                 ictl->mode   = mode;
2767                 ictl->tx_len = mtu;
2768                 ictl->irq    = card->hw.irq;
2769
2770                 /* indicate timeout on timer */
2771                 if (mode & 0x20) ictl->timeout = timeout; 
2772
2773                 mbox->cmd.length = sizeof(fr508_intr_ctl_t);
2774                 mbox->cmd.command = FR_SET_INTR_MODE;
2775                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2776
2777         } while (err && retry-- && fr_event(card, err, mbox));
2778         
2779         return err;
2780 }
2781
2782 /*============================================================================
2783  * Enable communications.
2784  */
2785 static int fr_comm_enable (sdla_t* card)
2786 {
2787         fr_mbox_t* mbox = card->mbox;
2788         int retry = MAX_CMD_RETRY;
2789         int err;
2790
2791         do
2792         {
2793                 mbox->cmd.command = FR_COMM_ENABLE;
2794                 mbox->cmd.length = 0;
2795                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2796         } while (err && retry-- && fr_event(card, err, mbox));
2797         
2798         return err;
2799 }
2800
2801 /*============================================================================
2802  * fr_comm_disable 
2803  *
2804  * Warning: This functin is called by the shutdown() procedure. It is void
2805  *          since dev->priv are has already been deallocated and no
2806  *          error checking is possible using fr_event() function.
2807  */
2808 static void fr_comm_disable (sdla_t* card)
2809 {
2810         fr_mbox_t* mbox = card->mbox;
2811         int retry = MAX_CMD_RETRY;
2812         int err;
2813
2814         do {
2815         mbox->cmd.command = FR_SET_MODEM_STATUS;
2816         mbox->cmd.length = 1;
2817         mbox->data[0] = 0;
2818         err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2819         } while (err && retry--);
2820         
2821         retry = MAX_CMD_RETRY;
2822         
2823         do
2824         {
2825                 mbox->cmd.command = FR_COMM_DISABLE;
2826                 mbox->cmd.length = 0;
2827                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2828         } while (err && retry--);
2829
2830         return;
2831 }
2832
2833
2834
2835 /*============================================================================
2836  * Get communications error statistics. 
2837  */
2838 static int fr_get_err_stats (sdla_t* card)
2839 {
2840         fr_mbox_t* mbox = card->mbox;
2841         int retry = MAX_CMD_RETRY;
2842         int err;
2843
2844
2845         do
2846         {
2847                 mbox->cmd.command = FR_READ_ERROR_STATS;
2848                 mbox->cmd.length = 0;
2849                 mbox->cmd.dlci = 0;
2850                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2851         } while (err && retry-- && fr_event(card, err, mbox));
2852
2853         if (!err) {
2854                 fr_comm_stat_t* stats = (void*)mbox->data;
2855                 card->wandev.stats.rx_over_errors    = stats->rx_overruns;
2856                 card->wandev.stats.rx_crc_errors     = stats->rx_bad_crc;
2857                 card->wandev.stats.rx_missed_errors  = stats->rx_aborts;
2858                 card->wandev.stats.rx_length_errors  = stats->rx_too_long;
2859                 card->wandev.stats.tx_aborted_errors = stats->tx_aborts;
2860         
2861         }
2862
2863         return err;
2864 }
2865
2866 /*============================================================================
2867  * Get statistics. 
2868  */
2869 static int fr_get_stats (sdla_t* card)
2870 {
2871         fr_mbox_t* mbox = card->mbox;
2872         int retry = MAX_CMD_RETRY;
2873         int err;
2874
2875
2876         do
2877         {
2878                 mbox->cmd.command = FR_READ_STATISTICS;
2879                 mbox->cmd.length = 0;
2880                 mbox->cmd.dlci = 0;
2881                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2882         } while (err && retry-- && fr_event(card, err, mbox));
2883
2884         if (!err) {
2885                 fr_link_stat_t* stats = (void*)mbox->data;
2886                 card->wandev.stats.rx_frame_errors = stats->rx_bad_format;
2887                 card->wandev.stats.rx_dropped =
2888                         stats->rx_dropped + stats->rx_dropped2;
2889         }
2890
2891         return err;
2892 }
2893
2894 /*============================================================================
2895  * Add DLCI(s) (Access Node only!).
2896  * This routine will perform the ADD_DLCIs command for the specified DLCI.
2897  */
2898 static int fr_add_dlci (sdla_t* card, int dlci)
2899 {
2900         fr_mbox_t* mbox = card->mbox;
2901         int retry = MAX_CMD_RETRY;
2902         int err;
2903
2904         do
2905         {
2906                 unsigned short* dlci_list = (void*)mbox->data;
2907
2908                 mbox->cmd.length  = sizeof(short);
2909                 dlci_list[0] = dlci;
2910                 mbox->cmd.command = FR_ADD_DLCI;
2911                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2912
2913         } while (err && retry-- && fr_event(card, err, mbox));
2914         
2915         return err;
2916 }
2917
2918 /*============================================================================
2919  * Activate DLCI(s) (Access Node only!). 
2920  * This routine will perform the ACTIVATE_DLCIs command with a DLCI number. 
2921  */
2922 static int fr_activate_dlci (sdla_t* card, int dlci)
2923 {
2924         fr_mbox_t* mbox = card->mbox;
2925         int retry = MAX_CMD_RETRY;
2926         int err;
2927
2928         do
2929         {
2930                 unsigned short* dlci_list = (void*)mbox->data;
2931
2932                 mbox->cmd.length  = sizeof(short);
2933                 dlci_list[0] = dlci;
2934                 mbox->cmd.command = FR_ACTIVATE_DLCI;
2935                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2936
2937         } while (err && retry-- && fr_event(card, err, mbox));
2938         
2939         return err;
2940 }
2941
2942 /*============================================================================
2943  * Delete DLCI(s) (Access Node only!). 
2944  * This routine will perform the DELETE_DLCIs command with a DLCI number. 
2945  */
2946 static int fr_delete_dlci (sdla_t* card, int dlci)
2947 {
2948         fr_mbox_t* mbox = card->mbox;
2949         int retry = MAX_CMD_RETRY;
2950         int err;
2951
2952         do
2953         {
2954                 unsigned short* dlci_list = (void*)mbox->data;
2955
2956                 mbox->cmd.length  = sizeof(short);
2957                 dlci_list[0] = dlci;
2958                 mbox->cmd.command = FR_DELETE_DLCI;
2959                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2960
2961         } while (err && retry-- && fr_event(card, err, mbox));
2962         
2963         return err;
2964 }
2965
2966
2967
2968 /*============================================================================
2969  * Issue in-channel signalling frame. 
2970  */
2971 static int fr_issue_isf (sdla_t* card, int isf)
2972 {
2973         fr_mbox_t* mbox = card->mbox;
2974         int retry = MAX_CMD_RETRY;
2975         int err;
2976
2977         do
2978         {
2979                 mbox->data[0] = isf;
2980                 mbox->cmd.length  = 1;
2981                 mbox->cmd.command = FR_ISSUE_IS_FRAME;
2982                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2983         } while (err && retry-- && fr_event(card, err, mbox));
2984         
2985         return err;
2986 }
2987
2988
2989 static unsigned int fr_send_hdr (sdla_t*card, int dlci, unsigned int offset)
2990 {
2991         struct net_device *dev = find_channel(card,dlci);       
2992         fr_channel_t *chan;
2993
2994         if (!dev || !(chan=dev->priv))
2995                 return offset;
2996         
2997         if (chan->fr_header_len){
2998                 sdla_poke(&card->hw, offset, chan->fr_header, chan->fr_header_len);
2999         }
3000         
3001         return offset+chan->fr_header_len;
3002 }
3003
3004 /*============================================================================
3005  * Send a frame on a selected DLCI.  
3006  */
3007 static int fr_send_data_header (sdla_t* card, int dlci, unsigned char attr, int len,
3008         void *buf, unsigned char hdr_len)
3009 {
3010         fr_mbox_t* mbox = card->mbox + 0x800;
3011         int retry = MAX_CMD_RETRY;
3012         int err;
3013
3014         do
3015         {
3016                 mbox->cmd.dlci    = dlci;
3017                 mbox->cmd.attr    = attr;
3018                 mbox->cmd.length  = len+hdr_len;
3019                 mbox->cmd.command = FR_WRITE;
3020                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3021         } while (err && retry-- && fr_event(card, err, mbox));
3022
3023         if (!err) {
3024                 fr_tx_buf_ctl_t* frbuf;
3025  
3026                 if(card->hw.type == SDLA_S514)
3027                         frbuf = (void*)(*(unsigned long*)mbox->data +
3028                                 card->hw.dpmbase);
3029                 else
3030                         frbuf = (void*)(*(unsigned long*)mbox->data -
3031                                 FR_MB_VECTOR + card->hw.dpmbase);
3032
3033                 sdla_poke(&card->hw, fr_send_hdr(card,dlci,frbuf->offset), buf, len);
3034                 frbuf->flag = 0x01;
3035         }
3036
3037         return err;
3038 }
3039
3040 static int fr_send (sdla_t* card, int dlci, unsigned char attr, int len,
3041         void *buf)
3042 {
3043         fr_mbox_t* mbox = card->mbox + 0x800;
3044         int retry = MAX_CMD_RETRY;
3045         int err;
3046
3047         do
3048         {
3049                 mbox->cmd.dlci    = dlci;
3050                 mbox->cmd.attr    = attr;
3051                 mbox->cmd.length  = len;
3052                 mbox->cmd.command = FR_WRITE;
3053                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3054         } while (err && retry-- && fr_event(card, err, mbox));
3055
3056         if (!err) {
3057                 fr_tx_buf_ctl_t* frbuf;
3058  
3059                 if(card->hw.type == SDLA_S514)
3060                         frbuf = (void*)(*(unsigned long*)mbox->data +
3061                                 card->hw.dpmbase);
3062                 else
3063                         frbuf = (void*)(*(unsigned long*)mbox->data -
3064                                 FR_MB_VECTOR + card->hw.dpmbase);
3065
3066                 sdla_poke(&card->hw, frbuf->offset, buf, len);
3067                 frbuf->flag = 0x01;
3068         }
3069
3070         return err;
3071 }
3072
3073
3074 /****** Firmware Asynchronous Event Handlers ********************************/
3075
3076 /*============================================================================
3077  * Main asyncronous event/error handler.
3078  *      This routine is called whenever firmware command returns non-zero
3079  *      return code.
3080  *
3081  * Return zero if previous command has to be cancelled.
3082  */
3083 static int fr_event (sdla_t *card, int event, fr_mbox_t* mbox)
3084 {
3085         fr508_flags_t* flags = card->flags;
3086         char *ptr = &flags->iflag;
3087         int i;
3088
3089         switch (event) {
3090
3091                 case FRRES_MODEM_FAILURE:
3092                         return fr_modem_failure(card, mbox);
3093
3094                 case FRRES_CHANNEL_DOWN: {
3095                         struct net_device *dev;
3096
3097                         /* Remove all routes from associated DLCI's */
3098                         for (dev = card->wandev.dev; dev;
3099                              dev = *((struct net_device **)dev->priv)) {
3100                                 fr_channel_t *chan = dev->priv;
3101                                 if (chan->route_flag == ROUTE_ADDED) {
3102                                         chan->route_flag = REMOVE_ROUTE;
3103                                 }
3104
3105                                 if (chan->inarp == INARP_CONFIGURED) {
3106                                         chan->inarp = INARP_REQUEST;
3107                                 }
3108
3109                                 /* If the link becomes disconnected then,
3110                                  * all channels will be disconnected
3111                                  * as well.
3112                                  */
3113                                 set_chan_state(dev,WAN_DISCONNECTED);
3114                         }
3115                                 
3116                         wanpipe_set_state(card, WAN_DISCONNECTED);
3117                         return 1;
3118                         }
3119
3120                 case FRRES_CHANNEL_UP: {
3121                         struct net_device *dev;
3122
3123                         /* FIXME: Only startup devices that are on the list */
3124                         
3125                         for (dev = card->wandev.dev; dev;
3126                              dev = *((struct net_device **)dev->priv)) {
3127                                 
3128                                 set_chan_state(dev,WAN_CONNECTED);
3129                         }
3130
3131                         wanpipe_set_state(card, WAN_CONNECTED);
3132                         return 1;
3133                         }
3134
3135                 case FRRES_DLCI_CHANGE:
3136                         return fr_dlci_change(card, mbox);
3137
3138                 case FRRES_DLCI_MISMATCH:
3139                         printk(KERN_INFO "%s: DLCI list mismatch!\n", 
3140                                 card->devname);
3141                         return 1;
3142
3143                 case CMD_TIMEOUT:
3144                         printk(KERN_ERR "%s: command 0x%02X timed out!\n",
3145                                 card->devname, mbox->cmd.command);
3146                         printk(KERN_INFO "%s: ID Bytes = ",card->devname);
3147                         for(i = 0; i < 8; i ++)
3148                                 printk(KERN_INFO "0x%02X ", *(ptr + 0x18 + i));
3149                         printk(KERN_INFO "\n"); 
3150             
3151                         break;
3152
3153                 case FRRES_DLCI_INACTIVE:
3154                         break;
3155  
3156                 case FRRES_CIR_OVERFLOW:
3157                         break;
3158                         
3159                 case FRRES_BUFFER_OVERFLOW:
3160                         break; 
3161                         
3162                 default:
3163                         printk(KERN_INFO "%s: command 0x%02X returned 0x%02X!\n"
3164                                 , card->devname, mbox->cmd.command, event);
3165         }
3166
3167         return 0;
3168 }
3169
3170 /*============================================================================
3171  * Handle modem error.
3172  *
3173  * Return zero if previous command has to be cancelled.
3174  */
3175 static int fr_modem_failure (sdla_t *card, fr_mbox_t* mbox)
3176 {
3177         printk(KERN_INFO "%s: physical link down! (modem error 0x%02X)\n",
3178                 card->devname, mbox->data[0]);
3179
3180         switch (mbox->cmd.command){
3181                 case FR_WRITE:
3182         
3183                 case FR_READ:
3184                         return 0;
3185         }
3186         
3187         return 1;
3188 }
3189
3190 /*============================================================================
3191  * Handle DLCI status change.
3192  *
3193  * Return zero if previous command has to be cancelled.
3194  */
3195 static int fr_dlci_change (sdla_t *card, fr_mbox_t* mbox)
3196 {
3197         dlci_status_t* status = (void*)mbox->data;
3198         int cnt = mbox->cmd.length / sizeof(dlci_status_t);
3199         fr_channel_t *chan;
3200         struct net_device* dev2;
3201         
3202
3203         for (; cnt; --cnt, ++status) {
3204
3205                 unsigned short dlci= status->dlci;
3206                 struct net_device* dev = find_channel(card, dlci);
3207                 
3208                 if (dev == NULL){
3209                         printk(KERN_INFO 
3210                                 "%s: CPE contains unconfigured DLCI= %d\n", 
3211                                 card->devname, dlci);   
3212
3213                       printk(KERN_INFO
3214                                 "%s: unconfigured DLCI %d reported by network\n"
3215                                 , card->devname, dlci);
3216  
3217                 }else{
3218                         if (status->state == FR_LINK_INOPER) {
3219                                 printk(KERN_INFO
3220                                         "%s: DLCI %u is inactive!\n",
3221                                         card->devname, dlci);
3222
3223                                 if (dev && netif_running(dev))
3224                                         set_chan_state(dev, WAN_DISCONNECTED);
3225                         }
3226         
3227                         if (status->state & FR_DLCI_DELETED) {
3228
3229                                 printk(KERN_INFO
3230                                         "%s: DLCI %u has been deleted!\n",
3231                                         card->devname, dlci);
3232
3233                                 if (dev && netif_running(dev)){
3234
3235                                         fr_channel_t *chan = dev->priv;
3236
3237                                         if (chan->route_flag == ROUTE_ADDED) {
3238                                                 chan->route_flag = REMOVE_ROUTE;
3239                                                 /* The state change will trigger
3240                                                  * the fr polling routine */
3241                                         }
3242
3243                                         if (chan->inarp == INARP_CONFIGURED) {
3244                                                 chan->inarp = INARP_REQUEST;
3245                                         }
3246
3247                                         set_chan_state(dev, WAN_DISCONNECTED);
3248                                 }
3249
3250                         } else if (status->state & FR_DLCI_ACTIVE) {
3251
3252                                 chan = dev->priv;
3253                         
3254                                 /* This flag is used for configuring specific 
3255                                    DLCI(s) when they become active.
3256                                 */ 
3257                                 chan->dlci_configured = DLCI_CONFIG_PENDING;
3258         
3259                                 set_chan_state(dev, WAN_CONNECTED);
3260                 
3261                         }
3262                 }
3263         }
3264         
3265         for (dev2 = card->wandev.dev; dev2;
3266              dev2 = *((struct net_device **)dev2->priv)){
3267                 
3268                 chan = dev2->priv;
3269         
3270                 if (chan->dlci_configured == DLCI_CONFIG_PENDING) {
3271                         if (fr_init_dlci(card, chan)){
3272                                 return 1;
3273                         }
3274                 }
3275
3276         }
3277         return 1;
3278 }
3279
3280
3281 static int fr_init_dlci (sdla_t *card, fr_channel_t *chan)
3282 {
3283         fr_dlc_conf_t cfg;
3284         
3285         memset(&cfg, 0, sizeof(cfg));
3286
3287         if ( chan->cir_status == CIR_DISABLED) {
3288
3289                 cfg.cir_fwd = cfg.cir_bwd  = 16;
3290                 cfg.bc_fwd = cfg.bc_bwd = 16;
3291                 cfg.conf_flags = 0x0001;        
3292
3293         }else if (chan->cir_status == CIR_ENABLED) {
3294         
3295                 cfg.cir_fwd = cfg.cir_bwd = chan->cir;
3296                 cfg.bc_fwd  = cfg.bc_bwd  = chan->bc;
3297                 cfg.be_fwd  = cfg.be_bwd  = chan->be;
3298                 cfg.conf_flags = 0x0000;
3299         }
3300         
3301         if (fr_dlci_configure( card, &cfg , chan->dlci)){
3302                 printk(KERN_INFO 
3303                         "%s: DLCI Configure failed for %d\n",
3304                                 card->devname, chan->dlci);
3305                 return 1;       
3306         }
3307         
3308         chan->dlci_configured = DLCI_CONFIGURED;
3309
3310         /* Read the interface byte mapping into the channel 
3311          * structure.
3312          */
3313         read_DLCI_IB_mapping( card, chan );
3314
3315         return 0;
3316 }
3317 /******* Miscellaneous ******************************************************/
3318
3319 /*============================================================================
3320  * Update channel state. 
3321  */
3322 static int update_chan_state(struct net_device* dev)
3323 {
3324         fr_channel_t* chan = dev->priv;
3325         sdla_t* card = chan->card;
3326         fr_mbox_t* mbox = card->mbox;
3327         int retry = MAX_CMD_RETRY;
3328         int err;
3329
3330         do
3331         {
3332                 mbox->cmd.command = FR_LIST_ACTIVE_DLCI;
3333                 mbox->cmd.length = 0;
3334                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3335         } while (err && retry-- && fr_event(card, err, mbox));
3336
3337         if (!err) {
3338                 
3339                 unsigned short* list = (void*)mbox->data;
3340                 int cnt = mbox->cmd.length / sizeof(short);
3341                 
3342                 err=1;
3343                 
3344                 for (; cnt; --cnt, ++list) {
3345
3346                         if (*list == chan->dlci) {
3347                                 set_chan_state(dev, WAN_CONNECTED);
3348
3349
3350                                 /* May 23 2000. NC
3351                                  * When a dlci is added or restarted,
3352                                  * the dlci_int_interface pointer must
3353                                  * be reinitialized.  */
3354                                 if (!chan->dlci_int_interface){
3355                                         err=fr_init_dlci (card,chan);
3356                                 }
3357                                 break;
3358                         }
3359                 }
3360         }
3361
3362         return err;
3363 }
3364
3365 /*============================================================================
3366  * Set channel state.
3367  */
3368 static void set_chan_state(struct net_device* dev, int state)
3369 {
3370         fr_channel_t* chan = dev->priv;
3371         sdla_t* card = chan->card;
3372
3373         if (chan->common.state != state) {
3374
3375                 switch (state) {
3376
3377                         case WAN_CONNECTED:
3378                                 printk(KERN_INFO
3379                                         "%s: Interface %s: DLCI %d connected\n",
3380                                         card->devname, dev->name, chan->dlci);
3381
3382                                 /* If the interface was previoulsy down,
3383                                  * bring it up, since the channel is active */
3384
3385                                 trigger_fr_poll (dev);
3386                                 trigger_fr_arp  (dev);
3387                                 break;
3388
3389                         case WAN_CONNECTING:
3390                                 printk(KERN_INFO 
3391                                       "%s: Interface %s: DLCI %d connecting\n",
3392                                         card->devname, dev->name, chan->dlci);
3393                                 break;
3394
3395                         case WAN_DISCONNECTED:
3396                                 printk (KERN_INFO 
3397                                     "%s: Interface %s: DLCI %d disconnected!\n",
3398                                         card->devname, dev->name, chan->dlci);
3399                         
3400                                 /* If the interface is up, bring it down,
3401                                  * since the channel is now disconnected */
3402                                 trigger_fr_poll (dev);
3403                                 break;
3404                 }
3405
3406                 chan->common.state = state;
3407         }
3408
3409         chan->state_tick = jiffies;
3410 }
3411
3412 /*============================================================================
3413  * Find network device by its channel number.
3414  *
3415  * We need this critical flag because we change
3416  * the dlci_to_dev_map outside the interrupt.
3417  *
3418  * NOTE: del_if() functions updates this array, it uses
3419  *       the spin locks to avoid corruption.
3420  */
3421 static struct net_device* find_channel(sdla_t* card, unsigned dlci)
3422 {
3423         if(dlci > HIGHEST_VALID_DLCI)
3424                 return NULL;
3425
3426         return(card->u.f.dlci_to_dev_map[dlci]);
3427 }
3428
3429 /*============================================================================
3430  * Check to see if a frame can be sent. If no transmit buffers available,
3431  * enable transmit interrupts.
3432  *
3433  * Return:      1 - Tx buffer(s) available
3434  *              0 - no buffers available
3435  */
3436 static int is_tx_ready (sdla_t* card, fr_channel_t* chan)
3437 {
3438         unsigned char sb;
3439
3440         if(card->hw.type == SDLA_S514)
3441                 return 1;
3442
3443         sb = inb(card->hw.port);
3444         if (sb & 0x02) 
3445                 return 1;
3446
3447         return 0;
3448 }
3449
3450 /*============================================================================
3451  * Convert decimal string to unsigned integer.
3452  * If len != 0 then only 'len' characters of the string are converted.
3453  */
3454 static unsigned int dec_to_uint (unsigned char* str, int len)
3455 {
3456         unsigned val;
3457
3458         if (!len) 
3459                 len = strlen(str);
3460
3461         for (val = 0; len && is_digit(*str); ++str, --len)
3462                 val = (val * 10) + (*str - (unsigned)'0');
3463
3464         return val;
3465 }
3466
3467
3468
3469 /*=============================================================================
3470  * Store a UDP management packet for later processing.
3471  */
3472
3473 static int store_udp_mgmt_pkt(int udp_type, char udp_pkt_src, sdla_t* card,
3474                                 struct sk_buff *skb, int dlci)
3475 {
3476         int udp_pkt_stored = 0;
3477         
3478         struct net_device *dev = find_channel(card, dlci);
3479         fr_channel_t *chan;
3480         
3481         if (!dev || !(chan=dev->priv))
3482                 return 1;
3483         
3484         if(!card->u.f.udp_pkt_lgth && (skb->len <= MAX_LGTH_UDP_MGNT_PKT)){
3485                 card->u.f.udp_pkt_lgth = skb->len + chan->fr_header_len;
3486                 card->u.f.udp_type = udp_type;
3487                 card->u.f.udp_pkt_src = udp_pkt_src;
3488                 card->u.f.udp_dlci = dlci;
3489                 memcpy(card->u.f.udp_pkt_data, skb->data, skb->len);
3490                 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UDP;
3491                 udp_pkt_stored = 1;
3492
3493         }else{
3494                 printk(KERN_INFO "ERROR: UDP packet not stored for DLCI %d\n", 
3495                                                         dlci);
3496         }
3497
3498         if(udp_pkt_src == UDP_PKT_FRM_STACK){
3499                 dev_kfree_skb_any(skb);
3500         }else{
3501                 dev_kfree_skb_any(skb);
3502         }
3503                 
3504         return(udp_pkt_stored);
3505 }
3506
3507
3508 /*==============================================================================
3509  * Process UDP call of type FPIPE8ND
3510  */
3511 static int process_udp_mgmt_pkt(sdla_t* card)
3512 {
3513
3514         int c_retry = MAX_CMD_RETRY;
3515         unsigned char *buf;
3516         unsigned char frames;
3517         unsigned int len;
3518         unsigned short buffer_length;
3519         struct sk_buff *new_skb;
3520         fr_mbox_t* mbox = card->mbox;
3521         int err;
3522         struct timeval tv;
3523         int udp_mgmt_req_valid = 1;
3524         struct net_device* dev;
3525         fr_channel_t* chan;
3526         fr_udp_pkt_t *fr_udp_pkt;
3527         unsigned short num_trc_els;
3528         fr_trc_el_t* ptr_trc_el;
3529         fr_trc_el_t trc_el;
3530         fpipemon_trc_t* fpipemon_trc;
3531
3532         char udp_pkt_src = card->u.f.udp_pkt_src; 
3533         int dlci = card->u.f.udp_dlci;
3534
3535         /* Find network interface for this packet */
3536         dev = find_channel(card, dlci);
3537         if (!dev){
3538                 card->u.f.udp_pkt_lgth = 0;
3539                 return 1;
3540         }
3541         if ((chan = dev->priv) == NULL){
3542                 card->u.f.udp_pkt_lgth = 0;
3543                 return 1;
3544         }
3545
3546         /* If the UDP packet is from the network, we are going to have to 
3547            transmit a response. Before doing so, we must check to see that
3548            we are not currently transmitting a frame (in 'if_send()') and
3549            that we are not already in a 'delayed transmit' state.
3550         */
3551         if(udp_pkt_src == UDP_PKT_FRM_NETWORK) {
3552                 if (check_tx_status(card,dev)){
3553                         card->u.f.udp_pkt_lgth = 0;
3554                         return 1;
3555                 }
3556         }
3557
3558         fr_udp_pkt = (fr_udp_pkt_t *)card->u.f.udp_pkt_data;
3559
3560         if(udp_pkt_src == UDP_PKT_FRM_NETWORK) {
3561         
3562                 switch(fr_udp_pkt->cblock.command) {
3563
3564                         case FR_READ_MODEM_STATUS:
3565                         case FR_READ_STATUS:
3566                         case FPIPE_ROUTER_UP_TIME:
3567                         case FR_READ_ERROR_STATS:
3568                         case FPIPE_DRIVER_STAT_GEN:
3569                         case FR_READ_STATISTICS:
3570                         case FR_READ_ADD_DLC_STATS:
3571                         case FR_READ_CONFIG:
3572                         case FR_READ_CODE_VERSION:
3573                                 udp_mgmt_req_valid = 1;
3574                                 break;
3575                         default:
3576                                 udp_mgmt_req_valid = 0;
3577                                 break;
3578                 }
3579         }
3580
3581         if(!udp_mgmt_req_valid) {
3582                 /* set length to 0 */
3583                 fr_udp_pkt->cblock.length = 0;
3584                 /* set return code */
3585                 fr_udp_pkt->cblock.result = 0xCD; 
3586                 
3587                 chan->drvstats_gen.UDP_PIPE_mgmt_direction_err ++;
3588
3589                 if (net_ratelimit()){   
3590                         printk(KERN_INFO 
3591                         "%s: Warning, Illegal UDP command attempted from network: %x\n",
3592                         card->devname,fr_udp_pkt->cblock.command);
3593                 }
3594                 
3595         } else {   
3596            
3597                 switch(fr_udp_pkt->cblock.command) {
3598
3599                 case FPIPE_ENABLE_TRACING:
3600                         if(!card->TracingEnabled) {
3601                                 do {
3602                                         mbox->cmd.command = FR_SET_TRACE_CONFIG;
3603                                         mbox->cmd.length = 1;
3604                                         mbox->cmd.dlci = 0x00;
3605                                         mbox->data[0] = fr_udp_pkt->data[0] | 
3606                                                 RESET_TRC;
3607                                         err = sdla_exec(mbox) ? 
3608                                                         mbox->cmd.result : CMD_TIMEOUT;
3609                                 } while (err && c_retry-- && fr_event(card, err,
3610                                          mbox));
3611
3612                                 if(err) {
3613                                         card->TracingEnabled = 0;
3614                                         /* set the return code */
3615                                         fr_udp_pkt->cblock.result =
3616                                                 mbox->cmd.result;
3617                                         mbox->cmd.length = 0;
3618                                         break;
3619                                 }
3620
3621                                 sdla_peek(&card->hw, NO_TRC_ELEMENTS_OFF,
3622                                                 &num_trc_els, 2);
3623                                 sdla_peek(&card->hw, BASE_TRC_ELEMENTS_OFF,
3624                                                 &card->u.f.trc_el_base, 4);
3625                                 card->u.f.curr_trc_el = card->u.f.trc_el_base;
3626                                 card->u.f.trc_el_last = card->u.f.curr_trc_el +
3627                                                         ((num_trc_els - 1) * 
3628                                                         sizeof(fr_trc_el_t));
3629    
3630                                 /* Calculate the maximum trace data area in */
3631                                 /* the UDP packet */
3632                                 card->u.f.trc_bfr_space=(MAX_LGTH_UDP_MGNT_PKT -
3633                                         //sizeof(fr_encap_hdr_t) -
3634                                         sizeof(ip_pkt_t) -
3635                                         sizeof(udp_pkt_t) -
3636                                         sizeof(wp_mgmt_t) -
3637                                         sizeof(cblock_t));
3638
3639                                 /* set return code */
3640                                 fr_udp_pkt->cblock.result = 0;
3641                         
3642