sdla_fr.c

Go to the documentation of this file.

/*****************************************************************************
* sdla_fr.c     WANPIPE(tm) Multiprotocol WAN Link Driver. Frame relay module.
*
* Author(s):    Nenad Corbic  <ncorbic@sangoma.com>
*               Gideon Hack
*
* Copyright:    (c) 1995-1999 Sangoma Technologies Inc.
*
*               This program is free software; you can redistribute it and/or
*               modify it under the terms of the GNU General Public License
*               as published by the Free Software Foundation; either version
*               2 of the License, or (at your option) any later version.
* ============================================================================
* Nov 08, 1999  Nenad Corbic    o Combined all debug UDP calls into one function
*                               o Removed the ARP support. This has to be done
*                                 in the next version.
*                               o Only a Node can implement NO signalling.
*                                 Initialize DLCI during if_open() if NO 
*                                 signalling.
*                               o Took out IPX support, implement in next
*                                 version
* Sep 29, 1999  Nenad Corbic    o Added SMP support and changed the update
*                                 function to use timer interrupt.
*                               o Fixed the CIR bug:  Set the value of BC
*                                 to CIR when the CIR is enabled.
*                               o Updated comments, statistics and tracing.
* Jun 02, 1999  Gideon Hack     o Updated for S514 support.
* Sep 18, 1998  Jaspreet Singh  o Updated for 2.2.X kernels.
* Jul 31, 1998  Jaspreet Singh  o Removed wpf_poll routine.  The channel/DLCI 
*                                 status is received through an event interrupt.
* Jul 08, 1998  David Fong      o Added inverse ARP support.
* Mar 26, 1997  Jaspreet Singh  o Returning return codes for failed UDP cmds.
* Jan 28, 1997  Jaspreet Singh  o Improved handling of inactive DLCIs.
* Dec 30, 1997  Jaspreet Singh  o Replaced dev_tint() with mark_bh(NET_BH)
* Dec 16, 1997  Jaspreet Singh  o Implemented Multiple IPX support.
* Nov 26, 1997  Jaspreet Singh  o Improved load sharing with multiple boards
*                               o Added Cli() to protect enabling of interrupts
*                                 while polling is called.
* Nov 24, 1997  Jaspreet Singh  o Added counters to avoid enabling of interrupts
*                                 when they have been disabled by another
*                                 interface or routine (eg. wpf_poll).
* Nov 06, 1997  Jaspreet Singh  o Added INTR_TEST_MODE to avoid polling 
*                                 routine disable interrupts during interrupt
*                                 testing.
* Oct 20, 1997  Jaspreet Singh  o Added hooks in for Router UP time.
* Oct 16, 1997  Jaspreet Singh  o The critical flag is used to maintain flow
*                                 control by avoiding RACE conditions.  The
*                                 cli() and restore_flags() are taken out.
*                                 The fr_channel structure is appended for 
*                                 Driver Statistics.
* Oct 15, 1997  Farhan Thawar    o updated if_send() and receive for IPX
* Aug 29, 1997  Farhan Thawar    o Removed most of the cli() and sti()
*                                o Abstracted the UDP management stuff
*                                o Now use tbusy and critical more intelligently
* Jul 21, 1997  Jaspreet Singh   o Can configure T391, T392, N391, N392 & N393
*                                  through router.conf.
*                                o Protected calls to sdla_peek() by adDing 
*                                  save_flags(), cli() and restore_flags().
*                                o Added error message for Inactive DLCIs in
*                                  fr_event() and update_chan_state().
*                                o Fixed freeing up of buffers using kfree() 
*                                  when packets are received.
* Jul 07, 1997  Jaspreet Singh   o Added configurable TTL for UDP packets 
*                                o Added ability to discard multicast and 
*                                  broadcast source addressed packets
* Jun 27, 1997  Jaspreet Singh   o Added FT1 monitor capabilities 
*                                  New case (0x44) statement in if_send routine 
*                                  Added a global variable rCount to keep track
*                                  of FT1 status enabled on the board.
* May 29, 1997  Jaspreet Singh   o Fixed major Flow Control Problem
*                                  With multiple boards a problem was seen where
*                                  the second board always stopped transmitting
*                                  packet after running for a while. The code
*                                  got into a stage where the interrupts were
*                                  disabled and dev->tbusy was set to 1.
*                                  This caused the If_send() routine to get into
*                                  the if clause for it(0,dev->tbusy) 
*                                  forever.
*                                  The code got into this stage due to an 
*                                  interrupt occurring within the if clause for 
*                                  set_bit(0,dev->tbusy).  Since an interrupt 
*                                  disables furhter transmit interrupt and 
*                                  makes dev->tbusy = 0, this effect was undone 
*                                  by making dev->tbusy = 1 in the if clause.
*                                  The Fix checks to see if Transmit interrupts
*                                  are disabled then do not make dev->tbusy = 1
*                                  Introduced a global variable: int_occur and
*                                  added tx_int_enabled in the wan_device 
*                                  structure.   
* May 21, 1997  Jaspreet Singh   o Fixed UDP Management for multiple
*                                  boards.
*
* Apr 25, 1997  Farhan Thawar    o added UDP Management stuff
*                                o fixed bug in if_send() and tx_intr() to
*                                  sleep and wakeup all devices
* Mar 11, 1997  Farhan Thawar   Version 3.1.1
*                                o fixed (+1) bug in fr508_rx_intr()
*                                o changed if_send() to return 0 if
*                                  wandev.critical() is true
*                                o free socket buffer in if_send() if
*                                  returning 0 
*                                o added tx_intr() routine
* Jan 30, 1997  Gene Kozin      Version 3.1.0
*                                o implemented exec() entry point
*                                o fixed a bug causing driver configured as
*                                  a FR switch to be stuck in WAN_
*                                  mode
* Jan 02, 1997  Gene Kozin      Initial version.
*****************************************************************************/

