[NET]: Kill skb->list
[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         chan->transmit_length = len;
1601         chan->delay_skb = skb;
1602         
1603         dlci_interface->gen_interrupt |= FR_INTR_TXRDY;
1604         dlci_interface->packet_length = len;
1605
1606         /* Turn on TX interrupt at the end of if_send */
1607         return 0;
1608 }
1609
1610
1611 /*============================================================================
1612  * Check to see if the packet to be transmitted contains a broadcast or
1613  * multicast source IP address.
1614  * Return 0 if not broadcast/multicast address, otherwise return 1.
1615  */
1616
1617 static int chk_bcast_mcast_addr(sdla_t *card, struct net_device* dev,
1618                                 struct sk_buff *skb)
1619 {
1620         u32 src_ip_addr;
1621         u32 broadcast_ip_addr = 0;
1622         struct in_device *in_dev;
1623         fr_channel_t* chan = dev->priv;
1624  
1625         /* read the IP source address from the outgoing packet */
1626         src_ip_addr = *(u32 *)(skb->data + 14);
1627
1628         /* read the IP broadcast address for the device */
1629         in_dev = dev->ip_ptr;
1630         if(in_dev != NULL) {
1631                 struct in_ifaddr *ifa= in_dev->ifa_list;
1632                 if(ifa != NULL)
1633                         broadcast_ip_addr = ifa->ifa_broadcast;
1634                 else
1635                         return 0;
1636         }
1637
1638         /* check if the IP Source Address is a Broadcast address */
1639         if((dev->flags & IFF_BROADCAST) && (src_ip_addr == broadcast_ip_addr)) {
1640                 printk(KERN_INFO
1641                         "%s: Broadcast Source Address silently discarded\n",
1642                         card->devname);
1643                 return 1;
1644         }
1645
1646         /* check if the IP Source Address is a Multicast address */
1647         if((chan->mc == WANOPT_NO) && (ntohl(src_ip_addr) >= 0xE0000001) &&
1648                 (ntohl(src_ip_addr) <= 0xFFFFFFFE)) {
1649                 printk(KERN_INFO
1650                         "%s: Multicast Source Address silently discarded\n",
1651                         card->devname);
1652                 return 1;
1653         }
1654
1655         return 0;
1656 }
1657
1658 /*============================================================================
1659  * Reply to UDP Management system.
1660  * Return nothing.
1661  */
1662 static int reply_udp( unsigned char *data, unsigned int mbox_len ) 
1663 {
1664         unsigned short len, udp_length, temp, ip_length;
1665         unsigned long ip_temp;
1666         int even_bound = 0;
1667
1668   
1669         fr_udp_pkt_t *fr_udp_pkt = (fr_udp_pkt_t *)data; 
1670
1671         /* Set length of packet */
1672         len = //sizeof(fr_encap_hdr_t)+
1673               sizeof(ip_pkt_t)+ 
1674               sizeof(udp_pkt_t)+
1675               sizeof(wp_mgmt_t)+
1676               sizeof(cblock_t)+
1677               mbox_len;
1678  
1679
1680         /* fill in UDP reply */
1681         fr_udp_pkt->wp_mgmt.request_reply = UDPMGMT_REPLY;
1682   
1683         /* fill in UDP length */
1684         udp_length = sizeof(udp_pkt_t)+ 
1685                      sizeof(wp_mgmt_t)+
1686                      sizeof(cblock_t)+
1687                      mbox_len; 
1688
1689
1690         /* put it on an even boundary */
1691         if ( udp_length & 0x0001 ) {
1692                 udp_length += 1;
1693                 len += 1;
1694                 even_bound = 1;
1695         }
1696
1697         temp = (udp_length<<8)|(udp_length>>8);
1698         fr_udp_pkt->udp_pkt.udp_length = temp;
1699          
1700         /* swap UDP ports */
1701         temp = fr_udp_pkt->udp_pkt.udp_src_port;
1702         fr_udp_pkt->udp_pkt.udp_src_port = 
1703                         fr_udp_pkt->udp_pkt.udp_dst_port; 
1704         fr_udp_pkt->udp_pkt.udp_dst_port = temp;
1705
1706
1707
1708         /* add UDP pseudo header */
1709         temp = 0x1100;
1710         *((unsigned short *)
1711                 (fr_udp_pkt->data+mbox_len+even_bound)) = temp; 
1712         temp = (udp_length<<8)|(udp_length>>8);
1713         *((unsigned short *)
1714                 (fr_udp_pkt->data+mbox_len+even_bound+2)) = temp;
1715                  
1716         /* calculate UDP checksum */
1717         fr_udp_pkt->udp_pkt.udp_checksum = 0;
1718
1719         fr_udp_pkt->udp_pkt.udp_checksum = 
1720                 calc_checksum(&data[UDP_OFFSET/*+sizeof(fr_encap_hdr_t)*/],
1721                               udp_length+UDP_OFFSET);
1722
1723         /* fill in IP length */
1724         ip_length = udp_length + sizeof(ip_pkt_t);
1725         temp = (ip_length<<8)|(ip_length>>8);
1726         fr_udp_pkt->ip_pkt.total_length = temp;
1727   
1728         /* swap IP addresses */
1729         ip_temp = fr_udp_pkt->ip_pkt.ip_src_address;
1730         fr_udp_pkt->ip_pkt.ip_src_address = 
1731                                 fr_udp_pkt->ip_pkt.ip_dst_address;
1732         fr_udp_pkt->ip_pkt.ip_dst_address = ip_temp;
1733
1734                  
1735         /* fill in IP checksum */
1736         fr_udp_pkt->ip_pkt.hdr_checksum = 0;
1737         fr_udp_pkt->ip_pkt.hdr_checksum = 
1738                 calc_checksum(&data[/*sizeof(fr_encap_hdr_t)*/0],
1739                               sizeof(ip_pkt_t));
1740
1741         return len;
1742 } /* reply_udp */
1743
1744 unsigned short calc_checksum (char *data, int len)
1745 {
1746         unsigned short temp; 
1747         unsigned long sum=0;
1748         int i;
1749
1750         for( i = 0; i <len; i+=2 ) {
1751                 memcpy(&temp,&data[i],2);
1752                 sum += (unsigned long)temp;
1753         }
1754
1755         while (sum >> 16 ) {
1756                 sum = (sum & 0xffffUL) + (sum >> 16);
1757         }
1758
1759         temp = (unsigned short)sum;
1760         temp = ~temp;
1761
1762         if( temp == 0 ) 
1763                 temp = 0xffff;
1764
1765         return temp;    
1766 }
1767
1768 /*
1769    If incoming is 0 (outgoing)- if the net numbers is ours make it 0
1770    if incoming is 1 - if the net number is 0 make it ours 
1771
1772 */
1773 static void switch_net_numbers(unsigned char *sendpacket, unsigned long network_number, unsigned char incoming)
1774 {
1775         unsigned long pnetwork_number;
1776
1777         pnetwork_number = (unsigned long)((sendpacket[14] << 24) + 
1778                           (sendpacket[15] << 16) + (sendpacket[16] << 8) + 
1779                           sendpacket[17]);
1780
1781         if (!incoming) {
1782                 /* If the destination network number is ours, make it 0 */
1783                 if( pnetwork_number == network_number) {
1784                         sendpacket[14] = sendpacket[15] = sendpacket[16] = 
1785                                          sendpacket[17] = 0x00;
1786                 }
1787         } else {
1788                 /* If the incoming network is 0, make it ours */
1789                 if( pnetwork_number == 0) {
1790                         sendpacket[14] = (unsigned char)(network_number >> 24);
1791                         sendpacket[15] = (unsigned char)((network_number & 
1792                                          0x00FF0000) >> 16);
1793                         sendpacket[16] = (unsigned char)((network_number & 
1794                                          0x0000FF00) >> 8);
1795                         sendpacket[17] = (unsigned char)(network_number & 
1796                                          0x000000FF);
1797                 }
1798         }
1799
1800
1801         pnetwork_number = (unsigned long)((sendpacket[26] << 24) + 
1802                           (sendpacket[27] << 16) + (sendpacket[28] << 8) + 
1803                           sendpacket[29]);
1804
1805         if( !incoming ) {
1806                 /* If the source network is ours, make it 0 */
1807                 if( pnetwork_number == network_number) {
1808                         sendpacket[26] = sendpacket[27] = sendpacket[28] = 
1809                                          sendpacket[29] = 0x00;
1810                 }
1811         } else {
1812                 /* If the source network is 0, make it ours */
1813                 if( pnetwork_number == 0 ) {
1814                         sendpacket[26] = (unsigned char)(network_number >> 24);
1815                         sendpacket[27] = (unsigned char)((network_number & 
1816                                          0x00FF0000) >> 16);
1817                         sendpacket[28] = (unsigned char)((network_number & 
1818                                          0x0000FF00) >> 8);
1819                         sendpacket[29] = (unsigned char)(network_number & 
1820                                          0x000000FF);
1821                 }
1822         }
1823 } /* switch_net_numbers */
1824
1825 /*============================================================================
1826  * Get ethernet-style interface statistics.
1827  * Return a pointer to struct enet_statistics.
1828  */
1829 static struct net_device_stats *if_stats(struct net_device *dev)
1830 {
1831         fr_channel_t* chan = dev->priv;
1832         
1833         if(chan == NULL)
1834                 return NULL;
1835
1836         return &chan->ifstats;
1837 }
1838
1839 /****** Interrupt Handlers **************************************************/
1840
1841 /*============================================================================
1842  * fr_isr:      S508 frame relay interrupt service routine.
1843  *
1844  * Description:
1845  *      Frame relay main interrupt service route. This
1846  *      function check the interrupt type and takes
1847  *      the appropriate action.
1848  */
1849 static void fr_isr (sdla_t* card)
1850 {
1851         fr508_flags_t* flags = card->flags;
1852         char *ptr = &flags->iflag;
1853         int i,err;
1854         fr_mbox_t* mbox = card->mbox;
1855
1856         /* This flag prevents nesting of interrupts.  See sdla_isr() routine
1857          * in sdlamain.c.  */
1858         card->in_isr = 1;
1859         
1860         ++card->statistics.isr_entry;
1861
1862
1863         /* All peripheral (configuraiton, re-configuration) events
1864          * take presidence over the ISR.  Thus, retrigger */
1865         if (test_bit(PERI_CRIT, (void*)&card->wandev.critical)) {
1866                 ++card->statistics.isr_already_critical;
1867                 goto fr_isr_exit;
1868         }
1869         
1870         if(card->hw.type != SDLA_S514) {
1871                 if (test_bit(SEND_CRIT, (void*)&card->wandev.critical)) {
1872                         printk(KERN_INFO "%s: Critical while in ISR: If Send Running!\n",
1873                                 card->devname);
1874                         ++card->statistics.isr_already_critical;
1875                         goto fr_isr_exit;
1876                 }
1877         }
1878
1879         switch (flags->iflag) {
1880
1881                 case FR_INTR_RXRDY:  /* receive interrupt */
1882                         ++card->statistics.isr_rx;
1883                         rx_intr(card);
1884                         break;
1885
1886
1887                 case FR_INTR_TXRDY:  /* transmit interrupt */
1888                         ++ card->statistics.isr_tx; 
1889                         tx_intr(card); 
1890                         break;
1891
1892                 case FR_INTR_READY:     
1893                         Intr_test_counter++;
1894                         ++card->statistics.isr_intr_test;
1895                         break;  
1896
1897                 case FR_INTR_DLC: /* Event interrupt occurred */
1898                         mbox->cmd.command = FR_READ_STATUS;
1899                         mbox->cmd.length = 0;
1900                         err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
1901                         if (err)
1902                                 fr_event(card, err, mbox);
1903                         break;
1904
1905                 case FR_INTR_TIMER:  /* Timer interrupt */
1906                         timer_intr(card);
1907                         break;
1908         
1909                 default:
1910                         ++card->statistics.isr_spurious;
1911                         spur_intr(card);
1912                         printk(KERN_INFO "%s: Interrupt Type 0x%02X!\n", 
1913                                 card->devname, flags->iflag);
1914             
1915                         printk(KERN_INFO "%s: ID Bytes = ",card->devname);
1916                         for(i = 0; i < 8; i ++)
1917                                 printk(KERN_INFO "0x%02X ", *(ptr + 0x28 + i));
1918                         printk(KERN_INFO "\n"); 
1919             
1920                         break;
1921         }
1922
1923 fr_isr_exit:
1924         
1925         card->in_isr = 0;
1926         flags->iflag = 0;
1927         return;
1928 }
1929
1930
1931
1932 /*===========================================================
1933  * rx_intr      Receive interrupt handler.
1934  *
1935  * Description
1936  *      Upon receiveing an interrupt: 
1937  *      1. Check that the firmware is in sync with 
1938  *         the driver. 
1939  *      2. Find an appropriate network interface
1940  *         based on the received dlci number.
1941  *      3. Check that the netowrk interface exists
1942  *         and that it's setup properly.
1943  *      4. Copy the data into an skb buffer.
1944  *      5. Check the packet type and take
1945  *         appropriate acton: UPD, API, ARP or Data.
1946  */
1947
1948 static void rx_intr (sdla_t* card)
1949 {
1950         fr_rx_buf_ctl_t* frbuf = card->rxmb;
1951         fr508_flags_t* flags = card->flags;
1952         fr_channel_t* chan;
1953         char *ptr = &flags->iflag;
1954         struct sk_buff* skb;
1955         struct net_device* dev;
1956         void* buf;
1957         unsigned dlci, len, offs, len_incl_hdr;
1958         int i, udp_type;        
1959
1960
1961         /* Check that firmware buffers are in sync */
1962         if (frbuf->flag != 0x01) {
1963
1964                 printk(KERN_INFO 
1965                         "%s: corrupted Rx buffer @ 0x%X, flag = 0x%02X!\n", 
1966                         card->devname, (unsigned)frbuf, frbuf->flag);
1967       
1968                 printk(KERN_INFO "%s: ID Bytes = ",card->devname);
1969                 for(i = 0; i < 8; i ++)
1970                         printk(KERN_INFO "0x%02X ", *(ptr + 0x28 + i));
1971                 printk(KERN_INFO "\n");
1972         
1973                 ++card->statistics.rx_intr_corrupt_rx_bfr;
1974
1975                 /* Bug Fix: Mar 6 2000
1976                  * If we get a corrupted mailbox, it means that driver 
1977                  * is out of sync with the firmware. There is no recovery.
1978                  * If we don't turn off all interrupts for this card
1979                  * the machine will crash. 
1980                  */
1981                 printk(KERN_INFO "%s: Critical router failure ...!!!\n", card->devname);
1982                 printk(KERN_INFO "Please contact Sangoma Technologies !\n");
1983                 fr_set_intr_mode(card, 0, 0, 0);        
1984                 return;
1985         }
1986
1987         len  = frbuf->length;
1988         dlci = frbuf->dlci;
1989         offs = frbuf->offset;
1990
1991         /* Find the network interface for this packet */
1992         dev = find_channel(card, dlci);
1993    
1994
1995         /* Check that the network interface is active and
1996          * properly setup */
1997         if (dev == NULL) {
1998                 if( net_ratelimit()) { 
1999                         printk(KERN_INFO "%s: received data on unconfigured DLCI %d!\n",
2000                                                 card->devname, dlci);
2001                 }
2002                 ++card->statistics.rx_intr_on_orphaned_DLCI; 
2003                 ++card->wandev.stats.rx_dropped;
2004                 goto rx_done;
2005         }
2006
2007         if ((chan = dev->priv) == NULL){
2008                 if( net_ratelimit()) { 
2009                         printk(KERN_INFO "%s: received data on unconfigured DLCI %d!\n",
2010                                                 card->devname, dlci);
2011                 }
2012                 ++card->statistics.rx_intr_on_orphaned_DLCI; 
2013                 ++card->wandev.stats.rx_dropped;
2014                 goto rx_done;
2015         }
2016
2017         skb = dev_alloc_skb(len); 
2018
2019         if (!netif_running(dev) || (skb == NULL)){
2020
2021                 ++chan->ifstats.rx_dropped;
2022         
2023                 if(skb == NULL) {
2024                         if (net_ratelimit()) { 
2025                                 printk(KERN_INFO 
2026                                         "%s: no socket buffers available!\n", 
2027                                                 card->devname);
2028                         }
2029                         chan->drvstats_rx_intr.rx_intr_no_socket ++;
2030                 } 
2031
2032                 if (!netif_running(dev)){
2033                         chan->drvstats_rx_intr.
2034                                 rx_intr_dev_not_started ++;
2035                         if (skb){
2036                                 dev_kfree_skb_any(skb);
2037                         }
2038                 }
2039                 goto rx_done;
2040         }
2041
2042         /* Copy data from the board into the socket buffer */
2043         if ((offs + len) > card->u.f.rx_top + 1) {
2044                 unsigned tmp = card->u.f.rx_top - offs + 1;
2045
2046                 buf = skb_put(skb, tmp);
2047                 sdla_peek(&card->hw, offs, buf, tmp);
2048                 offs = card->u.f.rx_base;
2049                 len -= tmp;
2050         }
2051
2052         buf = skb_put(skb, len);
2053         sdla_peek(&card->hw, offs, buf, len);
2054
2055
2056         /* We got the packet from the bard. 
2057          * Check the packet type and take appropriate action */
2058
2059         udp_type = udp_pkt_type( skb, card );
2060
2061         if(udp_type != UDP_INVALID_TYPE) {
2062
2063                 /* UDP Debug packet received, store the
2064                  * packet and handle it in timer interrupt */
2065
2066                 skb_pull(skb, 1); 
2067                 if (wanrouter_type_trans(skb, dev)){ 
2068                         if(store_udp_mgmt_pkt(udp_type,UDP_PKT_FRM_NETWORK,card,skb,dlci)){
2069
2070                                 flags->imask |= FR_INTR_TIMER;
2071
2072                                 if (udp_type == UDP_FPIPE_TYPE){
2073                                         ++chan->drvstats_rx_intr.rx_intr_PIPE_request;
2074                                 }
2075                         }
2076                 }
2077
2078         }else if (chan->common.usedby == API) {
2079
2080                 /* We are in API mode. 
2081                  * Add an API header to the RAW packet
2082                  * and queue it into a circular buffer.
2083                  * Then kick the fr_bh() bottom half handler */
2084
2085                 api_rx_hdr_t* api_rx_hdr;
2086                 chan->drvstats_rx_intr.rx_intr_bfr_passed_to_stack ++;
2087                 chan->ifstats.rx_packets ++;
2088                 card->wandev.stats.rx_packets ++;
2089
2090                 chan->ifstats.rx_bytes += skb->len;
2091                 card->wandev.stats.rx_bytes += skb->len;
2092
2093                 skb_push(skb, sizeof(api_rx_hdr_t));
2094                 api_rx_hdr = (api_rx_hdr_t*)&skb->data[0x00];
2095                 api_rx_hdr->attr = frbuf->attr;
2096                 api_rx_hdr->time_stamp = frbuf->tmstamp;
2097
2098                 skb->protocol = htons(ETH_P_IP);
2099                 skb->mac.raw  = skb->data;
2100                 skb->dev      = dev;
2101                 skb->pkt_type = WAN_PACKET_DATA;
2102
2103                 bh_enqueue(dev, skb);
2104
2105                 trigger_fr_bh(chan);
2106
2107         }else if (handle_IPXWAN(skb->data,chan->name,chan->enable_IPX, chan->network_number)){
2108
2109                 //FIXME: Frame Relay IPX is not supported, Yet !
2110                 //if (chan->enable_IPX) {
2111                 //      fr_send(card, dlci, 0, skb->len,skb->data);
2112                 //}
2113                 dev_kfree_skb_any(skb);
2114
2115         } else if (is_arp(skb->data)) {
2116
2117                 /* ARP support enabled Mar 16 2000 
2118                  * Process incoming ARP reply/request, setup
2119                  * dynamic routes. */ 
2120
2121                 if (process_ARP((arphdr_1490_t *)skb->data, card, dev)) {
2122                         if (net_ratelimit()){  
2123                                 printk (KERN_INFO 
2124                                    "%s: Error processing ARP Packet.\n", 
2125                                         card->devname);
2126                         }
2127                 }
2128                 dev_kfree_skb_any(skb);
2129
2130         } else if (skb->data[0] != 0x03) {
2131
2132                 if (net_ratelimit()) { 
2133                         printk(KERN_INFO "%s: Non IETF packet discarded.\n", 
2134                                 card->devname);
2135                 }
2136                 dev_kfree_skb_any(skb);
2137
2138         } else {
2139
2140                 len_incl_hdr = skb->len;
2141                 /* Decapsulate packet and pass it up the
2142                    protocol stack */
2143                 skb->dev = dev;
2144                 
2145                 if (chan->common.usedby == BRIDGE || chan->common.usedby == BRIDGE_NODE){
2146                 
2147                         /* Make sure it's an Ethernet frame, otherwise drop it */
2148                         if (!memcmp(skb->data, "\x03\x00\x80\x00\x80\xC2\x00\x07", 8)) {
2149                                 skb_pull(skb, 8);
2150                                 skb->protocol=eth_type_trans(skb,dev);
2151                         }else{
2152                                 ++chan->drvstats_rx_intr.rx_intr_bfr_not_passed_to_stack;
2153                                 ++chan->ifstats.rx_errors;
2154                                 ++card->wandev.stats.rx_errors;
2155                                 goto rx_done;
2156                         }
2157                 }else{
2158                 
2159                         /* remove hardware header */
2160                         buf = skb_pull(skb, 1); 
2161                         
2162                         if (!wanrouter_type_trans(skb, dev)) {
2163                                 
2164                                 /* can't decapsulate packet */
2165                                 dev_kfree_skb_any(skb);
2166
2167                                 ++chan->drvstats_rx_intr.rx_intr_bfr_not_passed_to_stack;
2168                                 ++chan->ifstats.rx_errors;
2169                                 ++card->wandev.stats.rx_errors;
2170                                 goto rx_done;   
2171                         }
2172                         skb->mac.raw = skb->data;
2173                 } 
2174                 
2175
2176                 /* Send a packet up the IP stack */
2177                 skb->dev->last_rx = jiffies;
2178                 netif_rx(skb);
2179                 ++chan->drvstats_rx_intr.rx_intr_bfr_passed_to_stack;
2180                 ++chan->ifstats.rx_packets;
2181                 ++card->wandev.stats.rx_packets;
2182
2183                 chan->ifstats.rx_bytes += len_incl_hdr;
2184                 card->wandev.stats.rx_bytes += len_incl_hdr;
2185         }
2186
2187 rx_done:
2188
2189         /* Release buffer element and calculate a pointer to the next one */ 
2190         frbuf->flag = 0;
2191         card->rxmb = ++frbuf;
2192         if ((void*)frbuf > card->u.f.rxmb_last)
2193                 card->rxmb = card->u.f.rxmb_base;
2194
2195 }
2196
2197 /*==================================================================
2198  * tx_intr:     Transmit interrupt handler.
2199  *
2200  * Rationale:
2201  *      If the board is busy transmitting, if_send() will
2202  *      buffers a single packet and turn on
2203  *      the tx interrupt. Tx interrupt will be called
2204  *      by the board, once the firmware can send more
2205  *      data. Thus, no polling is required.      
2206  *
2207  * Description:
2208  *      Tx interrupt is called for each 
2209  *      configured dlci channel. Thus: 
2210  *      1. Obtain the netowrk interface based on the
2211  *         dlci number.
2212  *      2. Check that network interface is up and
2213  *         properly setup.
2214  *      3. Check for a buffered packet.
2215  *      4. Transmit the packet.
2216  *      5. If we are in WANPIPE mode, mark the 
2217  *         NET_BH handler. 
2218  *      6. If we are in API mode, kick
2219  *         the AF_WANPIPE socket for more data. 
2220  *         
2221  */
2222 static void tx_intr(sdla_t *card)
2223 {
2224         fr508_flags_t* flags = card->flags;
2225         fr_tx_buf_ctl_t* bctl;
2226         struct net_device* dev;
2227         fr_channel_t* chan;
2228
2229         if(card->hw.type == SDLA_S514){
2230                 bctl = (void*)(flags->tse_offs + card->hw.dpmbase);
2231         }else{
2232                 bctl = (void*)(flags->tse_offs - FR_MB_VECTOR +
2233                         card->hw.dpmbase);
2234         }
2235
2236         /* Find the structure and make it unbusy */
2237         dev = find_channel(card, flags->dlci);
2238         if (dev == NULL){
2239                 printk(KERN_INFO "NO DEV IN TX Interrupt\n");   
2240                 goto end_of_tx_intr;
2241         }
2242
2243         if ((chan = dev->priv) == NULL){
2244                 printk(KERN_INFO "NO CHAN IN TX Interrupt\n");  
2245                 goto end_of_tx_intr;
2246         }
2247
2248         if(!chan->transmit_length || !chan->delay_skb) {
2249                 printk(KERN_INFO "%s: tx int error - transmit length zero\n",
2250                                 card->wandev.name);
2251                 goto end_of_tx_intr;
2252         }
2253
2254         /* If the 'if_send()' procedure is currently checking the 'tbusy'
2255            status, then we cannot transmit. Instead, we configure the microcode
2256            so as to re-issue this transmit interrupt at a later stage. 
2257         */
2258         if (test_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical)) {
2259
2260                 fr_dlci_interface_t* dlci_interface = chan->dlci_int_interface;
2261                 bctl->flag = 0xA0;
2262                 dlci_interface->gen_interrupt |= FR_INTR_TXRDY;
2263                 return;
2264
2265         }else{
2266                 bctl->dlci = flags->dlci;
2267                 bctl->length = chan->transmit_length+chan->fr_header_len;
2268                 sdla_poke(&card->hw, 
2269                           fr_send_hdr(card,bctl->dlci,bctl->offset), 
2270                           chan->delay_skb->data,
2271                           chan->delay_skb->len);
2272                 bctl->flag = 0xC0;
2273
2274                 ++chan->ifstats.tx_packets;
2275                 ++card->wandev.stats.tx_packets;
2276                 chan->ifstats.tx_bytes += chan->transmit_length;
2277                 card->wandev.stats.tx_bytes += chan->transmit_length;
2278
2279                 /* We must free an sk buffer, which we used
2280                  * for delayed transmission; Otherwise, the sock
2281                  * will run out of memory */
2282                 dev_kfree_skb_any(chan->delay_skb);
2283
2284                 chan->delay_skb = NULL;                         
2285                 chan->transmit_length = 0;
2286
2287                 dev->trans_start = jiffies;
2288
2289                 if (netif_queue_stopped(dev)){
2290                         /* If using API, than wakeup socket BH handler */
2291                         if (chan->common.usedby == API){
2292                                 netif_start_queue(dev);
2293                                 wakeup_sk_bh(dev);
2294                         }else{
2295                                 netif_wake_queue(dev);
2296                         }
2297                 }
2298         }
2299
2300 end_of_tx_intr:
2301
2302         /* if any other interfaces have transmit interrupts pending, 
2303          * do not disable the global transmit interrupt */
2304         if(!(-- card->u.f.tx_interrupts_pending))
2305                 flags->imask &= ~FR_INTR_TXRDY;
2306
2307
2308 }
2309
2310
2311 /*============================================================================
2312  * timer_intr:  Timer interrupt handler.
2313  *
2314  * Rationale:
2315  *      All commans must be executed within the timer
2316  *      interrupt since no two commands should execute
2317  *      at the same time.
2318  *
2319  * Description:
2320  *      The timer interrupt is used to:
2321  *      1. Processing udp calls from 'fpipemon'.
2322  *      2. Processing update calls from /proc file system
2323  *      3. Reading board-level statistics for 
2324  *         updating the proc file system.
2325  *      4. Sending inverse ARP request packets.
2326  *      5. Configure a dlci/channel.
2327  *      6. Unconfigure a dlci/channel. (Node only)
2328  */
2329
2330 static void timer_intr(sdla_t *card)
2331 {
2332         fr508_flags_t* flags = card->flags;
2333
2334         /* UDP Debuging: fpipemon call */
2335         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UDP) {
2336                 if(card->u.f.udp_type == UDP_FPIPE_TYPE) {
2337                         if(process_udp_mgmt_pkt(card)) {
2338                                 card->u.f.timer_int_enabled &=
2339                                         ~TMR_INT_ENABLED_UDP;
2340                         }
2341                 }
2342         }
2343
2344         /* /proc update call : triggered from update() */
2345         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UPDATE) {
2346                 fr_get_err_stats(card);
2347                 fr_get_stats(card);
2348                 card->u.f.update_comms_stats = 0;
2349                 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE;
2350         }
2351
2352         /* Update the channel state call.  This is call is
2353          * triggered by if_send() function */
2354         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UPDATE_STATE){
2355                 struct net_device *dev;
2356                 if (card->wandev.state == WAN_CONNECTED){
2357                         for (dev = card->wandev.dev; dev;
2358                              dev = *((struct net_device **)dev->priv)){
2359                                 fr_channel_t *chan = dev->priv; 
2360                                 if (chan->common.state != WAN_CONNECTED){
2361                                         update_chan_state(dev);
2362                                 }
2363                         }
2364                 }
2365                 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE_STATE;
2366         }
2367
2368         /* configure a dlci/channel */
2369         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_CONFIG){
2370                 config_fr(card);
2371                 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_CONFIG;
2372         }
2373
2374         /* unconfigure a dlci/channel */
2375         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UNCONFIG){
2376                 unconfig_fr(card);
2377                 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UNCONFIG;
2378         }
2379
2380         
2381         /* Transmit ARP packets */
2382         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_ARP){
2383                 int i=0;
2384                 struct net_device *dev;
2385
2386                 if (card->u.f.arp_dev == NULL)
2387                         card->u.f.arp_dev = card->wandev.dev;
2388
2389                 dev = card->u.f.arp_dev;
2390
2391                 for (;;){ 
2392
2393                         fr_channel_t *chan = dev->priv;
2394
2395                         /* If the interface is brought down cancel sending In-ARPs */
2396                         if (!(dev->flags&IFF_UP)){
2397                                 clear_bit(0,&chan->inarp_ready);        
2398                         }
2399
2400                         if (test_bit(0,&chan->inarp_ready)){
2401
2402                                 if (check_tx_status(card,dev)){
2403                                         set_bit(ARP_CRIT,&card->wandev.critical);
2404                                         break;
2405                                 }
2406
2407                                 if (!send_inarp_request(card,dev)){
2408                                         trigger_fr_arp(dev);
2409                                         chan->inarp_tick = jiffies;
2410                                 }
2411
2412                                 clear_bit(0,&chan->inarp_ready);
2413                                 dev = move_dev_to_next(card,dev);
2414                                 break;
2415                         }
2416                         dev = move_dev_to_next(card,dev);
2417
2418                         if (++i == card->wandev.new_if_cnt){
2419                                 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_ARP;
2420                                 break;
2421                         }
2422                 }
2423                 card->u.f.arp_dev = dev;
2424         }
2425
2426         if(!card->u.f.timer_int_enabled)
2427                 flags->imask &= ~FR_INTR_TIMER;
2428 }
2429
2430
2431 /*============================================================================
2432  * spur_intr:   Spurious interrupt handler.
2433  * 
2434  * Description:
2435  *      We don't know this interrupt.
2436  *      Print a warning.
2437  */
2438
2439 static void spur_intr (sdla_t* card)
2440 {
2441         if (net_ratelimit()){ 
2442                 printk(KERN_INFO "%s: spurious interrupt!\n", card->devname);
2443         }
2444 }
2445
2446
2447 //FIXME: Fix the IPX in next version
2448 /*===========================================================================
2449  *  Return 0 for non-IPXWAN packet
2450  *         1 for IPXWAN packet or IPX is not enabled!
2451  *  FIXME: Use a IPX structure here not offsets
2452  */
2453 static int handle_IPXWAN(unsigned char *sendpacket, 
2454                          char *devname, unsigned char enable_IPX, 
2455                          unsigned long network_number)
2456 {
2457         int i;
2458
2459         if( sendpacket[1] == 0x00 && sendpacket[2] == 0x80 &&
2460             sendpacket[6] == 0x81 && sendpacket[7] == 0x37) { 
2461
2462                 /* It's an IPX packet */
2463                 if (!enable_IPX){
2464                         /* Return 1 so we don't pass it up the stack. */
2465                         //FIXME: Take this out when IPX is fixed
2466                         if (net_ratelimit()){ 
2467                                 printk (KERN_INFO 
2468                                 "%s: WARNING: Unsupported IPX packet received and dropped\n",
2469                                         devname);
2470                         }
2471                         return 1;
2472                 }
2473         } else {
2474                 /* It's not IPX so return and pass it up the stack. */
2475                 return 0;
2476         }
2477
2478         if( sendpacket[24] == 0x90 && sendpacket[25] == 0x04){
2479                 /* It's IPXWAN */
2480
2481                 if( sendpacket[10] == 0x02 && sendpacket[42] == 0x00){
2482
2483                         /* It's a timer request packet */
2484                         printk(KERN_INFO "%s: Received IPXWAN Timer Request packet\n",
2485                                         devname);
2486
2487                         /* Go through the routing options and answer no to every
2488                          * option except Unnumbered RIP/SAP
2489                          */
2490                         for(i = 49; sendpacket[i] == 0x00; i += 5){
2491                                 /* 0x02 is the option for Unnumbered RIP/SAP */
2492                                 if( sendpacket[i + 4] != 0x02){
2493                                         sendpacket[i + 1] = 0;
2494                                 }
2495                         }
2496
2497                         /* Skip over the extended Node ID option */
2498                         if( sendpacket[i] == 0x04 ){
2499                                 i += 8;
2500                         }
2501
2502                         /* We also want to turn off all header compression opt.
2503                          */
2504                         for(; sendpacket[i] == 0x80 ;){
2505                                 sendpacket[i + 1] = 0;
2506                                 i += (sendpacket[i + 2] << 8) + (sendpacket[i + 3]) + 4;
2507                         }
2508
2509                         /* Set the packet type to timer response */
2510                         sendpacket[42] = 0x01;
2511
2512                         printk(KERN_INFO "%s: Sending IPXWAN Timer Response\n",
2513                                         devname);
2514
2515                 } else if( sendpacket[42] == 0x02 ){
2516
2517                         /* This is an information request packet */
2518                         printk(KERN_INFO 
2519                                 "%s: Received IPXWAN Information Request packet\n",
2520                                                 devname);
2521
2522                         /* Set the packet type to information response */
2523                         sendpacket[42] = 0x03;
2524
2525                         /* Set the router name */
2526                         sendpacket[59] = 'F';
2527                         sendpacket[60] = 'P';
2528                         sendpacket[61] = 'I';
2529                         sendpacket[62] = 'P';
2530                         sendpacket[63] = 'E';
2531                         sendpacket[64] = '-';
2532                         sendpacket[65] = CVHexToAscii(network_number >> 28);
2533                         sendpacket[66] = CVHexToAscii((network_number & 0x0F000000)>> 24);
2534                         sendpacket[67] = CVHexToAscii((network_number & 0x00F00000)>> 20);
2535                         sendpacket[68] = CVHexToAscii((network_number & 0x000F0000)>> 16);
2536                         sendpacket[69] = CVHexToAscii((network_number & 0x0000F000)>> 12);
2537                         sendpacket[70] = CVHexToAscii((network_number & 0x00000F00)>> 8);
2538                         sendpacket[71] = CVHexToAscii((network_number & 0x000000F0)>> 4);
2539                         sendpacket[72] = CVHexToAscii(network_number & 0x0000000F);
2540                         for(i = 73; i < 107; i+= 1)
2541                         {
2542                                 sendpacket[i] = 0;
2543                         }
2544
2545                         printk(KERN_INFO "%s: Sending IPXWAN Information Response packet\n",
2546                                         devname);
2547                 } else {
2548
2549                         printk(KERN_INFO "%s: Unknown IPXWAN packet!\n",devname);
2550                         return 0;
2551                 }
2552
2553                 /* Set the WNodeID to our network address */
2554                 sendpacket[43] = (unsigned char)(network_number >> 24);
2555                 sendpacket[44] = (unsigned char)((network_number & 0x00FF0000) >> 16);
2556                 sendpacket[45] = (unsigned char)((network_number & 0x0000FF00) >> 8);
2557                 sendpacket[46] = (unsigned char)(network_number & 0x000000FF);
2558
2559                 return 1;
2560         }
2561
2562         /* If we get here, it's an IPX-data packet so it'll get passed up the 
2563          * stack.
2564          * switch the network numbers 
2565          */
2566         switch_net_numbers(sendpacket, network_number ,1);
2567         return 0;
2568 }
2569 /*============================================================================
2570  * process_route
2571  * 
2572  * Rationale:
2573  *      If the interface goes down, or we receive an ARP request,
2574  *      we have to change the network interface ip addresses.
2575  *      This cannot be done within the interrupt.
2576  *
2577  * Description:
2578  *
2579  *      This routine is called as a polling routine to dynamically 
2580  *      add/delete routes negotiated by inverse ARP.  It is in this 
2581  *      "task" because we don't want routes to be added while in 
2582  *      interrupt context.
2583  *
2584  * Usage:
2585  *      This function is called by fr_poll() polling funtion.
2586  */
2587
2588 static void process_route(struct net_device *dev)
2589 {
2590         fr_channel_t *chan = dev->priv;
2591         sdla_t *card = chan->card;
2592
2593         struct ifreq if_info;
2594         struct sockaddr_in *if_data;
2595         mm_segment_t fs = get_fs();
2596         u32 ip_tmp;
2597         int err;
2598
2599
2600         switch(chan->route_flag){
2601
2602         case ADD_ROUTE:
2603                                 
2604                 /* Set remote addresses */
2605                 memset(&if_info, 0, sizeof(if_info));
2606                 strcpy(if_info.ifr_name, dev->name);
2607
2608                 set_fs(get_ds());     /* get user space block */ 
2609                 
2610                 if_data = (struct sockaddr_in *)&if_info.ifr_dstaddr;
2611                 if_data->sin_addr.s_addr = chan->ip_remote;
2612                 if_data->sin_family = AF_INET;
2613                 err = devinet_ioctl( SIOCSIFDSTADDR, &if_info );
2614
2615                 set_fs(fs);           /* restore old block */
2616
2617                 if (err) {
2618                         printk(KERN_INFO 
2619                                 "%s: Route Add failed.  Error: %d\n", 
2620                                         card->devname,err);
2621                         printk(KERN_INFO "%s: Address: %u.%u.%u.%u\n",
2622                                 chan->name, NIPQUAD(chan->ip_remote));
2623
2624                 }else {
2625                         printk(KERN_INFO "%s: Route Added Successfully: %u.%u.%u.%u\n",
2626                                 card->devname,NIPQUAD(chan->ip_remote));
2627                         chan->route_flag = ROUTE_ADDED;
2628                 }
2629                 break;
2630
2631         case REMOVE_ROUTE:
2632
2633                 /* Set remote addresses */
2634                 memset(&if_info, 0, sizeof(if_info));
2635                 strcpy(if_info.ifr_name, dev->name);
2636
2637                 ip_tmp = get_ip_address(dev,WAN_POINTOPOINT_IP);        
2638
2639                 set_fs(get_ds());     /* get user space block */ 
2640                 
2641                 if_data = (struct sockaddr_in *)&if_info.ifr_dstaddr;
2642                 if_data->sin_addr.s_addr = 0;
2643                 if_data->sin_family = AF_INET;
2644                 err = devinet_ioctl( SIOCSIFDSTADDR, &if_info );
2645
2646                 set_fs(fs);    
2647                 
2648                 if (err) {
2649                         printk(KERN_INFO 
2650                                 "%s: Deleting of route failed.  Error: %d\n", 
2651                                         card->devname,err);
2652                         printk(KERN_INFO "%s: Address: %u.%u.%u.%u\n",
2653                                 dev->name,NIPQUAD(chan->ip_remote) );
2654
2655                 } else {
2656                         printk(KERN_INFO "%s: Route Removed Sucessfuly: %u.%u.%u.%u\n", 
2657                                 card->devname,NIPQUAD(ip_tmp));
2658                         chan->route_flag = NO_ROUTE;
2659                 }
2660                 break;
2661
2662         } /* Case Statement */
2663
2664 }
2665
2666
2667
2668 /****** Frame Relay Firmware-Specific Functions *****************************/
2669
2670 /*============================================================================
2671  * Read firmware code version.
2672  * o fill string str with firmware version info. 
2673  */
2674 static int fr_read_version (sdla_t* card, char* str)
2675 {
2676         fr_mbox_t* mbox = card->mbox;
2677         int retry = MAX_CMD_RETRY;
2678         int err;
2679
2680         do
2681         {
2682                 mbox->cmd.command = FR_READ_CODE_VERSION;
2683                 mbox->cmd.length = 0;
2684                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2685         } while (err && retry-- && fr_event(card, err, mbox));
2686         
2687         if (!err && str) {
2688                 int len = mbox->cmd.length;
2689                 memcpy(str, mbox->data, len);
2690                 str[len] = '\0';
2691         }
2692         return err;
2693 }
2694
2695 /*============================================================================
2696  * Set global configuration.
2697  */
2698 static int fr_configure (sdla_t* card, fr_conf_t *conf)
2699 {
2700         fr_mbox_t* mbox = card->mbox;
2701         int retry = MAX_CMD_RETRY;
2702         int dlci_num = card->u.f.dlci_num;
2703         int err, i;
2704
2705         do
2706         {
2707                 memcpy(mbox->data, conf, sizeof(fr_conf_t));
2708
2709                 if (dlci_num) for (i = 0; i < dlci_num; ++i)
2710                         ((fr_conf_t*)mbox->data)->dlci[i] = 
2711                                         card->u.f.node_dlci[i]; 
2712                 
2713                 mbox->cmd.command = FR_SET_CONFIG;
2714                 mbox->cmd.length =
2715                         sizeof(fr_conf_t) + dlci_num * sizeof(short);
2716
2717                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2718         
2719         } while (err && retry-- && fr_event(card, err, mbox));
2720
2721         /*NC Oct 12 2000 */
2722         if (err != CMD_OK){
2723                 printk(KERN_ERR "%s: Frame Relay Configuration Failed: rc=0x%x\n",
2724                                 card->devname,err);
2725         }
2726         
2727         return err;
2728 }
2729
2730 /*============================================================================
2731  * Set DLCI configuration.
2732  */
2733 static int fr_dlci_configure (sdla_t* card, fr_dlc_conf_t *conf, unsigned dlci)
2734 {
2735         fr_mbox_t* mbox = card->mbox;
2736         int retry = MAX_CMD_RETRY;
2737         int err;
2738
2739         do
2740         {
2741                 memcpy(mbox->data, conf, sizeof(fr_dlc_conf_t));
2742                 mbox->cmd.dlci = (unsigned short) dlci; 
2743                 mbox->cmd.command = FR_SET_CONFIG;
2744                 mbox->cmd.length = sizeof(fr_dlc_conf_t);
2745                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2746         } while (err && retry--);
2747         
2748         return err;
2749 }
2750 /*============================================================================
2751  * Set interrupt mode.
2752  */
2753 static int fr_set_intr_mode (sdla_t* card, unsigned mode, unsigned mtu,
2754         unsigned short timeout)
2755 {
2756         fr_mbox_t* mbox = card->mbox;
2757         fr508_intr_ctl_t* ictl = (void*)mbox->data;
2758         int retry = MAX_CMD_RETRY;
2759         int err;
2760
2761         do
2762         {
2763                 memset(ictl, 0, sizeof(fr508_intr_ctl_t));
2764                 ictl->mode   = mode;
2765                 ictl->tx_len = mtu;
2766                 ictl->irq    = card->hw.irq;
2767
2768                 /* indicate timeout on timer */
2769                 if (mode & 0x20) ictl->timeout = timeout; 
2770
2771                 mbox->cmd.length = sizeof(fr508_intr_ctl_t);
2772                 mbox->cmd.command = FR_SET_INTR_MODE;
2773                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2774
2775         } while (err && retry-- && fr_event(card, err, mbox));
2776         
2777         return err;
2778 }
2779
2780 /*============================================================================
2781  * Enable communications.
2782  */
2783 static int fr_comm_enable (sdla_t* card)
2784 {
2785         fr_mbox_t* mbox = card->mbox;
2786         int retry = MAX_CMD_RETRY;
2787         int err;
2788
2789         do
2790         {
2791                 mbox->cmd.command = FR_COMM_ENABLE;
2792                 mbox->cmd.length = 0;
2793                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2794         } while (err && retry-- && fr_event(card, err, mbox));
2795         
2796         return err;
2797 }
2798
2799 /*============================================================================
2800  * fr_comm_disable 
2801  *
2802  * Warning: This functin is called by the shutdown() procedure. It is void
2803  *          since dev->priv are has already been deallocated and no
2804  *          error checking is possible using fr_event() function.
2805  */
2806 static void fr_comm_disable (sdla_t* card)
2807 {
2808         fr_mbox_t* mbox = card->mbox;
2809         int retry = MAX_CMD_RETRY;
2810         int err;
2811
2812         do {
2813         mbox->cmd.command = FR_SET_MODEM_STATUS;
2814         mbox->cmd.length = 1;
2815         mbox->data[0] = 0;
2816         err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2817         } while (err && retry--);
2818         
2819         retry = MAX_CMD_RETRY;
2820         
2821         do
2822         {
2823                 mbox->cmd.command = FR_COMM_DISABLE;
2824                 mbox->cmd.length = 0;
2825                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2826         } while (err && retry--);
2827
2828         return;
2829 }
2830
2831
2832
2833 /*============================================================================
2834  * Get communications error statistics. 
2835  */
2836 static int fr_get_err_stats (sdla_t* card)
2837 {
2838         fr_mbox_t* mbox = card->mbox;
2839         int retry = MAX_CMD_RETRY;
2840         int err;
2841
2842
2843         do
2844         {
2845                 mbox->cmd.command = FR_READ_ERROR_STATS;
2846                 mbox->cmd.length = 0;
2847                 mbox->cmd.dlci = 0;
2848                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2849         } while (err && retry-- && fr_event(card, err, mbox));
2850
2851         if (!err) {
2852                 fr_comm_stat_t* stats = (void*)mbox->data;
2853                 card->wandev.stats.rx_over_errors    = stats->rx_overruns;
2854                 card->wandev.stats.rx_crc_errors     = stats->rx_bad_crc;
2855                 card->wandev.stats.rx_missed_errors  = stats->rx_aborts;
2856                 card->wandev.stats.rx_length_errors  = stats->rx_too_long;
2857                 card->wandev.stats.tx_aborted_errors = stats->tx_aborts;
2858         
2859         }
2860
2861         return err;
2862 }
2863
2864 /*============================================================================
2865  * Get statistics. 
2866  */
2867 static int fr_get_stats (sdla_t* card)
2868 {
2869         fr_mbox_t* mbox = card->mbox;
2870         int retry = MAX_CMD_RETRY;
2871         int err;
2872
2873
2874         do
2875         {
2876                 mbox->cmd.command = FR_READ_STATISTICS;
2877                 mbox->cmd.length = 0;
2878                 mbox->cmd.dlci = 0;
2879                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2880         } while (err && retry-- && fr_event(card, err, mbox));
2881
2882         if (!err) {
2883                 fr_link_stat_t* stats = (void*)mbox->data;
2884                 card->wandev.stats.rx_frame_errors = stats->rx_bad_format;
2885                 card->wandev.stats.rx_dropped =
2886                         stats->rx_dropped + stats->rx_dropped2;
2887         }
2888
2889         return err;
2890 }
2891
2892 /*============================================================================
2893  * Add DLCI(s) (Access Node only!).
2894  * This routine will perform the ADD_DLCIs command for the specified DLCI.
2895  */
2896 static int fr_add_dlci (sdla_t* card, int dlci)
2897 {
2898         fr_mbox_t* mbox = card->mbox;
2899         int retry = MAX_CMD_RETRY;
2900         int err;
2901
2902         do
2903         {
2904                 unsigned short* dlci_list = (void*)mbox->data;
2905
2906                 mbox->cmd.length  = sizeof(short);
2907                 dlci_list[0] = dlci;
2908                 mbox->cmd.command = FR_ADD_DLCI;
2909                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2910
2911         } while (err && retry-- && fr_event(card, err, mbox));
2912         
2913         return err;
2914 }
2915
2916 /*============================================================================
2917  * Activate DLCI(s) (Access Node only!). 
2918  * This routine will perform the ACTIVATE_DLCIs command with a DLCI number. 
2919  */
2920 static int fr_activate_dlci (sdla_t* card, int dlci)
2921 {
2922         fr_mbox_t* mbox = card->mbox;
2923         int retry = MAX_CMD_RETRY;
2924         int err;
2925
2926         do
2927         {
2928                 unsigned short* dlci_list = (void*)mbox->data;
2929
2930                 mbox->cmd.length  = sizeof(short);
2931                 dlci_list[0] = dlci;
2932                 mbox->cmd.command = FR_ACTIVATE_DLCI;
2933                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2934
2935         } while (err && retry-- && fr_event(card, err, mbox));
2936         
2937         return err;
2938 }
2939
2940 /*============================================================================
2941  * Delete DLCI(s) (Access Node only!). 
2942  * This routine will perform the DELETE_DLCIs command with a DLCI number. 
2943  */
2944 static int fr_delete_dlci (sdla_t* card, int dlci)
2945 {
2946         fr_mbox_t* mbox = card->mbox;
2947         int retry = MAX_CMD_RETRY;
2948         int err;
2949
2950         do
2951         {
2952                 unsigned short* dlci_list = (void*)mbox->data;
2953
2954                 mbox->cmd.length  = sizeof(short);
2955                 dlci_list[0] = dlci;
2956                 mbox->cmd.command = FR_DELETE_DLCI;
2957                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2958
2959         } while (err && retry-- && fr_event(card, err, mbox));
2960         
2961         return err;
2962 }
2963
2964
2965
2966 /*============================================================================
2967  * Issue in-channel signalling frame. 
2968  */
2969 static int fr_issue_isf (sdla_t* card, int isf)
2970 {
2971         fr_mbox_t* mbox = card->mbox;
2972         int retry = MAX_CMD_RETRY;
2973         int err;
2974
2975         do
2976         {
2977                 mbox->data[0] = isf;
2978                 mbox->cmd.length  = 1;
2979                 mbox->cmd.command = FR_ISSUE_IS_FRAME;
2980                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2981         } while (err && retry-- && fr_event(card, err, mbox));
2982         
2983         return err;
2984 }
2985
2986
2987 static unsigned int fr_send_hdr (sdla_t*card, int dlci, unsigned int offset)
2988 {
2989         struct net_device *dev = find_channel(card,dlci);       
2990         fr_channel_t *chan;
2991
2992         if (!dev || !(chan=dev->priv))
2993                 return offset;
2994         
2995         if (chan->fr_header_len){
2996                 sdla_poke(&card->hw, offset, chan->fr_header, chan->fr_header_len);
2997         }
2998         
2999         return offset+chan->fr_header_len;
3000 }
3001
3002 /*============================================================================
3003  * Send a frame on a selected DLCI.  
3004  */
3005 static int fr_send_data_header (sdla_t* card, int dlci, unsigned char attr, int len,
3006         void *buf, unsigned char hdr_len)
3007 {
3008         fr_mbox_t* mbox = card->mbox + 0x800;
3009         int retry = MAX_CMD_RETRY;
3010         int err;
3011
3012         do
3013         {
3014                 mbox->cmd.dlci    = dlci;
3015                 mbox->cmd.attr    = attr;
3016                 mbox->cmd.length  = len+hdr_len;
3017                 mbox->cmd.command = FR_WRITE;
3018                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3019         } while (err && retry-- && fr_event(card, err, mbox));
3020
3021         if (!err) {
3022                 fr_tx_buf_ctl_t* frbuf;
3023  
3024                 if(card->hw.type == SDLA_S514)
3025                         frbuf = (void*)(*(unsigned long*)mbox->data +
3026                                 card->hw.dpmbase);
3027                 else
3028                         frbuf = (void*)(*(unsigned long*)mbox->data -
3029                                 FR_MB_VECTOR + card->hw.dpmbase);
3030
3031                 sdla_poke(&card->hw, fr_send_hdr(card,dlci,frbuf->offset), buf, len);
3032                 frbuf->flag = 0x01;
3033         }
3034
3035         return err;
3036 }
3037
3038 static int fr_send (sdla_t* card, int dlci, unsigned char attr, int len,
3039         void *buf)
3040 {
3041         fr_mbox_t* mbox = card->mbox + 0x800;
3042         int retry = MAX_CMD_RETRY;
3043         int err;
3044
3045         do
3046         {
3047                 mbox->cmd.dlci    = dlci;
3048                 mbox->cmd.attr    = attr;
3049                 mbox->cmd.length  = len;
3050                 mbox->cmd.command = FR_WRITE;
3051                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3052         } while (err && retry-- && fr_event(card, err, mbox));
3053
3054         if (!err) {
3055                 fr_tx_buf_ctl_t* frbuf;
3056  
3057                 if(card->hw.type == SDLA_S514)
3058                         frbuf = (void*)(*(unsigned long*)mbox->data +
3059                                 card->hw.dpmbase);
3060                 else
3061                         frbuf = (void*)(*(unsigned long*)mbox->data -
3062                                 FR_MB_VECTOR + card->hw.dpmbase);
3063
3064                 sdla_poke(&card->hw, frbuf->offset, buf, len);
3065                 frbuf->flag = 0x01;
3066         }
3067
3068         return err;
3069 }
3070
3071
3072 /****** Firmware Asynchronous Event Handlers ********************************/
3073
3074 /*============================================================================
3075  * Main asyncronous event/error handler.
3076  *      This routine is called whenever firmware command returns non-zero
3077  *      return code.
3078  *
3079  * Return zero if previous command has to be cancelled.
3080  */
3081 static int fr_event (sdla_t *card, int event, fr_mbox_t* mbox)
3082 {
3083         fr508_flags_t* flags = card->flags;
3084         char *ptr = &flags->iflag;
3085         int i;
3086
3087         switch (event) {
3088
3089                 case FRRES_MODEM_FAILURE:
3090                         return fr_modem_failure(card, mbox);
3091
3092                 case FRRES_CHANNEL_DOWN: {
3093                         struct net_device *dev;
3094
3095                         /* Remove all routes from associated DLCI's */
3096                         for (dev = card->wandev.dev; dev;
3097                              dev = *((struct net_device **)dev->priv)) {
3098                                 fr_channel_t *chan = dev->priv;
3099                                 if (chan->route_flag == ROUTE_ADDED) {
3100                                         chan->route_flag = REMOVE_ROUTE;
3101                                 }
3102
3103                                 if (chan->inarp == INARP_CONFIGURED) {
3104                                         chan->inarp = INARP_REQUEST;
3105                                 }
3106
3107                                 /* If the link becomes disconnected then,
3108                                  * all channels will be disconnected
3109                                  * as well.
3110                                  */
3111                                 set_chan_state(dev,WAN_DISCONNECTED);
3112                         }
3113                                 
3114                         wanpipe_set_state(card, WAN_DISCONNECTED);
3115                         return 1;
3116                         }
3117
3118                 case FRRES_CHANNEL_UP: {
3119                         struct net_device *dev;
3120
3121                         /* FIXME: Only startup devices that are on the list */
3122                         
3123                         for (dev = card->wandev.dev; dev;
3124                              dev = *((struct net_device **)dev->priv)) {
3125                                 
3126                                 set_chan_state(dev,WAN_CONNECTED);
3127                         }
3128
3129                         wanpipe_set_state(card, WAN_CONNECTED);
3130                         return 1;
3131                         }
3132
3133                 case FRRES_DLCI_CHANGE:
3134                         return fr_dlci_change(card, mbox);
3135
3136                 case FRRES_DLCI_MISMATCH:
3137                         printk(KERN_INFO "%s: DLCI list mismatch!\n", 
3138                                 card->devname);
3139                         return 1;
3140
3141                 case CMD_TIMEOUT:
3142                         printk(KERN_ERR "%s: command 0x%02X timed out!\n",
3143                                 card->devname, mbox->cmd.command);
3144                         printk(KERN_INFO "%s: ID Bytes = ",card->devname);
3145                         for(i = 0; i < 8; i ++)
3146                                 printk(KERN_INFO "0x%02X ", *(ptr + 0x18 + i));
3147                         printk(KERN_INFO "\n"); 
3148             
3149                         break;
3150
3151                 case FRRES_DLCI_INACTIVE:
3152                         break;
3153  
3154                 case FRRES_CIR_OVERFLOW:
3155                         break;
3156                         
3157                 case FRRES_BUFFER_OVERFLOW:
3158                         break; 
3159                         
3160                 default:
3161                         printk(KERN_INFO "%s: command 0x%02X returned 0x%02X!\n"
3162                                 , card->devname, mbox->cmd.command, event);
3163         }
3164
3165         return 0;
3166 }
3167
3168 /*============================================================================