#include <linux/version.h>
#include <linux/kernel.h>       /* printk(), and other useful stuff */
#include <linux/stddef.h>       /* offsetof(), etc. */
#include <linux/errno.h>        /* return codes */
#include <linux/string.h>       /* inline memset(), etc. */
#include <linux/malloc.h>       /* kmalloc(), kfree() */
#include <linux/wanrouter.h>    /* WAN router definitions */
#include <linux/wanpipe.h>      /* WANPIPE common user API definitions */
#include <linux/if_arp.h>       /* ARPHRD_* defines */
#include <asm/byteorder.h>      /* htons(), etc. */
#include <asm/io.h>             /* for inb(), outb(), etc. */
#include <linux/time.h>         /* for do_gettimeofday */       
#include <linux/in.h>           /* sockaddr_in */
#include <linux/inet.h>         /* in_ntoa(), etc... */
#include <asm/uaccess.h>
#include <linux/inetdevice.h>
#include <linux/ip.h>
#include <net/route.h>          /* Dynamic Route Creation */
#include <linux/if.h>

#include <linux/sdla_fr.h>      /* frame relay firmware API definitions */
#if LINUX_VERSION_CODE < 0x020125
#define test_and_set_bit set_bit
#endif
 
/****** Defines & Macros ****************************************************/

#define MAX_CMD_RETRY   10              /* max number of firmware retries */

#define FR_HEADER_LEN   8               /* max encapsulation header size */
#define FR_CHANNEL_MTU  1500            /* unfragmented logical channel MTU */

/* Q.922 frame types */
#define Q922_UI         0x03            /* Unnumbered Info frame */
#define Q922_XID        0xAF            

/* DLCI configured or not */
#define DLCI_NOT_CONFIGURED     0x00
#define DLCI_CONFIG_PENDING     0x01
#define DLCI_CONFIGURED         0x02

/* CIR enabled or not */
#define CIR_ENABLED     0x00
#define CIR_DISABLED    0x01

#define WANPIPE 0x00
#define API     0x01
#define FRAME_RELAY_API 1

/* For handle_IPXWAN() */
#define CVHexToAscii(b) (((unsigned char)(b) > (unsigned char)9) ? ((unsigned char)'A' + ((unsigned char)(b) - (unsigned char)10)) : ((unsigned char)'0' + (unsigned char)(b)))
 
/****** Data Structures *****************************************************/

/* This is an extention of the 'struct device' we create for each network
 * interface to keep the rest of channel-specific data.
 */
typedef struct fr_channel
{
        char name[WAN_IFNAME_SZ+1];     /* interface name, ASCIIZ */
        unsigned dlci_configured  ;     /* check whether configured or not */
        unsigned cir_status;            /* check whether CIR enabled or not */
        unsigned dlci;                  /* logical channel number */
        unsigned cir;                   /* committed information rate */
        unsigned bc;                    /* committed burst size */
        unsigned be;                    /* excess burst size */
        unsigned mc;                    /* multicast support on or off */
        unsigned tx_int_status;         /* Transmit Interrupt Status */ 
        unsigned short pkt_length;      /* Packet Length */
        unsigned long router_start_time;/* Router start time in seconds */
        unsigned long tick_counter;     /* counter for transmit time out */
        char dev_pending_devtint;       /* interface pending dev_tint() */
        char state;                     /* channel state */
        void *dlci_int_interface;       /* pointer to the DLCI Interface */ 
        unsigned long IB_addr;          /* physical address of Interface Byte */
        unsigned long state_tick;       /* time of the last state change */
        unsigned char enable_IPX;       /* Enable/Disable the use of IPX */
        unsigned long network_number;   /* Internal Network Number for IPX*/
        sdla_t *card;                   /* -> owner */
        unsigned route_flag;            /* Add/Rem dest addr in route tables */
        unsigned inarp;                 /* Inverse Arp Request status */ 
        int inarp_interval;             /* Time between InArp Requests */
        unsigned long inarp_tick;       /* InArp jiffies tick counter */
        struct net_device_stats ifstats;        /* interface statistics */
        if_send_stat_t drvstats_if_send;
        rx_intr_stat_t drvstats_rx_intr;
        pipe_mgmt_stat_t drvstats_gen;

        unsigned char usedby;  /* Used by WANPIPE or API */

        unsigned long router_up_time;

        unsigned short transmit_length;
        char transmit_buffer[FR_MAX_NO_DATA_BYTES_IN_FRAME];
} fr_channel_t;

/* Route Flag options */
#define NO_ROUTE        0x00
#define ADD_ROUTE       0x01
#define ROUTE_ADDED     0x02
#define REMOVE_ROUTE    0x03

/* inarp options */
#define INARP_NONE              0x00
#define INARP_REQUEST           0x01
#define INARP_CONFIGURED        0x02

/* reasons for enabling the timer interrupt on the adapter */
#define TMR_INT_ENABLED_UDP     0x01
#define TMR_INT_ENABLED_UPDATE  0x02


typedef struct dlci_status
{
        unsigned short dlci     PACKED;
        unsigned char state     PACKED;
} dlci_status_t;

typedef struct dlci_IB_mapping
{
        unsigned short dlci             PACKED;
        unsigned long  addr_value       PACKED;
} dlci_IB_mapping_t;

/* This structure is used for DLCI list Tx interrupt mode.  It is used to
   enable interrupt bit and set the packet length for transmission
 */
typedef struct fr_dlci_interface 
{
        unsigned char gen_interrupt     PACKED;
        unsigned short packet_length    PACKED;
        unsigned char reserved          PACKED;
} fr_dlci_interface_t; 

/* variable for keeping track of enabling/disabling FT1 monitor status */
static int rCount = 0;

extern int ip_rt_ioctl(unsigned int, void *);
extern void disable_irq(unsigned int);
extern void enable_irq(unsigned int);

/* variable for keeping track of number of interrupts generated during 
 * interrupt test routine 
 */
static int Intr_test_counter;
/****** Function Prototypes *************************************************/

/* WAN link driver entry points. These are called by the WAN router module. */
static int update(wan_device_t *wandev);
static int new_if(wan_device_t *wandev, struct device *dev, wanif_conf_t *conf);
static int del_if(wan_device_t *wandev, struct device *dev);

/* WANPIPE-specific entry points */
static int wpf_exec(struct sdla *card, void *u_cmd, void *u_data);

/* Network device interface */
static int if_init(struct device *dev);
static int if_open(struct device *dev);
static int if_close(struct device *dev);
static int if_header(struct sk_buff *skb, struct device *dev, unsigned short type, void *daddr, void *saddr, unsigned len);
static int if_rebuild_hdr(struct sk_buff *skb);
static int if_send(struct sk_buff *skb, struct device *dev);
static int chk_bcast_mcast_addr(sdla_t *card, struct device* dev,
                                struct sk_buff *skb);
static struct net_device_stats *if_stats(struct device *dev);

/* Interrupt handlers */
static void fr_isr(sdla_t *card);
static void rx_intr(sdla_t *card);
static void tx_intr(sdla_t *card);
static void timer_intr(sdla_t *card);
static void spur_intr(sdla_t *card);

/* Frame relay firmware interface functions */
static int fr_read_version(sdla_t *card, char *str);
static int fr_configure(sdla_t *card, fr_conf_t *conf);
static int fr_dlci_configure(sdla_t *card, fr_dlc_conf_t *conf, unsigned dlci);
static int fr_init_dlci (sdla_t *card, fr_channel_t *chan);
static int fr_set_intr_mode (sdla_t *card, unsigned mode, unsigned mtu, unsigned short timeout);
static int fr_comm_enable(sdla_t *card);
static int fr_comm_disable(sdla_t *card);
static int fr_get_err_stats(sdla_t *card);
static int fr_get_stats(sdla_t *card);
static int fr_add_dlci(sdla_t *card, int dlci);
static int fr_activate_dlci(sdla_t *card, int dlci);
static int fr_delete_dlci (sdla_t* card, int dlci);
static int fr_issue_isf(sdla_t *card, int isf);
static int fr_send(sdla_t *card, int dlci, unsigned char attr, int len,
        void *buf);

/* Firmware asynchronous event handlers */
static int fr_event(sdla_t *card, int event, fr_mbox_t *mbox);
static int fr_modem_failure(sdla_t *card, fr_mbox_t *mbox);
static int fr_dlci_change(sdla_t *card, fr_mbox_t *mbox);

/* Miscellaneous functions */
static int update_chan_state(struct device *dev);
static void set_chan_state(struct device *dev, int state);
static struct device *find_channel(sdla_t *card, unsigned dlci);
static int is_tx_ready(sdla_t *card, fr_channel_t *chan);
static unsigned int dec_to_uint(unsigned char *str, int len);
static int reply_udp( unsigned char *data, unsigned int mbox_len );

static int intr_test( sdla_t* card );
static void init_chan_statistics( fr_channel_t* chan );
static void init_global_statistics( sdla_t* card );
static void read_DLCI_IB_mapping( sdla_t* card, fr_channel_t* chan );
static void setup_for_delayed_transmit(struct device* dev, void* buf,
        unsigned len);


/* Inverse ARP and Dynamic routing functions */
int process_ARP(arphdr_1490_t *ArpPacket, sdla_t *card, struct device *dev);
int is_arp(void *buf);
int send_inarp_request(sdla_t *card, struct device *dev);

/* Udp management functions */
static int process_udp_mgmt_pkt(sdla_t *card);
static int udp_pkt_type( struct sk_buff *skb, sdla_t *card );
static int store_udp_mgmt_pkt(int udp_type, char udp_pkt_src, sdla_t* card,
                                struct sk_buff *skb, int dlci);

/* IPX functions */
static void switch_net_numbers(unsigned char *sendpacket,
        unsigned long network_number, unsigned char incoming);

static int handle_IPXWAN(unsigned char *sendpacket, char *devname,
        unsigned char enable_IPX, unsigned long network_number);

/* Lock Functions: SMP supported */
void    s508_s514_unlock(sdla_t *card, unsigned long *smp_flags);
void    s508_s514_lock(sdla_t *card, unsigned long *smp_flags);

unsigned short calc_checksum (char *, int);


/****** Public Functions ****************************************************/

/*============================================================================
 * Frame relay protocol initialization routine.
 *
 * This routine is called by the main WANPIPE module during setup.  At this
 * point adapter is completely initialized and firmware is running.
 *  o read firmware version (to make sure it's alive)
 *  o configure adapter
 *  o initialize protocol-specific fields of the adapter data space.
 *
 * Return:      0       o.k.
 *              < 0     failure.
 */
int wpf_init(sdla_t *card, wandev_conf_t *conf)
{

        int err;

        union
        {
                char str[80];
                fr_conf_t cfg;
        } u;
        fr_buf_info_t* buf_info;
        int i;

        /* Verify configuration ID */
        if (conf->config_id != WANCONFIG_FR) {
                
                printk(KERN_INFO "%s: invalid configuration ID %u!\n",
                        card->devname, conf->config_id);
                return -EINVAL;
        
        }

        /* Initialize protocol-specific fields of adapter data space */
        switch (card->hw.fwid) {
        
                case SFID_FR508:
                        card->mbox  = (void*)(card->hw.dpmbase + 
                                        FR508_MBOX_OFFS);
                        card->flags = (void*)(card->hw.dpmbase + 
                                        FR508_FLAG_OFFS);
                        if(card->hw.type == SDLA_S514) {
                                card->mbox += FR_MB_VECTOR;
                                card->flags += FR_MB_VECTOR;
                        }
                        card->isr = &fr_isr;
                        break;

                default:
                        return -EINVAL;
        }

        /* Read firmware version.  Note that when adapter initializes, it
         * clears the mailbox, so it may appear that the first command was
         * executed successfully when in fact it was merely erased. To work
         * around this, we execute the first command twice.
         */

        if (fr_read_version(card, NULL) || fr_read_version(card, u.str))
                return -EIO;

        printk(KERN_INFO "%s: running frame relay firmware v%s\n",
                card->devname, u.str);

        /* Adjust configuration */
        conf->mtu += FR_HEADER_LEN;
        conf->mtu = (conf->mtu >= MIN_LGTH_FR_DATA_CFG) ?
                        min(conf->mtu, FR_MAX_NO_DATA_BYTES_IN_FRAME) :
                        FR_CHANNEL_MTU + FR_HEADER_LEN;
     
        conf->bps = min(conf->bps, 2048000);

        /* Initialze the configuration structure sent to the board to zero */
        memset(&u.cfg, 0, sizeof(u.cfg));

        memset(card->u.f.dlci_to_dev_map, 0, sizeof(card->u.f.dlci_to_dev_map));
        
        /* Configure adapter firmware */
        
        u.cfg.mtu       = conf->mtu;
        u.cfg.kbps      = conf->bps / 1000;

        u.cfg.cir_fwd = u.cfg.cir_bwd = 16;
        u.cfg.bc_fwd  = u.cfg.bc_bwd = 16;
        
        u.cfg.options   = 0x0000;
        printk(KERN_INFO "%s: Global CIR enabled by Default\n", card->devname);
        
        switch (conf->u.fr.signalling) {

                case WANOPT_FR_ANSI:
                        u.cfg.options = 0x0000; 
                        break;          
        
                case WANOPT_FR_Q933:    
                        u.cfg.options |= 0x0200; 
                        break;
        
                case WANOPT_FR_LMI:     
                        u.cfg.options |= 0x0400; 
                        break;

                case WANOPT_NO:
                        u.cfg.options |= 0x0800; 
                        break;
                default:
                        printk(KERN_INFO "%s: Illegal Signalling option\n",
                                        card->wandev.name);
                        return -EINVAL;
        }


        card->wandev.signalling = conf->u.fr.signalling;

        if (conf->station == WANOPT_CPE) {


                if (conf->u.fr.signalling == WANOPT_NO){
                        printk(KERN_INFO 
                                "%s: ERROR - For NO signalling, station must be set to Node!",
                                         card->devname);
                        return -EINVAL;
                }

                u.cfg.station = 0;
                u.cfg.options |= 0x8000;        /* auto config DLCI */
                card->u.f.dlci_num  = 0;
        
        } else {

                u.cfg.station = 1;      /* switch emulation mode */

                /* For switch emulation we have to create a list of dlci(s)
                 * that will be sent to be global SET_DLCI_CONFIGURATION 
                 * command in fr_configure() routine. 
                 */

                card->u.f.dlci_num  = min(max(conf->u.fr.dlci_num, 1), 100);
        
                for ( i = 0; i < card->u.f.dlci_num; i++) {

                        card->u.f.node_dlci[i] = (unsigned short) 
                                conf->u.fr.dlci[i] ? conf->u.fr.dlci[i] : 16;
        
                }
        }

        if (conf->clocking == WANOPT_INTERNAL)
                u.cfg.port |= 0x0001;

        if (conf->interface == WANOPT_RS232)
                u.cfg.port |= 0x0002;

        if (conf->u.fr.t391)
                u.cfg.t391 = min(conf->u.fr.t391, 30);
        else
                u.cfg.t391 = 5;

        if (conf->u.fr.t392)
                u.cfg.t392 = min(conf->u.fr.t392, 30);
        else
                u.cfg.t392 = 15;

        if (conf->u.fr.n391)
                u.cfg.n391 = min(conf->u.fr.n391, 255);
        else
                u.cfg.n391 = 2;

        if (conf->u.fr.n392)
                u.cfg.n392 = min(conf->u.fr.n392, 10);
        else
                u.cfg.n392 = 3; 

        if (conf->u.fr.n393)
                u.cfg.n393 = min(conf->u.fr.n393, 10);
        else
                u.cfg.n393 = 4;

        if (fr_configure(card, &u.cfg))
                return -EIO;

        if (card->hw.type == SDLA_S514) {
        
                buf_info = (void*)(card->hw.dpmbase + FR_MB_VECTOR +
                        FR508_RXBC_OFFS);

                card->rxmb = (void*)(buf_info->rse_next + card->hw.dpmbase);

                card->u.f.rxmb_base =
                        (void*)(buf_info->rse_base + card->hw.dpmbase); 

                card->u.f.rxmb_last =
                        (void*)(buf_info->rse_base +
                        (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) +
                        card->hw.dpmbase);
        }

        else {  
                buf_info = (void*)(card->hw.dpmbase + FR508_RXBC_OFFS);

                card->rxmb = (void*)(buf_info->rse_next -
                        FR_MB_VECTOR + card->hw.dpmbase);
                
                card->u.f.rxmb_base =
                        (void*)(buf_info->rse_base -
                        FR_MB_VECTOR + card->hw.dpmbase);
                
                card->u.f.rxmb_last =
                        (void*)(buf_info->rse_base +
                        (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) -
                        FR_MB_VECTOR + card->hw.dpmbase);
        }

        card->u.f.rx_base = buf_info->buf_base;
        card->u.f.rx_top  = buf_info->buf_top;

        card->u.f.tx_interrupts_pending = 0;

        card->wandev.mtu        = conf->mtu;
        card->wandev.bps        = conf->bps;
        card->wandev.interface  = conf->interface;
        card->wandev.clocking   = conf->clocking;
        card->wandev.station    = conf->station;
        card->poll              = NULL; 
        card->exec              = &wpf_exec;
        card->wandev.update     = &update;
        card->wandev.new_if     = &new_if;
        card->wandev.del_if     = &del_if;
        card->wandev.state      = WAN_DISCONNECTED;
        card->wandev.ttl        = conf->ttl;
        card->wandev.udp_port   = conf->udp_port;       

        /* Intialize global statistics for a card */
        init_global_statistics( card );

        card->TracingEnabled          = 0;

        /* Interrupt Test */
        Intr_test_counter = 0;
        card->intr_mode = INTR_TEST_MODE;
        err = intr_test( card );

        if (err || (Intr_test_counter < MAX_INTR_TEST_COUNTER)) {
                printk( 
                        "%s: Interrupt Test Failed, Counter: %i\n", 
                        card->devname, Intr_test_counter);
                printk( "Please choose another interrupt\n");
                err = -EIO;
                return err;
        }

        printk(KERN_INFO "%s: Interrupt Test Passed, Counter: %i\n",
                        card->devname, Intr_test_counter);


        return 0;
}

/******* WAN Device Driver Entry Points *************************************/

/*============================================================================
 * Update device status & statistics.
 */
static int update (wan_device_t* wandev)
{
        volatile sdla_t* card;
        unsigned long timeout;
        fr508_flags_t* flags;

        /* sanity checks */
        if ((wandev == NULL) || (wandev->private == NULL))
                return -EFAULT;

        if (wandev->state == WAN_UNCONFIGURED)
                return -ENODEV;

        if (test_bit(1, (void*)&wandev->critical))
                return -EAGAIN;

        card = wandev->private;
        flags = card->flags;


        card->u.f.update_comms_stats = 1;
        card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UPDATE;
        flags->imask |= FR_INTR_TIMER;
        timeout = jiffies;
        for(;;) {
                if(card->u.f.update_comms_stats == 0)
                        break;
                if ((jiffies - timeout) > (1 * HZ)){
                        card->u.f.update_comms_stats = 0;
                        return -EAGAIN;
                }
        }
        return 0;
}

/*============================================================================
 * Create new logical channel.
 * This routine is called by the router when ROUTER_IFNEW IOCTL is being
 * handled.
 * o parse media- and hardware-specific configuration
 * o make sure that a new channel can be created
 * o allocate resources, if necessary
 * o prepare network device structure for registaration.
 *
 * Return:      0       o.k.
 *              < 0     failure (channel will not be created)
 */
static int new_if (wan_device_t* wandev, struct device* dev, wanif_conf_t* conf)
{
        sdla_t* card = wandev->private;
        fr_channel_t* chan;
        int dlci = 0;
        int err = 0;
        
        if ((conf->name[0] == '\0') || (strlen(conf->name) > WAN_IFNAME_SZ)) {
                
                printk(KERN_INFO "%s: invalid interface name!\n",
                        card->devname);
                return -EINVAL;
        }

        /* allocate and initialize private data */
        chan = kmalloc(sizeof(fr_channel_t), GFP_KERNEL);

        if (chan == NULL)
                return -ENOMEM;

        memset(chan, 0, sizeof(fr_channel_t));
        strcpy(chan->name, conf->name);
        chan->card = card;
 
        /* verify media address */
        if (is_digit(conf->addr[0])) {

                dlci = dec_to_uint(conf->addr, 0);

                if (dlci && (dlci <= HIGHEST_VALID_DLCI)) {
                
                        chan->dlci = dlci;
                
                } else {
                
                        printk(KERN_ERR
                                "%s: invalid DLCI %u on interface %s!\n",
                                wandev->name, dlci, chan->name);
                        err = -EINVAL;
                }

        } else {
                printk(KERN_ERR
                        "%s: invalid media address on interface %s!\n",
                        wandev->name, chan->name);
                err = -EINVAL;
        }

        /* Setup wanpipe as a router (WANPIPE) or as an API */
        if(strcmp(conf->usedby, "WANPIPE") == 0){
                printk(KERN_INFO "%s: Running in WANPIPE mode %s\n",
                        wandev->name, chan->name);
                chan->usedby = WANPIPE;

        } else if(strcmp(conf->usedby, "API") == 0){

#ifdef FRAME_RELAY_API
                chan->usedby = API;
                printk(KERN_INFO "%s: Running in API mode %s\n",
                        wandev->name, chan->name);
#else
                printk(KERN_INFO "%s: API Mode is not supported !\n",
                        wandev->name);
                printk(KERN_INFO
                        "%s: API patch can be obtained from Sangoma Tech.\n",
                                wandev->name);
                err = -EINVAL;
#endif
        }

        if (err) {
                
                kfree(chan);
                return err;
        }

        card->u.f.dlci_to_dev_map[dlci] = dev;
 
        /* place cir,be,bc and other channel specific information into the
         * chan structure 
         */
        if (conf->cir) {

                chan->cir = max( 1, min( conf->cir, 512 ) );
                chan->cir_status = CIR_ENABLED; 

                
                /* If CIR is enabled, force BC to equal CIR
                 * this solves number of potential problems if CIR is 
                 * set and BC is not 
                 */
                chan->bc = chan->cir;

                if (conf->be){
                        chan->be = max( 0, min( conf->be, 511) ); 
                }else{  
                        conf->be = 0;
                }

                printk (KERN_INFO "%s: CIR enabled for DLCI %i \n",
                                wandev->name,chan->dlci);
                printk (KERN_INFO "%s:     CIR = %i ; BC = %i ; BE = %i\n",
                                wandev->name,chan->cir,chan->bc,chan->be);


        }else{
                chan->cir_status = CIR_DISABLED;
                printk (KERN_INFO "%s: CIR disabled for DLCI %i\n",
                                wandev->name,chan->dlci);
        }

        chan->mc = conf->mc;

        /* FIXME: ARP is not supported by this frame relay verson */
        if (conf->inarp == WANOPT_YES){
                printk(KERN_INFO "%s: ERROR - This version of WANPIPE doesn't support ARPs\n",
                                card->devname);
        
                //chan->inarp = conf->inarp ? INARP_REQUEST : INARP_NONE;
                //chan->inarp_interval = conf->inarp_interval ? conf->inarp_interval : 10;
                kfree(chan);
                return -EINVAL;
        }else{
                chan->inarp = INARP_NONE;
                chan->inarp_interval = 10;
        }

        chan->dlci_configured = DLCI_NOT_CONFIGURED;    


        /*FIXME: IPX disabled in this WANPIPE version */
        if (conf->enable_IPX == WANOPT_YES){
                printk(KERN_INFO "%s: ERROR - This version of WANPIPE doesn't support IPX\n",
                                card->devname);
                kfree(chan);
                return -EINVAL;
        }else{
                chan->enable_IPX = WANOPT_NO;
        }       

        if (conf->network_number){
                chan->network_number = conf->network_number;
        }else{
                chan->network_number = 0xDEADBEEF;
        }

        chan->route_flag = NO_ROUTE;
        
        init_chan_statistics(chan);

        chan->transmit_length = 0;

        /* prepare network device data space for registration */
        dev->name = chan->name;
        dev->init = &if_init;
        dev->priv = chan;


        /* Enable Interrupts and Communications */
        if (!wandev->new_if_cnt){
                fr508_flags_t* flags = card->flags;

                wandev->new_if_cnt++;

                /* 
                If you enable comms and then set ints, you get a Tx int as you
                perform the SET_INT_TRIGGERS command. So, we only set int
                triggers and then adjust the interrupt mask (to disable Tx ints)
                before enabling comms. 
                */      
                if (fr_set_intr_mode(card, (FR_INTR_RXRDY | FR_INTR_TXRDY |
                        FR_INTR_DLC | FR_INTR_TIMER | FR_INTR_TX_MULT_DLCIs) ,
                        card->wandev.mtu, 0)) {
                        kfree(chan);
                        return -EIO;
                }

                flags->imask &= ~(FR_INTR_TXRDY | FR_INTR_TIMER);
 
                if (fr_comm_enable(card)) {
                        kfree(chan);
                        return -EIO;
                }       
                wanpipe_set_state(card, WAN_CONNECTED);
        }

        return 0;
}

/*============================================================================
 * Delete logical channel.
 */
static int del_if (wan_device_t* wandev, struct device* dev)
{
        sdla_t *card = wandev->private;

        /* Execute shutdown very first time we enter del_if */

        if (!wandev->del_if_cnt) {
                wandev->del_if_cnt++;
                wanpipe_set_state(card, WAN_DISCONNECTED);
                fr_set_intr_mode(card, 0, 0, 0);
                fr_comm_disable(card);
        }

        if (dev->priv) {
                kfree(dev->priv);
                dev->priv = NULL;
        }

        return 0;
}

/****** WANPIPE-specific entry points ***************************************/

/*============================================================================
 * Execute adapter interface command.
 */
static int wpf_exec (struct sdla* card, void* u_cmd, void* u_data)
{
        fr_mbox_t* mbox = card->mbox;
        int retry = MAX_CMD_RETRY;
        int err, len;
        fr_cmd_t cmd;

        if(copy_from_user((void*)&cmd, u_cmd, sizeof(cmd)))
                return -EFAULT;
        /* XXX: should check cmd.length against size allocated for mbox->data */
        
        /* execute command */
        do
        {
                memcpy(&mbox->cmd, &cmd, sizeof(cmd));
                
                if (cmd.length){
                        if( copy_from_user((void*)&mbox->data, u_data, cmd.length))
                                return -EFAULT;
                }
                
                if (sdla_exec(mbox))
                        err = mbox->cmd.result;

                else return -EIO;
        
        } while (err && retry-- && fr_event(card, err, mbox));

        /* return result */
        if (copy_to_user(u_cmd, (void*)&mbox->cmd, sizeof(fr_cmd_t)))
                return -EFAULT;

        len = mbox->cmd.length;

        if (len && u_data && !copy_to_user(u_data, (void*)&mbox->data, len))
                return -EFAULT;
        return 0;

}

/****** Network Device Interface ********************************************/

/*============================================================================
 * Initialize Linux network interface.
 *
 * This routine is called only once for each interface, during Linux network
 * interface registration.  Returning anything but zero will fail interface
 * registration.
 */
static int if_init (struct device* dev)
{
        fr_channel_t* chan = dev->priv;
        sdla_t* card = chan->card;
        wan_device_t* wandev = &card->wandev;

        /* Initialize device driver entry points */
        dev->open               = &if_open;
        dev->stop               = &if_close;
        dev->hard_header        = &if_header;
        dev->rebuild_header     = &if_rebuild_hdr;
        dev->hard_start_xmit    = &if_send;
        dev->get_stats          = &if_stats;

        /* Initialize media-specific parameters */
        dev->type               = ARPHRD_DLCI;  /* ARP h/w type */
        dev->flags              |= IFF_POINTOPOINT;     

        /* Enable Multicast addressing */
        if (chan->mc == WANOPT_YES){
                dev->flags      |= IFF_MULTICAST;
        }

        dev->mtu                = wandev->mtu - FR_HEADER_LEN;
        /* For an API, the maximum number of bytes that the stack will pass
           to the driver is (dev->mtu + dev->hard_header_len). So, adjust the
           mtu so that a frame of maximum size can be transmitted by the API. 
        */
        if(chan->usedby == API) {
                dev->mtu += (sizeof(api_tx_hdr_t) - FR_HEADER_LEN);
        }
        
        dev->hard_header_len    = FR_HEADER_LEN;/* media header length */
        dev->addr_len           = 2;            /* hardware address length */
        *(unsigned short*)dev->dev_addr = htons(chan->dlci);

        /* Initialize hardware parameters (just for reference) */
        dev->irq        = wandev->irq;
        dev->dma        = wandev->dma;
        dev->base_addr  = wandev->ioport;
        dev->mem_start  = wandev->maddr;
        dev->mem_end    = wandev->maddr + wandev->msize - 1;

        /* Set transmit buffer queue length */
        dev->tx_queue_len = 100;
   
        /* Initialize socket buffers */
        dev_init_buffers(dev);

        set_chan_state(dev, WAN_DISCONNECTED);
        return 0;
}

/*============================================================================
 * Open network interface.
 * o if this is the first open, then enable communications and interrupts.
 * o prevent module from unloading by incrementing use count
 *
 * Return 0 if O.k. or errno.
 */
static int if_open (struct device* dev)
{
        fr_channel_t* chan = dev->priv;
        sdla_t* card = chan->card;
        int err = 0;
        struct timeval tv;

        if (dev->start)
                return -EBUSY;          /* only one open is allowed */

        if (test_and_set_bit(1, (void*)&card->wandev.critical))
                return -EAGAIN;
        

        /* If signalling is set to NO, then setup 
         * DLCI addresses right away.  Don't have to wait for
         * link to connect. 
         */
        if (card->wandev.signalling == WANOPT_NO){
                printk(KERN_INFO "%s: Signalling set to NO: Mapping DLCI's\n",
                                        card->wandev.name);
                if (fr_init_dlci(card,chan)){
                        return -EAGAIN;
                }
        }

        if (card->wandev.station == WANOPT_CPE) {

                /* CPE: issue full status enquiry */
                fr_issue_isf(card, FR_ISF_FSE);

        } else {        /* FR switch: activate DLCI(s) */
                
                /* For Switch emulation we have to ADD and ACTIVATE
                 * the DLCI(s) that were configured with the SET_DLCI_
                 * CONFIGURATION command. Add and Activate will fail if
                 * DLCI specified is not included in the list.
                 *
                 * Also If_open is called once for each interface. But
                 * it does not get in here for all the interface. So
                 * we have to pass the entire list of DLCI(s) to add 
                 * activate routines.  
                 */ 
        
                fr_add_dlci(card, chan->dlci);
                fr_activate_dlci(card, chan->dlci);
        }

        dev->interrupt = 0;
        dev->tbusy = 0;
        dev->start = 1;
        wanpipe_open(card);
        update_chan_state(dev);
        do_gettimeofday( &tv );
        chan->router_start_time = tv.tv_sec;
        clear_bit(1, (void*)&card->wandev.critical);
        return err;
}

/*============================================================================
 * Close network interface.
 * o if this is the last open, then disable communications and interrupts.
 * o reset flags.
 */
static int if_close (struct device* dev)
{
        fr_channel_t* chan = dev->priv;
        sdla_t* card = chan->card;

        if (test_and_set_bit(1, (void*)&card->wandev.critical))
                return -EAGAIN;

        dev->start = 0;
        wanpipe_close(card);
        if (card->wandev.station == WANOPT_NODE) {
                fr_delete_dlci (card,chan->dlci);
        }

        clear_bit(1, (void*)&card->wandev.critical);
        return 0;
}

/*============================================================================
 * Build media header.
 * o encapsulate packet according to encapsulation type.
 *
 * The trick here is to put packet type (Ethertype) into 'protocol' field of
 * the socket buffer, so that we don't forget it.  If encapsulation fails,
 * set skb->protocol to 0 and discard packet later.
 *
 * Return:      media header length.
 */
static int if_header (struct sk_buff* skb, struct device* dev,
        unsigned short type, void* daddr, void* saddr, unsigned len)
{
        int hdr_len = 0;
        
        skb->protocol = type;
        hdr_len = wanrouter_encapsulate(skb, dev);

        if (hdr_len < 0) {
                hdr_len = 0;
                skb->protocol = 0;
        }
        skb_push(skb, 1);
        skb->data[0] = Q922_UI;
        ++hdr_len;
        return hdr_len;
}

/*============================================================================
 * Re-build media header.
 *
 * Return:      1       physical address resolved.
 *              0       physical address not resolved
 */
static int if_rebuild_hdr (struct sk_buff* skb)
{
        struct device *dev = skb->dev;
        fr_channel_t* chan = dev->priv;
        sdla_t* card = chan->card;

        printk(KERN_INFO "%s: rebuild_header() called for interface %s!\n",
                card->devname, dev->name);
        return 1;
}

/*============================================================================
 * Send a packet on a network interface.
 * o set tbusy flag (marks start of the transmission) to block a timer-based
 *   transmit from overlapping.
 * o set critical flag when accessing board.
 * o check link state. If link is not up, then drop the packet.
 * o check channel status. If it's down then initiate a call.
 * o pass a packet to corresponding WAN device.
 * o free socket buffer
 *
 * Return:      0       complete (socket buffer must be freed)
 *              non-0   packet may be re-transmitted (tbusy must be set)
 *
 * Notes:
 * 1. This routine is called either by the protocol stack or by the "net
 *    bottom half" (with interrupts enabled).
 * 2. Setting tbusy flag will inhibit further transmit requests from the
 *    protocol stack and can be used for flow control with protocol layer.
 */
static int if_send (struct sk_buff* skb, struct device* dev)
{
        fr_channel_t* chan = dev->priv;
        sdla_t* card = chan->card;
        int err;
        unsigned char *sendpacket;
        fr508_flags_t* adptr_flags = card->flags;
        int udp_type, send_data;
        unsigned long smp_flags=0;
        void* data;
        unsigned len;

        chan->drvstats_if_send.if_send_entry++;

        if (skb == NULL) {             
                /* if we get here, some higher layer thinks we've missed an
                 * tx-done interrupt.
                 */
                printk(KERN_INFO "%s: interface %s got kicked!\n", 
                        card->devname, dev->name);
                chan->drvstats_if_send.if_send_skb_null ++;
                mark_bh(NET_BH);
                return 0;
        }

        /* We must set the 'tbusy' flag if we already have a packet queued for
           transmission in the transmit interrupt handler. However, we must
           ensure that the transmit interrupt does not reset the 'tbusy' flag
           just before we set it, as this will result in a "transmit timeout".
        */
        set_bit(2, (void*)&card->wandev.critical);
        if(chan->transmit_length) {
                dev->tbusy = 1;
                chan->tick_counter = jiffies;
                clear_bit(2, (void*)&card->wandev.critical);
                return 1;
        }
        clear_bit(2, (void*)&card->wandev.critical);
  
        if (dev->tbusy) {

                /* If our device stays busy for at least 5 seconds then we will
                 * kick start the device by making dev->tbusy = 0.  We expect
                 * that our device never stays busy more than 5 seconds. So this                 
                 * is only used as a last resort.
                 */
                
                chan->drvstats_if_send.if_send_tbusy++;
                ++chan->ifstats.collisions;

                if ((jiffies - chan->tick_counter) < (5 * HZ)) {
                        return 1;
                }

                printk(KERN_INFO "%s: Transmit timed out\n", chan->name);
                chan->drvstats_if_send.if_send_tbusy_timeout ++;
                dev->tbusy = 0;
        }

        data = skb->data;
        sendpacket = skb->data;
        len = skb->len;

        udp_type = udp_pkt_type(skb, card);

        if(udp_type != UDP_INVALID_TYPE) {
                if(store_udp_mgmt_pkt(udp_type, UDP_PKT_FRM_STACK, card, skb,
                        chan->dlci)) {
                        adptr_flags->imask |= FR_INTR_TIMER;
                        if (udp_type == UDP_FPIPE_TYPE){
                                chan->drvstats_if_send.
                                        if_send_PIPE_request ++;
                        }
                }
                return 0;
        }

        if((chan->usedby == API) && (len <= sizeof(api_tx_hdr_t))) {
                //FIXME: increment some error statistic
                dev_kfree_skb(skb);
                return 0;
        }
 
        //FIXME: can we do better than sendpacket[2]?
        if ((chan->usedby == WANPIPE) && (sendpacket[2] == 0x45)) {
                /* check to see if the source IP address is a broadcast or */
                /* multicast IP address */
                if(chk_bcast_mcast_addr(card, dev, skb))
                        return 0;
        }

        /* Lock the 508 card: SMP Supported */
        s508_s514_lock(card,&smp_flags);

        if (test_and_set_bit(0, (void*)&card->wandev.critical)) {
                chan->drvstats_if_send.if_send_critical_non_ISR ++;
                chan->ifstats.tx_dropped ++;
                printk(KERN_INFO "%s Critical in IF_SEND %02X\n", 
                                card->devname, card->wandev.critical);
                dev_kfree_skb(skb);
                /* Unlock the 508 card */
                s508_s514_unlock(card,&smp_flags);
                return 0;
        }
        
        if (card->wandev.state != WAN_CONNECTED) {
                chan->drvstats_if_send.if_send_wan_disconnected ++;
                ++chan->ifstats.tx_dropped;
                ++card->wandev.stats.tx_dropped;
        
        } else if (chan->state != WAN_CONNECTED) {
                chan->drvstats_if_send.if_send_dlci_disconnected ++;
                /* Critical area on 514, since disabl_irq is not used
                 * thus, interrupt would execute a command at
                 * the same time as if_