lisa/android_kernel_xiaomi_sm8350
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
136df52d53
android_kernel_xiaomi_sm8350/drivers/net/wan/sdla_x25.c

5498 lines
149 KiB
C
Raw Normal View History

Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 18:20:36 -04:00
/*****************************************************************************
* sdla_x25.c WANPIPE(tm) Multiprotocol WAN Link Driver. X.25 module.
*
* Author: Nenad Corbic <ncorbic@sangoma.com>
*
* Copyright: (c) 1995-2001 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.
* ============================================================================
* Apr 03, 2001 Nenad Corbic o Fixed the rx_skb=NULL bug in x25 in rx_intr().
* Dec 26, 2000 Nenad Corbic o Added a new polling routine, that uses
* a kernel timer (more efficient).
* Dec 25, 2000 Nenad Corbic o Updated for 2.4.X kernel
* Jul 26, 2000 Nenad Corbic o Increased the local packet buffering
* for API to 4096+header_size.
* Jul 17, 2000 Nenad Corbic o Fixed the x25 startup bug. Enable
* communications only after all interfaces
* come up. HIGH SVC/PVC is used to calculate
* the number of channels.
* Enable protocol only after all interfaces
* are enabled.
* Jul 10, 2000 Nenad Corbic o Fixed the M_BIT bug.
* Apr 25, 2000 Nenad Corbic o Pass Modem messages to the API.
* Disable idle timeout in X25 API.
* Apr 14, 2000 Nenad Corbic o Fixed: Large LCN number support.
* Maximum LCN number is 4095.
* Maximum number of X25 channels is 255.
* Apr 06, 2000 Nenad Corbic o Added SMP Support.
* Mar 29, 2000 Nenad Corbic o Added support for S514 PCI Card
* Mar 23, 2000 Nenad Corbic o Improved task queue, BH handling.
* Mar 14, 2000 Nenad Corbic o Updated Protocol Violation handling
* routines. Bug Fix.
* Mar 10, 2000 Nenad Corbic o Bug Fix: corrupted mbox recovery.
* Mar 09, 2000 Nenad Corbic o Fixed the auto HDLC bug.
* Mar 08, 2000 Nenad Corbic o Fixed LAPB HDLC startup problems.
* Application must bring the link up
* before tx/rx, and bring the
* link down on close().
* Mar 06, 2000 Nenad Corbic o Added an option for logging call setup
* information.
* Feb 29, 2000 Nenad Corbic o Added support for LAPB HDLC API
* Feb 25, 2000 Nenad Corbic o Fixed the modem failure handling.
* No Modem OOB message will be passed
* to the user.
* Feb 21, 2000 Nenad Corbic o Added Xpipemon Debug Support
* Dec 30, 1999 Nenad Corbic o Socket based X25API
* Sep 17, 1998 Jaspreet Singh o Updates for 2.2.X kernel
* Mar 15, 1998 Alan Cox o 2.1.x porting
* Dec 19, 1997 Jaspreet Singh o Added multi-channel IPX support
* Nov 27, 1997 Jaspreet Singh o Added protection against enabling of irqs
* when they are disabled.
* Nov 17, 1997 Farhan Thawar o Added IPX support
* o Changed if_send() to now buffer packets when
* the board is busy
* o Removed queueing of packets via the polling
* routing
* o Changed if_send() critical flags to properly
* handle race conditions
* Nov 06, 1997 Farhan Thawar o Added support for SVC timeouts
* o Changed PVC encapsulation to ETH_P_IP
* Jul 21, 1997 Jaspreet Singh o Fixed freeing up of buffers using kfree()
* when packets are received.
* Mar 11, 1997 Farhan Thawar Version 3.1.1
* o added support for V35
* o changed if_send() to return 0 if
* wandev.critical() is true
* o free socket buffer in if_send() if
* returning 0
* o added support for single '@' address to
* accept all incoming calls
* o fixed bug in set_chan_state() to disconnect
* Jan 15, 1997 Gene Kozin Version 3.1.0
* o implemented exec() entry point
* Jan 07, 1997 Gene Kozin Initial version.
*****************************************************************************/
/*======================================================
* Includes
*=====================================================*/
#include <linux/module.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/ctype.h>
#include <linux/slab.h> /* kmalloc(), kfree() */
#include <linux/wanrouter.h> /* WAN router definitions */
#include <linux/wanpipe.h> /* WANPIPE common user API definitions */
#include <linux/workqueue.h>
[WAN]: drivers/net/wan/: use of time_after macro From: Marcelo Feitoza Parisi <marcelo@feitoza.com.br> Use of the time_after() macro, defined at linux/jiffies.h, which deal with wrapping correctly and are nicer to read. Signed-off-by: Marcelo Feitoza Parisi <marcelo@feitoza.com.br> Signed-off-by: Domen Puncer <domen@coderock.org> Signed-off-by: David S. Miller <davem@davemloft.net>
2005-07-15 12:59:26 -04:00
#include <linux/jiffies.h> /* time_after() macro */
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 18:20:36 -04:00
#include <asm/byteorder.h> /* htons(), etc. */
#include <asm/atomic.h>
#include <linux/delay.h> /* Experimental delay */
#include <asm/uaccess.h>
#include <linux/if.h>
#include <linux/if_arp.h>
#include <linux/sdla_x25.h> /* X.25 firmware API definitions */
#include <linux/if_wanpipe_common.h>
#include <linux/if_wanpipe.h>
/*======================================================
* Defines & Macros
*=====================================================*/
#define CMD_OK 0 /* normal firmware return code */
#define CMD_TIMEOUT 0xFF /* firmware command timed out */
#define MAX_CMD_RETRY 10 /* max number of firmware retries */
#define X25_CHAN_MTU 4096 /* unfragmented logical channel MTU */
#define X25_HRDHDR_SZ 7 /* max encapsulation header size */
#define X25_CONCT_TMOUT (90*HZ) /* link connection timeout */
#define X25_RECON_TMOUT (10*HZ) /* link connection timeout */
#define CONNECT_TIMEOUT (90*HZ) /* link connection timeout */
#define HOLD_DOWN_TIME (30*HZ) /* link hold down time */
#define MAX_BH_BUFF 10
#define M_BIT 0x01
//#define PRINT_DEBUG 1
#ifdef PRINT_DEBUG
#define DBG_PRINTK(format, a...) printk(format, ## a)
#else
#define DBG_PRINTK(format, a...)
#endif
#define TMR_INT_ENABLED_POLL_ACTIVE 0x01
#define TMR_INT_ENABLED_POLL_CONNECT_ON 0x02
#define TMR_INT_ENABLED_POLL_CONNECT_OFF 0x04
#define TMR_INT_ENABLED_POLL_DISCONNECT 0x08
#define TMR_INT_ENABLED_CMD_EXEC 0x10
#define TMR_INT_ENABLED_UPDATE 0x20
#define TMR_INT_ENABLED_UDP_PKT 0x40
#define MAX_X25_ADDR_SIZE 16
#define MAX_X25_DATA_SIZE 129
#define MAX_X25_FACL_SIZE 110
#define TRY_CMD_AGAIN 2
#define DELAY_RESULT 1
#define RETURN_RESULT 0
#define DCD(x) (x & 0x03 ? "HIGH" : "LOW")
#define CTS(x) (x & 0x05 ? "HIGH" : "LOW")
/* Driver will not write log messages about
* modem status if defined.*/
#define MODEM_NOT_LOG 1
/*====================================================
* For 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)))
/*====================================================
* MEMORY DEBUGGING FUNCTION
*====================================================
#define KMEM_SAFETYZONE 8
static void * dbg_kmalloc(unsigned int size, int prio, int line) {
int i = 0;
void * v = kmalloc(size+sizeof(unsigned int)+2*KMEM_SAFETYZONE*8,prio);
char * c1 = v;
c1 += sizeof(unsigned int);
*((unsigned int *)v) = size;
for (i = 0; i < KMEM_SAFETYZONE; i++) {
c1[0] = 'D'; c1[1] = 'E'; c1[2] = 'A'; c1[3] = 'D';
c1[4] = 'B'; c1[5] = 'E'; c1[6] = 'E'; c1[7] = 'F';
c1 += 8;
}
c1 += size;
for (i = 0; i < KMEM_SAFETYZONE; i++) {
c1[0] = 'M'; c1[1] = 'U'; c1[2] = 'N'; c1[3] = 'G';
c1[4] = 'W'; c1[5] = 'A'; c1[6] = 'L'; c1[7] = 'L';
c1 += 8;
}
v = ((char *)v) + sizeof(unsigned int) + KMEM_SAFETYZONE*8;
printk(KERN_INFO "line %d kmalloc(%d,%d) = %p\n",line,size,prio,v);
return v;
}
static void dbg_kfree(void * v, int line) {
unsigned int * sp = (unsigned int *)(((char *)v) - (sizeof(unsigned int) + KMEM_SAFETYZONE*8));
unsigned int size = *sp;
char * c1 = ((char *)v) - KMEM_SAFETYZONE*8;
int i = 0;
for (i = 0; i < KMEM_SAFETYZONE; i++) {
if ( c1[0] != 'D' || c1[1] != 'E' || c1[2] != 'A' || c1[3] != 'D'
|| c1[4] != 'B' || c1[5] != 'E' || c1[6] != 'E' || c1[7] != 'F') {
printk(KERN_INFO "kmalloced block at %p has been corrupted (underrun)!\n",v);
printk(KERN_INFO " %4x: %2x %2x %2x %2x %2x %2x %2x %2x\n", i*8,
c1[0],c1[1],c1[2],c1[3],c1[4],c1[5],c1[6],c1[7] );
}
c1 += 8;
}
c1 += size;
for (i = 0; i < KMEM_SAFETYZONE; i++) {
if ( c1[0] != 'M' || c1[1] != 'U' || c1[2] != 'N' || c1[3] != 'G'
|| c1[4] != 'W' || c1[5] != 'A' || c1[6] != 'L' || c1[7] != 'L'
) {
printk(KERN_INFO "kmalloced block at %p has been corrupted (overrun):\n",v);
printk(KERN_INFO " %4x: %2x %2x %2x %2x %2x %2x %2x %2x\n", i*8,
c1[0],c1[1],c1[2],c1[3],c1[4],c1[5],c1[6],c1[7] );
}
c1 += 8;
}
printk(KERN_INFO "line %d kfree(%p)\n",line,v);
v = ((char *)v) - (sizeof(unsigned int) + KMEM_SAFETYZONE*8);
kfree(v);
}
#define kmalloc(x,y) dbg_kmalloc(x,y,__LINE__)
#define kfree(x) dbg_kfree(x,__LINE__)
==============================================================*/
/*===============================================
* Data Structures
*===============================================*/
/*========================================================
* Name: x25_channel
*
* Purpose: To hold private informaton for each
* logical channel.
*
* Rationale: Per-channel debugging is possible if each
* channel has its own private area.
*
* Assumptions:
*
* Description: This is an extention of the struct net_device
* we create for each network interface to keep
* the rest of X.25 channel-specific data.
*
* Construct: Typedef
*/
typedef struct x25_channel
{
wanpipe_common_t common; /* common area for x25api and socket */
char name[WAN_IFNAME_SZ+1]; /* interface name, ASCIIZ */
char addr[WAN_ADDRESS_SZ+1]; /* media address, ASCIIZ */
unsigned tx_pkt_size;
unsigned short protocol; /* ethertype, 0 - multiplexed */
char drop_sequence; /* mark sequence for dropping */
unsigned long state_tick; /* time of the last state change */
unsigned idle_timeout; /* sec, before disconnecting */
unsigned long i_timeout_sofar; /* # of sec's we've been idle */
unsigned hold_timeout; /* sec, before re-connecting */
unsigned long tick_counter; /* counter for transmit time out */
char devtint; /* Weather we should dev_tint() */
struct sk_buff* rx_skb; /* receive socket buffer */
struct sk_buff* tx_skb; /* transmit socket buffer */
bh_data_t *bh_head; /* Circular buffer for x25api_bh */
unsigned long tq_working;
volatile int bh_write;
volatile int bh_read;
atomic_t bh_buff_used;
sdla_t* card; /* -> owner */
struct net_device *dev; /* -> bound devce */
int ch_idx;
unsigned char enable_IPX;
unsigned long network_number;
struct net_device_stats ifstats; /* interface statistics */
unsigned short transmit_length;
unsigned short tx_offset;
char transmit_buffer[X25_CHAN_MTU+sizeof(x25api_hdr_t)];
if_send_stat_t if_send_stat;
rx_intr_stat_t rx_intr_stat;
pipe_mgmt_stat_t pipe_mgmt_stat;
unsigned long router_start_time; /* Router start time in seconds */
unsigned long router_up_time;
} x25_channel_t;
/* FIXME Take this out */
#ifdef NEX_OLD_CALL_INFO
typedef struct x25_call_info
{
char dest[17]; PACKED;/* ASCIIZ destination address */
char src[17]; PACKED;/* ASCIIZ source address */
char nuser; PACKED;/* number of user data bytes */
unsigned char user[127]; PACKED;/* user data */
char nfacil; PACKED;/* number of facilities */
struct
{
unsigned char code; PACKED;
unsigned char parm; PACKED;
} facil[64]; /* facilities */
} x25_call_info_t;
#else
typedef struct x25_call_info
{
char dest[MAX_X25_ADDR_SIZE] PACKED;/* ASCIIZ destination address */
char src[MAX_X25_ADDR_SIZE] PACKED;/* ASCIIZ source address */
unsigned char nuser PACKED;
unsigned char user[MAX_X25_DATA_SIZE] PACKED;/* user data */
unsigned char nfacil PACKED;
unsigned char facil[MAX_X25_FACL_SIZE] PACKED;
unsigned short lcn PACKED;
} x25_call_info_t;
#endif
/*===============================================
* Private Function Prototypes
*==============================================*/
/*=================================================
* WAN link driver entry points. These are
* called by the WAN router module.
*/
static int update(struct wan_device* wandev);
static int new_if(struct wan_device* wandev, struct net_device* dev,
wanif_conf_t* conf);
static int del_if(struct wan_device* wandev, struct net_device* dev);
static void disable_comm (sdla_t* card);
static void disable_comm_shutdown(sdla_t *card);
/*=================================================
* WANPIPE-specific entry points
*/
static int wpx_exec (struct sdla* card, void* u_cmd, void* u_data);
static void x25api_bh(struct net_device *dev);
static int x25api_bh_cleanup(struct net_device *dev);
static int bh_enqueue(struct net_device *dev, struct sk_buff *skb);
/*=================================================
* Network device interface
*/
static int if_init(struct net_device* dev);
static int if_open(struct net_device* dev);
static int if_close(struct net_device* dev);
static int if_header(struct sk_buff* skb, struct net_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 net_device* dev);
static struct net_device_stats *if_stats(struct net_device* dev);
static void if_tx_timeout(struct net_device *dev);
/*=================================================
* Interrupt handlers
*/
static void wpx_isr (sdla_t *);
static void rx_intr (sdla_t *);
static void tx_intr (sdla_t *);
static void status_intr (sdla_t *);
static void event_intr (sdla_t *);
static void spur_intr (sdla_t *);
static void timer_intr (sdla_t *);
static int tx_intr_send(sdla_t *card, struct net_device *dev);
static struct net_device *move_dev_to_next(sdla_t *card,
struct net_device *dev);
/*=================================================
* Background polling routines
*/
static void wpx_poll (sdla_t* card);
static void poll_disconnected (sdla_t* card);
static void poll_connecting (sdla_t* card);
static void poll_active (sdla_t* card);
static void trigger_x25_poll(sdla_t *card);
static void x25_timer_routine(unsigned long data);
/*=================================================
* X.25 firmware interface functions
*/
static int x25_get_version (sdla_t* card, char* str);
static int x25_configure (sdla_t* card, TX25Config* conf);
static int hdlc_configure (sdla_t* card, TX25Config* conf);
static int set_hdlc_level (sdla_t* card);
static int x25_get_err_stats (sdla_t* card);
static int x25_get_stats (sdla_t* card);
static int x25_set_intr_mode (sdla_t* card, int mode);
static int x25_close_hdlc (sdla_t* card);
static int x25_open_hdlc (sdla_t* card);
static int x25_setup_hdlc (sdla_t* card);
static int x25_set_dtr (sdla_t* card, int dtr);
static int x25_get_chan_conf (sdla_t* card, x25_channel_t* chan);
static int x25_place_call (sdla_t* card, x25_channel_t* chan);
static int x25_accept_call (sdla_t* card, int lcn, int qdm);
static int x25_clear_call (sdla_t* card, int lcn, int cause, int diagn);
static int x25_send (sdla_t* card, int lcn, int qdm, int len, void* buf);
static int x25_fetch_events (sdla_t* card);
static int x25_error (sdla_t* card, int err, int cmd, int lcn);
/*=================================================
* X.25 asynchronous event handlers
*/
static int incoming_call (sdla_t* card, int cmd, int lcn, TX25Mbox* mb);
static int call_accepted (sdla_t* card, int cmd, int lcn, TX25Mbox* mb);
static int call_cleared (sdla_t* card, int cmd, int lcn, TX25Mbox* mb);
static int timeout_event (sdla_t* card, int cmd, int lcn, TX25Mbox* mb);
static int restart_event (sdla_t* card, int cmd, int lcn, TX25Mbox* mb);
/*=================================================
* Miscellaneous functions
*/
static int connect (sdla_t* card);
static int disconnect (sdla_t* card);
static struct net_device* get_dev_by_lcn(struct wan_device* wandev,
unsigned lcn);
static int chan_connect(struct net_device* dev);
static int chan_disc(struct net_device* dev);
static void set_chan_state(struct net_device* dev, int state);
static int chan_send(struct net_device *dev, void* buff, unsigned data_len,
unsigned char tx_intr);
static unsigned char bps_to_speed_code (unsigned long bps);
static unsigned int dec_to_uint (unsigned char* str, int len);
static unsigned int hex_to_uint (unsigned char*, int);
static void parse_call_info (unsigned char*, x25_call_info_t*);
static struct net_device *find_channel(sdla_t *card, unsigned lcn);
static void bind_lcn_to_dev(sdla_t *card, struct net_device *dev, unsigned lcn);
static void setup_for_delayed_transmit(struct net_device *dev,
void *buf, unsigned len);
/*=================================================
* X25 API Functions
*/
static int wanpipe_pull_data_in_skb(sdla_t *card, struct net_device *dev,
struct sk_buff **);
static void timer_intr_exec(sdla_t *, unsigned char);
static int execute_delayed_cmd(sdla_t *card, struct net_device *dev,
mbox_cmd_t *usr_cmd, char bad_cmd);
static int api_incoming_call (sdla_t*, TX25Mbox *, int);
static int alloc_and_init_skb_buf (sdla_t *,struct sk_buff **, int);
static void send_delayed_cmd_result(sdla_t *card, struct net_device *dev,
TX25Mbox* mbox);
static int clear_confirm_event (sdla_t *, TX25Mbox*);
static void send_oob_msg (sdla_t *card, struct net_device *dev, TX25Mbox *mbox);
static int timer_intr_cmd_exec(sdla_t *card);
static void api_oob_event (sdla_t *card,TX25Mbox *mbox);
static int check_bad_command(sdla_t *card, struct net_device *dev);
static int channel_disconnect(sdla_t* card, struct net_device *dev);
static void hdlc_link_down (sdla_t*);
/*=================================================
* XPIPEMON Functions
*/
static int process_udp_mgmt_pkt(sdla_t *);
static int udp_pkt_type( struct sk_buff *, sdla_t*);
static int reply_udp( unsigned char *, unsigned int);
static void init_x25_channel_struct( x25_channel_t *);
static void init_global_statistics( sdla_t *);
static int store_udp_mgmt_pkt(int udp_type, char udp_pkt_src, sdla_t *card,
struct net_device *dev,
struct sk_buff *skb, int lcn);
static unsigned short calc_checksum (char *, int);
/*=================================================
* IPX functions
*/
static void switch_net_numbers(unsigned char *, unsigned long, unsigned char);
static int handle_IPXWAN(unsigned char *, char *, unsigned char ,
unsigned long , unsigned short );
extern void disable_irq(unsigned int);
extern void enable_irq(unsigned int);
static void S508_S514_lock(sdla_t *, unsigned long *);
static void S508_S514_unlock(sdla_t *, unsigned long *);
/*=================================================
* Global Variables
*=================================================*/
/*=================================================
* Public Functions
*=================================================*/
/*===================================================================
* wpx_init: X.25 Protocol Initialization routine.
*
* Purpose: To initialize the protocol/firmware.
*
* Rationale: This function is called by setup() function, in
* sdlamain.c, to dynamically setup the x25 protocol.
* This is the first protocol specific function, which
* executes once on startup.
*
* Description: This procedure initializes the x25 firmware and
* sets up the mailbox, transmit and receive buffer
* pointers. It also initializes all debugging structures
* and sets up the X25 environment.
*
* Sets up hardware options defined by user in [wanpipe#]
* section of wanpipe#.conf configuration file.
*
* At this point adapter is completely initialized
* and X.25 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.
*
* Called by: setup() function in sdlamain.c
*
* Assumptions: None
*
* Warnings: None
*
* Return: 0 o.k.
* < 0 failure.
*/
int wpx_init (sdla_t* card, wandev_conf_t* conf)
{
union{
char str[80];
TX25Config cfg;
} u;
/* Verify configuration ID */
if (conf->config_id != WANCONFIG_X25){
printk(KERN_INFO "%s: invalid configuration ID %u!\n",
card->devname, conf->config_id)
;
return -EINVAL;
}
/* Initialize protocol-specific fields */
card->mbox = (void*)(card->hw.dpmbase + X25_MBOX_OFFS);
card->rxmb = (void*)(card->hw.dpmbase + X25_RXMBOX_OFFS);
card->flags = (void*)(card->hw.dpmbase + X25_STATUS_OFFS);
/* Initialize for S514 Card */
if(card->hw.type == SDLA_S514) {
card->mbox += X25_MB_VECTOR;
card->flags += X25_MB_VECTOR;
card->rxmb += X25_MB_VECTOR;
}
/* 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 (x25_get_version(card, NULL) || x25_get_version(card, u.str))
return -EIO;
/* X25 firmware can run ether in X25 or LAPB HDLC mode.
* Check the user defined option and configure accordingly */
if (conf->u.x25.LAPB_hdlc_only == WANOPT_YES){
if (set_hdlc_level(card) != CMD_OK){
return -EIO;
}else{
printk(KERN_INFO "%s: running LAP_B HDLC firmware v%s\n",
card->devname, u.str);
}
card->u.x.LAPB_hdlc = 1;
}else{
printk(KERN_INFO "%s: running X.25 firmware v%s\n",
card->devname, u.str);
card->u.x.LAPB_hdlc = 0;
}
/* Configure adapter. Here we set resonable defaults, then parse
* device configuration structure and set configuration options.
* Most configuration options are verified and corrected (if
* necessary) since we can't rely on the adapter to do so.
*/
memset(&u.cfg, 0, sizeof(u.cfg));
u.cfg.t1 = 3;
u.cfg.n2 = 10;
u.cfg.autoHdlc = 1; /* automatic HDLC connection */
u.cfg.hdlcWindow = 7;
u.cfg.pktWindow = 2;
u.cfg.station = 1; /* DTE */
u.cfg.options = 0x0090; /* disable D-bit pragmatics */
u.cfg.ccittCompat = 1988;
u.cfg.t10t20 = 30;
u.cfg.t11t21 = 30;
u.cfg.t12t22 = 30;
u.cfg.t13t23 = 30;
u.cfg.t16t26 = 30;
u.cfg.t28 = 30;
u.cfg.r10r20 = 5;
u.cfg.r12r22 = 5;
u.cfg.r13r23 = 5;
u.cfg.responseOpt = 1; /* RR's after every packet */
if (card->u.x.LAPB_hdlc){
u.cfg.hdlcMTU = 1027;
}
if (conf->u.x25.x25_conf_opt){
u.cfg.options = conf->u.x25.x25_conf_opt;
}
if (conf->clocking != WANOPT_EXTERNAL)
u.cfg.baudRate = bps_to_speed_code(conf->bps);
if (conf->station != WANOPT_DTE){
u.cfg.station = 0; /* DCE mode */
}
if (conf->interface != WANOPT_RS232 ){
u.cfg.hdlcOptions |= 0x80; /* V35 mode */
}
/* adjust MTU */
if (!conf->mtu || (conf->mtu >= 1024))
card->wandev.mtu = 1024;
else if (conf->mtu >= 512)
card->wandev.mtu = 512;
else if (conf->mtu >= 256)
card->wandev.mtu = 256;
else if (conf->mtu >= 128)
card->wandev.mtu = 128;
else
card->wandev.mtu = 64;
u.cfg.defPktSize = u.cfg.pktMTU = card->wandev.mtu;
if (conf->u.x25.hi_pvc){
card->u.x.hi_pvc = min_t(unsigned int, conf->u.x25.hi_pvc, MAX_LCN_NUM);
card->u.x.lo_pvc = min_t(unsigned int, conf->u.x25.lo_pvc, card->u.x.hi_pvc);
}
if (conf->u.x25.hi_svc){
card->u.x.hi_svc = min_t(unsigned int, conf->u.x25.hi_svc, MAX_LCN_NUM);
card->u.x.lo_svc = min_t(unsigned int, conf->u.x25.lo_svc, card->u.x.hi_svc);
}
/* Figure out the total number of channels to configure */
card->u.x.num_of_ch = 0;
if (card->u.x.hi_svc != 0){
card->u.x.num_of_ch = (card->u.x.hi_svc - card->u.x.lo_svc) + 1;
}
if (card->u.x.hi_pvc != 0){
card->u.x.num_of_ch += (card->u.x.hi_pvc - card->u.x.lo_pvc) + 1;
}
if (card->u.x.num_of_ch == 0){
printk(KERN_INFO "%s: ERROR, Minimum number of PVC/SVC channels is 1 !\n"
"%s: Please set the Lowest/Highest PVC/SVC values !\n",
card->devname,card->devname);
return -ECHRNG;
}
u.cfg.loPVC = card->u.x.lo_pvc;
u.cfg.hiPVC = card->u.x.hi_pvc;
u.cfg.loTwoWaySVC = card->u.x.lo_svc;
u.cfg.hiTwoWaySVC = card->u.x.hi_svc;
if (conf->u.x25.hdlc_window)
u.cfg.hdlcWindow = min_t(unsigned int, conf->u.x25.hdlc_window, 7);
if (conf->u.x25.pkt_window)
u.cfg.pktWindow = min_t(unsigned int, conf->u.x25.pkt_window, 7);
if (conf->u.x25.t1)
u.cfg.t1 = min_t(unsigned int, conf->u.x25.t1, 30);
if (conf->u.x25.t2)
u.cfg.t2 = min_t(unsigned int, conf->u.x25.t2, 29);
if (conf->u.x25.t4)
u.cfg.t4 = min_t(unsigned int, conf->u.x25.t4, 240);
if (conf->u.x25.n2)
u.cfg.n2 = min_t(unsigned int, conf->u.x25.n2, 30);
if (conf->u.x25.t10_t20)
u.cfg.t10t20 = min_t(unsigned int, conf->u.x25.t10_t20,255);
if (conf->u.x25.t11_t21)
u.cfg.t11t21 = min_t(unsigned int, conf->u.x25.t11_t21,255);
if (conf->u.x25.t12_t22)
u.cfg.t12t22 = min_t(unsigned int, conf->u.x25.t12_t22,255);
if (conf->u.x25.t13_t23)
u.cfg.t13t23 = min_t(unsigned int, conf->u.x25.t13_t23,255);
if (conf->u.x25.t16_t26)
u.cfg.t16t26 = min_t(unsigned int, conf->u.x25.t16_t26, 255);
if (conf->u.x25.t28)
u.cfg.t28 = min_t(unsigned int, conf->u.x25.t28, 255);
if (conf->u.x25.r10_r20)
u.cfg.r10r20 = min_t(unsigned int, conf->u.x25.r10_r20,250);
if (conf->u.x25.r12_r22)
u.cfg.r12r22 = min_t(unsigned int, conf->u.x25.r12_r22,250);
if (conf->u.x25.r13_r23)
u.cfg.r13r23 = min_t(unsigned int, conf->u.x25.r13_r23,250);
if (conf->u.x25.ccitt_compat)
u.cfg.ccittCompat = conf->u.x25.ccitt_compat;
/* initialize adapter */
if (card->u.x.LAPB_hdlc){
if (hdlc_configure(card, &u.cfg) != CMD_OK)
return -EIO;
}else{
if (x25_configure(card, &u.cfg) != CMD_OK)
return -EIO;
}
if ((x25_close_hdlc(card) != CMD_OK) || /* close HDLC link */
(x25_set_dtr(card, 0) != CMD_OK)) /* drop DTR */
return -EIO;
/* Initialize protocol-specific fields of adapter data space */
card->wandev.bps = conf->bps;
card->wandev.interface = conf->interface;
card->wandev.clocking = conf->clocking;
card->wandev.station = conf->station;
card->isr = &wpx_isr;
card->poll = NULL; //&wpx_poll;
card->disable_comm = &disable_comm;
card->exec = &wpx_exec;
card->wandev.update = &update;
card->wandev.new_if = &new_if;
card->wandev.del_if = &del_if;
/* WARNING: This function cannot exit with an error
* after the change of state */
card->wandev.state = WAN_DISCONNECTED;
card->wandev.enable_tx_int = 0;
card->irq_dis_if_send_count = 0;
card->irq_dis_poll_count = 0;
card->u.x.tx_dev = NULL;
card->u.x.no_dev = 0;
/* Configure for S514 PCI Card */
if (card->hw.type == SDLA_S514) {
card->u.x.hdlc_buf_status =
(volatile unsigned char *)
(card->hw.dpmbase + X25_MB_VECTOR+ X25_MISC_HDLC_BITS);
}else{
card->u.x.hdlc_buf_status =
(volatile unsigned char *)(card->hw.dpmbase + X25_MISC_HDLC_BITS);
}
card->u.x.poll_device=NULL;
card->wandev.udp_port = conf->udp_port;
/* Enable or disable call setup logging */
if (conf->u.x25.logging == WANOPT_YES){
printk(KERN_INFO "%s: Enabling Call Logging.\n",
card->devname);
card->u.x.logging = 1;
}else{
card->u.x.logging = 0;
}
/* Enable or disable modem status reporting */
if (conf->u.x25.oob_on_modem == WANOPT_YES){
printk(KERN_INFO "%s: Enabling OOB on Modem change.\n",
card->devname);
card->u.x.oob_on_modem = 1;
}else{
card->u.x.oob_on_modem = 0;
}
init_global_statistics(card);
INIT_WORK(&card->u.x.x25_poll_work, (void *)wpx_poll, card);
init_timer(&card->u.x.x25_timer);
card->u.x.x25_timer.data = (unsigned long)card;
card->u.x.x25_timer.function = x25_timer_routine;
return 0;
}
/*=========================================================
* WAN Device Driver Entry Points
*========================================================*/
/*============================================================
* Name: update(), Update device status & statistics.
*
* Purpose: To provide debugging and statitical
* information to the /proc file system.
* /proc/net/wanrouter/wanpipe#
*
* Rationale: The /proc file system is used to collect
* information about the kernel and drivers.
* Using the /proc file system the user
* can see exactly what the sangoma drivers are
* doing. And in what state they are in.
*
* Description: Collect all driver statistical information
* and pass it to the top laywer.
*
* Since we have to execute a debugging command,
* to obtain firmware statitics, we trigger a
* UPDATE function within the timer interrtup.
* We wait until the timer update is complete.
* Once complete return the appropriate return
* code to indicate that the update was successful.
*
* Called by: device_stat() in wanmain.c
*
* Assumptions:
*
* Warnings: This function will degrade the performance
* of the router, since it uses the mailbox.
*
* Return: 0 OK
* <0 Failed (or busy).
*/
static int update(struct wan_device* wandev)
{
volatile sdla_t* card;
TX25Status* status;
unsigned long timeout;
/* sanity checks */
if ((wandev == NULL) || (wandev->private == NULL))
return -EFAULT;
if (wandev->state == WAN_UNCONFIGURED)
return -ENODEV;
if (test_bit(SEND_CRIT, (void*)&wandev->critical))
return -EAGAIN;
if (!wandev->dev)
return -ENODEV;
card = wandev->private;
status = card->flags;
card->u.x.timer_int_enabled |= TMR_INT_ENABLED_UPDATE;
status->imask |= INTR_ON_TIMER;
timeout = jiffies;
for (;;){
if (!(card->u.x.timer_int_enabled & TMR_INT_ENABLED_UPDATE)){
break;
}
[WAN]: drivers/net/wan/: use of time_after macro From: Marcelo Feitoza Parisi <marcelo@feitoza.com.br> Use of the time_after() macro, defined at linux/jiffies.h, which deal with wrapping correctly and are nicer to read. Signed-off-by: Marcelo Feitoza Parisi <marcelo@feitoza.com.br> Signed-off-by: Domen Puncer <domen@coderock.org> Signed-off-by: David S. Miller <davem@davemloft.net>
2005-07-15 12:59:26 -04:00
if (time_after(jiffies, timeout + 1*HZ)){
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 18:20:36 -04:00
card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE;
return -EAGAIN;
}
}
return 0;
}
/*===================================================================
* Name: new_if
*
* Purpose: To allocate and initialize resources for a
* new logical channel.
*
* Rationale: A new channel can be added dynamically via
* ioctl call.
*
* Description: Allocate a private channel structure, x25_channel_t.
* Parse the user interface options from wanpipe#.conf
* configuration file.
* Bind the private are into the network device private
* area pointer (dev->priv).
* Prepare the network device structure for registration.
*
* Called by: ROUTER_IFNEW Ioctl call, from wanrouter_ioctl()
* (wanmain.c)
*
* Assumptions: None
*
* Warnings: None
*
* Return: 0 Ok
* <0 Failed (channel will not be created)
*/
static int new_if(struct wan_device* wandev, struct net_device* dev,
wanif_conf_t* conf)
{
sdla_t* card = wandev->private;
x25_channel_t* chan;
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;
}
if(card->wandev.new_if_cnt++ > 0 && card->u.x.LAPB_hdlc) {
printk(KERN_INFO "%s: Error: Running LAPB HDLC Mode !\n",
card->devname);
printk(KERN_INFO
"%s: Maximum number of network interfaces must be one !\n",
card->devname);
return -EEXIST;
}
/* allocate and initialize private data */
chan = kmalloc(sizeof(x25_channel_t), GFP_ATOMIC);
if (chan == NULL){
return -ENOMEM;
}
memset(chan, 0, sizeof(x25_channel_t));
/* Bug Fix: Seg Err on PVC startup
* It must be here since bind_lcn_to_dev expects
* it bellow */
dev->priv = chan;
strcpy(chan->name, conf->name);
chan->card = card;
chan->dev = dev;
chan->common.sk = NULL;
chan->common.func = NULL;
chan->common.rw_bind = 0;
chan->tx_skb = chan->rx_skb = NULL;
/* verify media address */
if (conf->addr[0] == '@'){ /* SVC */
chan->common.svc = 1;
strncpy(chan->addr, &conf->addr[1], WAN_ADDRESS_SZ);
/* Set channel timeouts (default if not specified) */
chan->idle_timeout = (conf->idle_timeout) ?
conf->idle_timeout : 90;
chan->hold_timeout = (conf->hold_timeout) ?
conf->hold_timeout : 10;
}else if (is_digit(conf->addr[0])){ /* PVC */
int lcn = dec_to_uint(conf->addr, 0);
if ((lcn >= card->u.x.lo_pvc) && (lcn <= card->u.x.hi_pvc)){
bind_lcn_to_dev (card, dev, lcn);
}else{
printk(KERN_ERR
"%s: PVC %u is out of range on interface %s!\n",
wandev->name, lcn, chan->name);
err = -EINVAL;
}
}else{
printk(KERN_ERR
"%s: invalid media address on interface %s!\n",
wandev->name, chan->name);
err = -EINVAL;
}
if(strcmp(conf->usedby, "WANPIPE") == 0){
printk(KERN_INFO "%s: Running in WANPIPE mode %s\n",
wandev->name, chan->name);
chan->common.usedby = WANPIPE;
chan->protocol = htons(ETH_P_IP);
}else if(strcmp(conf->usedby, "API") == 0){
chan->common.usedby = API;
printk(KERN_INFO "%s: Running in API mode %s\n",
wandev->name, chan->name);
chan->protocol = htons(X25_PROT);
}
if (err){
kfree(chan);
dev->priv = NULL;
return err;
}
chan->enable_IPX = conf->enable_IPX;
if (chan->enable_IPX)
chan->protocol = htons(ETH_P_IPX);
if (conf->network_number)
chan->network_number = conf->network_number;
else
chan->network_number = 0xDEADBEEF;
/* prepare network device data space for registration */
strcpy(dev->name,chan->name);
dev->init = &if_init;
init_x25_channel_struct(chan);
return 0;
}
/*===================================================================
* Name: del_if(), Remove a logical channel.
*
* Purpose: To dynamically remove a logical channel.
*
* Rationale: Each logical channel should be dynamically
* removable. This functin is called by an
* IOCTL_IFDEL ioctl call or shutdown().
*
* Description: Do nothing.
*
* Called by: IOCTL_IFDEL : wanrouter_ioctl() from wanmain.c
* shutdown() from sdlamain.c
*
* Assumptions:
*
* Warnings:
*
* Return: 0 Ok. Void function.
*/
//FIXME Del IF Should be taken out now.
static int del_if(struct wan_device* wandev, struct net_device* dev)
{
return 0;
}
/*============================================================
* Name: wpx_exec
*
* Description: Execute adapter interface command.
* This option is currently dissabled.
*===========================================================*/
static int wpx_exec (struct sdla* card, void* u_cmd, void* u_data)
{
return 0;
}
/*============================================================
* Name: disable_comm
*
* Description: Disable communications during shutdown.
* Dont check return code because there is
* nothing we can do about it.
*
* Warning: Dev and private areas are gone at this point.
*===========================================================*/
static void disable_comm(sdla_t* card)
{
disable_comm_shutdown(card);
del_timer(&card->u.x.x25_timer);
return;
}
/*============================================================
* Network Device Interface
*===========================================================*/
/*===================================================================
* Name: if_init(), Netowrk Interface Initialization
*
* Purpose: To initialize a network interface device structure.
*
* Rationale: During network interface startup, the if_init
* is called by the kernel to initialize the
* netowrk device structure. Thus a driver
* can customze a network device.
*
* Description: Initialize the netowrk device call back
* routines. This is where we tell the kernel
* which function to use when it wants to send
* via our interface.
* Furthermore, we initialize the device flags,
* MTU and physical address of the board.
*
* Called by: Kernel (/usr/src/linux/net/core/dev.c)
* (dev->init())
*
* Assumptions: None
*
* Warnings: None
*
* Return: 0 Ok : Void function.
*/
static int if_init(struct net_device* dev)
{
x25_channel_t* chan = dev->priv;
sdla_t* card = chan->card;
struct wan_device* 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;
dev->tx_timeout = &if_tx_timeout;
dev->watchdog_timeo = TX_TIMEOUT;
/* Initialize media-specific parameters */
dev->type = ARPHRD_PPP; /* ARP h/w type */
dev->flags |= IFF_POINTOPOINT;
dev->flags |= IFF_NOARP;
if (chan->common.usedby == API){
dev->mtu = X25_CHAN_MTU+sizeof(x25api_hdr_t);
}else{
dev->mtu = card->wandev.mtu;
}
dev->hard_header_len = X25_HRDHDR_SZ; /* media header length */
dev->addr_len = 2; /* hardware address length */
if (!chan->common.svc){
*(unsigned short*)dev->dev_addr = htons(chan->common.lcn);
}
/* Initialize hardware parameters (just for reference) */
dev->irq = wandev->irq;
dev->dma = wandev->dma;
dev->base_addr = wandev->ioport;
dev->mem_start = (unsigned long)wandev->maddr;
dev->mem_end = wandev->maddr + wandev->msize - 1;
/* Set transmit buffer queue length */
dev->tx_queue_len = 100;
SET_MODULE_OWNER(dev);
/* FIXME Why are we doing this */
set_chan_state(dev, WAN_DISCONNECTED);
return 0;
}
/*===================================================================
* Name: if_open(), Open/Bring up the Netowrk Interface
*
* Purpose: To bring up a network interface.
*
* Rationale:
*
* Description: Open network interface.
* o prevent module from unloading by incrementing use count
* o if link is disconnected then initiate connection
*
* Called by: Kernel (/usr/src/linux/net/core/dev.c)
* (dev->open())
*
* Assumptions: None
*
* Warnings: None
*
* Return: 0 Ok
* <0 Failure: Interface will not come up.
*/
static int if_open(struct net_device* dev)
{
x25_channel_t* chan = dev->priv;
sdla_t* card = chan->card;
struct timeval tv;
unsigned long smp_flags;
if (netif_running(dev))
return -EBUSY;
chan->tq_working = 0;
/* Initialize the workqueue */
INIT_WORK(&chan->common.wanpipe_work, (void *)x25api_bh, dev);
/* Allocate and initialize BH circular buffer */
/* Add 1 to MAX_BH_BUFF so we don't have test with (MAX_BH_BUFF-1) */
chan->bh_head = kmalloc((sizeof(bh_data_t)*(MAX_BH_BUFF+1)),GFP_ATOMIC);
if (chan->bh_head == NULL){
printk(KERN_INFO "%s: ERROR, failed to allocate memory ! BH_BUFFERS !\n",
card->devname);
return -ENOBUFS;
}
memset(chan->bh_head,0,(sizeof(bh_data_t)*(MAX_BH_BUFF+1)));
atomic_set(&chan->bh_buff_used, 0);
/* Increment the number of interfaces */
++card->u.x.no_dev;
wanpipe_open(card);
/* LAPB protocol only uses one interface, thus
* start the protocol after it comes up. */
if (card->u.x.LAPB_hdlc){
if (card->open_cnt == 1){
TX25Status* status = card->flags;
S508_S514_lock(card, &smp_flags);
x25_set_intr_mode(card, INTR_ON_TIMER);
status->imask &= ~INTR_ON_TIMER;
S508_S514_unlock(card, &smp_flags);
}
}else{
/* X25 can have multiple interfaces thus, start the
* protocol once all interfaces are up */
//FIXME: There is a bug here. If interface is
//brought down and up, it will try to enable comm.
if (card->open_cnt == card->u.x.num_of_ch){
S508_S514_lock(card, &smp_flags);
connect(card);
S508_S514_unlock(card, &smp_flags);
mod_timer(&card->u.x.x25_timer, jiffies + HZ);
}
}
/* Device is not up until the we are in connected state */
do_gettimeofday( &tv );
chan->router_start_time = tv.tv_sec;
netif_start_queue(dev);
return 0;
}
/*===================================================================
* Name: if_close(), Close/Bring down the Netowrk Interface
*
* Purpose: To bring down a network interface.
*
* Rationale:
*
* Description: Close network interface.
* o decrement use module use count
*
* Called by: Kernel (/usr/src/linux/net/core/dev.c)
* (dev->close())
* ifconfig <name> down: will trigger the kernel
* which will call this function.
*
* Assumptions: None
*
* Warnings: None
*
* Return: 0 Ok
* <0 Failure: Interface will not exit properly.
*/
static int if_close(struct net_device* dev)
{
x25_channel_t* chan = dev->priv;
sdla_t* card = chan->card;
unsigned long smp_flags;
netif_stop_queue(dev);
if ((chan->common.state == WAN_CONNECTED) ||
(chan->common.state == WAN_CONNECTING)){
S508_S514_lock(card, &smp_flags);
chan_disc(dev);
S508_S514_unlock(card, &smp_flags);
}
wanpipe_close(card);
S508_S514_lock(card, &smp_flags);
if (chan->bh_head){
int i;
struct sk_buff *skb;
for (i=0; i<(MAX_BH_BUFF+1); i++){
skb = ((bh_data_t *)&chan->bh_head[i])->skb;
if (skb != NULL){
dev_kfree_skb_any(skb);
}
}
kfree(chan->bh_head);
chan->bh_head=NULL;
}
S508_S514_unlock(card, &smp_flags);
/* If this is the last close, disconnect physical link */
if (!card->open_cnt){
S508_S514_lock(card, &smp_flags);
disconnect(card);
x25_set_intr_mode(card, 0);
S508_S514_unlock(card, &smp_flags);
}
/* Decrement the number of interfaces */
--card->u.x.no_dev;
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 net_device* dev,
unsigned short type, void* daddr, void* saddr,
unsigned len)
{
x25_channel_t* chan = dev->priv;
int hdr_len = dev->hard_header_len;
skb->protocol = htons(type);
if (!chan->protocol){
hdr_len = wanrouter_encapsulate(skb, dev, type);
if (hdr_len < 0){
hdr_len = 0;
skb->protocol = htons(0);
}
}
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 net_device *dev = skb->dev;
x25_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;
}
/*============================================================================
* Handle transmit timeout event from netif watchdog
*/
static void if_tx_timeout(struct net_device *dev)
{
x25_channel_t* chan = dev->priv;
sdla_t *card = chan->card;
/* 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->if_send_stat.if_send_tbusy_timeout;
printk (KERN_INFO "%s: Transmit timed out on %s\n",
card->devname, dev->name);
netif_wake_queue (dev);
}
/*=========================================================================
* Send a packet on a network interface.
* o set tbusy flag (marks start of the transmission).
* 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 net_device* dev)
{
x25_channel_t* chan = dev->priv;
sdla_t* card = chan->card;
TX25Status* status = card->flags;
int udp_type;
unsigned long smp_flags=0;
++chan->if_send_stat.if_send_entry;
netif_stop_queue(dev);
/* No need to check frame length, since socket code
* will perform the check for us */
chan->tick_counter = jiffies;
/* Critical region starts here */
S508_S514_lock(card, &smp_flags);
if (test_and_set_bit(SEND_CRIT, (void*)&card->wandev.critical)){
printk(KERN_INFO "Hit critical in if_send()! %lx\n",card->wandev.critical);
goto if_send_crit_exit;
}
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, dev, skb,
chan->common.lcn)) {
status->imask |= INTR_ON_TIMER;
if (udp_type == UDP_XPIPE_TYPE){
chan->if_send_stat.if_send_PIPE_request++;
}
}
netif_start_queue(dev);
clear_bit(SEND_CRIT,(void*)&card->wandev.critical);
S508_S514_unlock(card, &smp_flags);
return 0;
}
if (chan->transmit_length){
//FIXME: This check doesn't make sense any more
if (chan->common.state != WAN_CONNECTED){
chan->transmit_length=0;
atomic_set(&chan->common.driver_busy,0);
}else{
netif_stop_queue(dev);
++card->u.x.tx_interrupts_pending;
status->imask |= INTR_ON_TX_FRAME;
clear_bit(SEND_CRIT,(void*)&card->wandev.critical);
S508_S514_unlock(card, &smp_flags);
return 1;
}
}
if (card->wandev.state != WAN_CONNECTED){
++chan->ifstats.tx_dropped;
++card->wandev.stats.tx_dropped;
++chan->if_send_stat.if_send_wan_disconnected;
}else if ( chan->protocol && (chan->protocol != skb->protocol)){
printk(KERN_INFO
"%s: unsupported Ethertype 0x%04X on interface %s!\n",
chan->name, htons(skb->protocol), dev->name);
printk(KERN_INFO "PROTO %Xn", htons(chan->protocol));
++chan->ifstats.tx_errors;
++chan->ifstats.tx_dropped;
++card->wandev.stats.tx_dropped;
++chan->if_send_stat.if_send_protocol_error;
}else switch (chan->common.state){
case WAN_DISCONNECTED:
/* Try to establish connection. If succeded, then start
* transmission, else drop a packet.
*/
if (chan->common.usedby == API){
++chan->ifstats.tx_dropped;
++card->wandev.stats.tx_dropped;
break;
}else{
if (chan_connect(dev) != 0){
++chan->ifstats.tx_dropped;
++card->wandev.stats.tx_dropped;
break;
}
}
/* fall through */
case WAN_CONNECTED:
if( skb->protocol == htons(ETH_P_IPX)) {
if(chan->enable_IPX) {
switch_net_numbers( skb->data,
chan->network_number, 0);
} else {
++card->wandev.stats.tx_dropped;
++chan->ifstats.tx_dropped;
++chan->if_send_stat.if_send_protocol_error;
goto if_send_crit_exit;
}
}
/* We never drop here, if cannot send than, copy
* a packet into a transmit buffer
*/
chan_send(dev, skb->data, skb->len, 0);
break;
default:
++chan->ifstats.tx_dropped;
++card->wandev.stats.tx_dropped;
break;
}
if_send_crit_exit:
dev_kfree_skb_any(skb);
netif_start_queue(dev);
clear_bit(SEND_CRIT,(void*)&card->wandev.critical);
S508_S514_unlock(card, &smp_flags);
return 0;
}
/*============================================================================
* Setup so that a frame can be transmitted on the occurrence of a transmit
* interrupt.
*===========================================================================*/
static void setup_for_delayed_transmit(struct net_device* dev, void* buf,
unsigned len)
{
x25_channel_t* chan = dev->priv;
sdla_t* card = chan->card;
TX25Status* status = card->flags;
++chan->if_send_stat.if_send_adptr_bfrs_full;
if(chan->transmit_length) {
printk(KERN_INFO "%s: Error, transmit length set in delayed transmit!\n",
card->devname);
return;
}
if (chan->common.usedby == API){
if (len > X25_CHAN_MTU+sizeof(x25api_hdr_t)) {
++chan->ifstats.tx_dropped;
++card->wandev.stats.tx_dropped;
printk(KERN_INFO "%s: Length is too big for delayed transmit\n",
card->devname);
return;
}
}else{
if (len > X25_MAX_DATA) {
++chan->ifstats.tx_dropped;
++card->wandev.stats.tx_dropped;
printk(KERN_INFO "%s: Length is too big for delayed transmit\n",
card->devname);
return;
}
}
chan->transmit_length = len;
atomic_set(&chan->common.driver_busy,1);
memcpy(chan->transmit_buffer, buf, len);
++chan->if_send_stat.if_send_tx_int_enabled;
/* Enable Transmit Interrupt */
++card->u.x.tx_interrupts_pending;
status->imask |= INTR_ON_TX_FRAME;
}
/*===============================================================
* net_device_stats
*
* Get ethernet-style interface statistics.
* Return a pointer to struct enet_statistics.
*
*==============================================================*/
static struct net_device_stats *if_stats(struct net_device* dev)
{
x25_channel_t *chan = dev->priv;
if(chan == NULL)
return NULL;
return &chan->ifstats;
}
/*
* Interrupt Handlers
*/
/*
* X.25 Interrupt Service Routine.
*/
static void wpx_isr (sdla_t* card)
{
TX25Status* status = card->flags;
card->in_isr = 1;
++card->statistics.isr_entry;
if (test_bit(PERI_CRIT,(void*)&card->wandev.critical)){
card->in_isr=0;
status->iflags = 0;
return;
}
if (test_bit(SEND_CRIT, (void*)&card->wandev.critical)){
printk(KERN_INFO "%s: wpx_isr: wandev.critical set to 0x%02lx, int type = 0x%02x\n",
card->devname, card->wandev.critical, status->iflags);
card->in_isr = 0;
status->iflags = 0;
return;
}
/* For all interrupts set the critical flag to CRITICAL_RX_INTR.
* If the if_send routine is called with this flag set it will set
* the enable transmit flag to 1. (for a delayed interrupt)
*/
switch (status->iflags){
case RX_INTR_PENDING: /* receive interrupt */
rx_intr(card);
break;
case TX_INTR_PENDING: /* transmit interrupt */
tx_intr(card);
break;
case MODEM_INTR_PENDING: /* modem status interrupt */
status_intr(card);
break;
case X25_ASY_TRANS_INTR_PENDING: /* network event interrupt */
event_intr(card);
break;
case TIMER_INTR_PENDING:
timer_intr(card);
break;
default: /* unwanted interrupt */
spur_intr(card);
}
card->in_isr = 0;
status->iflags = 0; /* clear interrupt condition */
}
/*
* Receive interrupt handler.
* This routine handles fragmented IP packets using M-bit according to the
* RFC1356.
* o map ligical channel number to network interface.
* o allocate socket buffer or append received packet to the existing one.
* o if M-bit is reset (i.e. it's the last packet in a sequence) then
* decapsulate packet and pass socket buffer to the protocol stack.
*
* Notes:
* 1. When allocating a socket buffer, if M-bit is set then more data is
* coming and we have to allocate buffer for the maximum IP packet size
* expected on this channel.
* 2. If something goes wrong and X.25 packet has to be dropped (e.g. no
* socket buffers available) the whole packet sequence must be discarded.
*/
static void rx_intr (sdla_t* card)
{
TX25Mbox* rxmb = card->rxmb;
unsigned lcn = rxmb->cmd.lcn;
struct net_device* dev = find_channel(card,lcn);
x25_channel_t* chan;
struct sk_buff* skb=NULL;
if (dev == NULL){
/* Invalid channel, discard packet */
printk(KERN_INFO "%s: receiving on orphaned LCN %d!\n",
card->devname, lcn);
return;
}
chan = dev->priv;
chan->i_timeout_sofar = jiffies;
/* Copy the data from the board, into an
* skb buffer
*/
if (wanpipe_pull_data_in_skb(card,dev,&skb)){
++chan->ifstats.rx_dropped;
++card->wandev.stats.rx_dropped;
++chan->rx_intr_stat.rx_intr_no_socket;
++chan->rx_intr_stat.rx_intr_bfr_not_passed_to_stack;
return;
}
dev->last_rx = jiffies; /* timestamp */
/* ------------ API ----------------*/
if (chan->common.usedby == API){
if (bh_enqueue(dev, skb)){
++chan->ifstats.rx_dropped;
++card->wandev.stats.rx_dropped;
++chan->rx_intr_stat.rx_intr_bfr_not_passed_to_stack;
dev_kfree_skb_any(skb);
return;
}
++chan->ifstats.rx_packets;
chan->ifstats.rx_bytes += skb->len;
chan->rx_skb = NULL;
if (!test_and_set_bit(0, &chan->tq_working)){
wanpipe_queue_work(&chan->common.wanpipe_work);
}
return;
}
/* ------------- WANPIPE -------------------*/
/* set rx_skb to NULL so we won't access it later when kernel already owns it */
chan->rx_skb=NULL;
/* Decapsulate packet, if necessary */
if (!skb->protocol && !wanrouter_type_trans(skb, dev)){
/* can't decapsulate packet */
dev_kfree_skb_any(skb);
++chan->ifstats.rx_errors;
++chan->ifstats.rx_dropped;
++card->wandev.stats.rx_dropped;
++chan->rx_intr_stat.rx_intr_bfr_not_passed_to_stack;
}else{
if( handle_IPXWAN(skb->data, chan->name,
chan->enable_IPX, chan->network_number,
skb->protocol)){
if( chan->enable_IPX ){
if(chan_send(dev, skb->data, skb->len,0)){
chan->tx_skb = skb;
}else{
dev_kfree_skb_any(skb);
++chan->rx_intr_stat.rx_intr_bfr_not_passed_to_stack;
}
}else{
/* increment IPX packet dropped statistic */
++chan->ifstats.rx_dropped;
++chan->rx_intr_stat.rx_intr_bfr_not_passed_to_stack;
}
}else{
skb->mac.raw = skb->data;
chan->ifstats.rx_bytes += skb->len;
++chan->ifstats.rx_packets;
++chan->rx_intr_stat.rx_intr_bfr_passed_to_stack;
netif_rx(skb);
}
}
return;
}
static int wanpipe_pull_data_in_skb(sdla_t *card, struct net_device *dev,
struct sk_buff **skb)
{
void *bufptr;
TX25Mbox* rxmb = card->rxmb;
unsigned len = rxmb->cmd.length; /* packet length */
unsigned qdm = rxmb->cmd.qdm; /* Q,D and M bits */
x25_channel_t *chan = dev->priv;
struct sk_buff *new_skb = *skb;
if (chan->common.usedby == WANPIPE){
if (chan->drop_sequence){
if (!(qdm & 0x01)){
chan->drop_sequence = 0;
}
return 1;
}
new_skb = chan->rx_skb;
}else{
/* Add on the API header to the received
* data
*/
len += sizeof(x25api_hdr_t);
}
if (new_skb == NULL){
int bufsize;
if (chan->common.usedby == WANPIPE){
bufsize = (qdm & 0x01) ? dev->mtu : len;
}else{
bufsize = len;
}
/* Allocate new socket buffer */
new_skb = dev_alloc_skb(bufsize + dev->hard_header_len);
if (new_skb == NULL){
printk(KERN_INFO "%s: no socket buffers available!\n",
card->devname);
chan->drop_sequence = 1; /* set flag */
++chan->ifstats.rx_dropped;
return 1;
}
}
if (skb_tailroom(new_skb) < len){
/* No room for the packet. Call off the whole thing! */
dev_kfree_skb_any(new_skb);
if (chan->common.usedby == WANPIPE){
chan->rx_skb = NULL;
if (qdm & 0x01){
chan->drop_sequence = 1;
}
}
printk(KERN_INFO "%s: unexpectedly long packet sequence "
"on interface %s!\n", card->devname, dev->name);
++chan->ifstats.rx_length_errors;
return 1;
}
bufptr = skb_put(new_skb,len);
if (chan->common.usedby == API){
/* Fill in the x25api header
*/
x25api_t * api_data = (x25api_t*)bufptr;
api_data->hdr.qdm = rxmb->cmd.qdm;
api_data->hdr.cause = rxmb->cmd.cause;
api_data->hdr.diagn = rxmb->cmd.diagn;
api_data->hdr.length = rxmb->cmd.length;
memcpy(api_data->data, rxmb->data, rxmb->cmd.length);
}else{
memcpy(bufptr, rxmb->data, len);
}
new_skb->dev = dev;
if (chan->common.usedby == API){
new_skb->mac.raw = new_skb->data;
new_skb->protocol = htons(X25_PROT);
new_skb->pkt_type = WAN_PACKET_DATA;
}else{
new_skb->protocol = chan->protocol;
chan->rx_skb = new_skb;
}
/* If qdm bit is set, more data is coming
* thus, exit and wait for more data before
* sending the packet up. (Used by router only)
*/
if ((qdm & 0x01) && (chan->common.usedby == WANPIPE))
return 1;
*skb = new_skb;
return 0;
}
/*===============================================================
* tx_intr
*
* Transmit interrupt handler.
* For each dev, check that there is something to send.
* If data available, transmit.
*
*===============================================================*/
static void tx_intr (sdla_t* card)
{
struct net_device *dev;
TX25Status* status = card->flags;
unsigned char more_to_tx=0;
x25_channel_t *chan=NULL;
int i=0;
if (card->u.x.tx_dev == NULL){
card->u.x.tx_dev = card->wandev.dev;
}
dev = card->u.x.tx_dev;
for (;;){
chan = dev->priv;
if (chan->transmit_length){
/* Device was set to transmit, check if the TX
* buffers are available
*/
if (chan->common.state != WAN_CONNECTED){
chan->transmit_length = 0;
atomic_set(&chan->common.driver_busy,0);
chan->tx_offset=0;
if (netif_queue_stopped(dev)){
if (chan->common.usedby == API){
netif_start_queue(dev);
wakeup_sk_bh(dev);
}else{
netif_wake_queue(dev);
}
}
dev = move_dev_to_next(card,dev);
break;
}
if ((status->cflags[chan->ch_idx] & 0x40 || card->u.x.LAPB_hdlc) &&
(*card->u.x.hdlc_buf_status & 0x40) ){
/* Tx buffer available, we can send */
if (tx_intr_send(card, dev)){
more_to_tx=1;
}
/* If more than one interface present, move the
* device pointer to the next interface, so on the
* next TX interrupt we will try sending from it.
*/
dev = move_dev_to_next(card,dev);
break;
}else{
/* Tx buffers not available, but device set
* the TX interrupt. Set more_to_tx and try
* to transmit for other devices.
*/
more_to_tx=1;
dev = move_dev_to_next(card,dev);
}
}else{
/* This device was not set to transmit,
* go to next
*/
dev = move_dev_to_next(card,dev);
}
if (++i == card->u.x.no_dev){
if (!more_to_tx){
DBG_PRINTK(KERN_INFO "%s: Nothing to Send in TX INTR\n",
card->devname);
}
break;
}
} //End of FOR
card->u.x.tx_dev = dev;
if (!more_to_tx){
/* if any other interfaces have transmit interrupts pending, */
/* do not disable the global transmit interrupt */
if (!(--card->u.x.tx_interrupts_pending)){
status->imask &= ~INTR_ON_TX_FRAME;
}
}
return;
}
/*===============================================================
* move_dev_to_next
*
*
*===============================================================*/
struct net_device *move_dev_to_next(sdla_t *card, struct net_device *dev)
{
if (card->u.x.no_dev != 1){
if (!*((struct net_device **)dev->priv))
return card->wandev.dev;
else
return *((struct net_device **)dev->priv);
}
return dev;
}
/*===============================================================
* tx_intr_send
*
*
*===============================================================*/
static int tx_intr_send(sdla_t *card, struct net_device *dev)
{
x25_channel_t* chan = dev->priv;
if (chan_send (dev,chan->transmit_buffer,chan->transmit_length,1)){
/* Packet was split up due to its size, do not disable
* tx_intr
*/
return 1;
}
chan->transmit_length=0;
atomic_set(&chan->common.driver_busy,0);
chan->tx_offset=0;
/* If we are in API mode, wakeup the
* sock BH handler, not the NET_BH */
if (netif_queue_stopped(dev)){
if (chan->common.usedby == API){
netif_start_queue(dev);
wakeup_sk_bh(dev);
}else{
netif_wake_queue(dev);
}
}
return 0;
}
/*===============================================================
* timer_intr
*
* Timer interrupt handler.
* Check who called the timer interrupt and perform
* action accordingly.
*
*===============================================================*/
static void timer_intr (sdla_t *card)
{
TX25Status* status = card->flags;
if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_CMD_EXEC){
if (timer_intr_cmd_exec(card) == 0){
card->u.x.timer_int_enabled &=
~TMR_INT_ENABLED_CMD_EXEC;
}
}else if(card->u.x.timer_int_enabled & TMR_INT_ENABLED_UDP_PKT) {
if ((*card->u.x.hdlc_buf_status & 0x40) &&
card->u.x.udp_type == UDP_XPIPE_TYPE){
if(process_udp_mgmt_pkt(card)) {
card->u.x.timer_int_enabled &=
~TMR_INT_ENABLED_UDP_PKT;
}
}
}else if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_POLL_ACTIVE) {
struct net_device *dev = card->u.x.poll_device;
x25_channel_t *chan = NULL;
if (!dev){
card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_POLL_ACTIVE;
return;
}
chan = dev->priv;
printk(KERN_INFO
"%s: Closing down Idle link %s on LCN %d\n",
card->devname,chan->name,chan->common.lcn);
chan->i_timeout_sofar = jiffies;
chan_disc(dev);
card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_POLL_ACTIVE;
card->u.x.poll_device=NULL;
}else if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_POLL_CONNECT_ON) {
wanpipe_set_state(card, WAN_CONNECTED);
if (card->u.x.LAPB_hdlc){
struct net_device *dev = card->wandev.dev;
set_chan_state(dev,WAN_CONNECTED);
send_delayed_cmd_result(card,dev,card->mbox);
}
/* 0x8F enable all interrupts */
x25_set_intr_mode(card, INTR_ON_RX_FRAME|
INTR_ON_TX_FRAME|
INTR_ON_MODEM_STATUS_CHANGE|
//INTR_ON_COMMAND_COMPLETE|
X25_ASY_TRANS_INTR_PENDING |
INTR_ON_TIMER |
DIRECT_RX_INTR_USAGE
);
status->imask &= ~INTR_ON_TX_FRAME; /* mask Tx interrupts */
card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_POLL_CONNECT_ON;
}else if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_POLL_CONNECT_OFF) {
//printk(KERN_INFO "Poll connect, Turning OFF\n");
disconnect(card);
card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_POLL_CONNECT_OFF;
}else if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_POLL_DISCONNECT) {
//printk(KERN_INFO "POll disconnect, trying to connect\n");
connect(card);
card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_POLL_DISCONNECT;
}else if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_UPDATE){
if (*card->u.x.hdlc_buf_status & 0x40){
x25_get_err_stats(card);
x25_get_stats(card);
card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE;
}
}
if(!card->u.x.timer_int_enabled){
//printk(KERN_INFO "Turning Timer Off \n");
status->imask &= ~INTR_ON_TIMER;
}
}
/*====================================================================
* Modem status interrupt handler.
*===================================================================*/
static void status_intr (sdla_t* card)
{
/* Added to avoid Modem status message flooding */
static TX25ModemStatus last_stat;
TX25Mbox* mbox = card->mbox;
TX25ModemStatus *modem_status;
struct net_device *dev;
x25_channel_t *chan;
int err;
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
mbox->cmd.command = X25_READ_MODEM_STATUS;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
if (err){
x25_error(card, err, X25_READ_MODEM_STATUS, 0);
}else{
modem_status = (TX25ModemStatus*)mbox->data;
/* Check if the last status was the same
* if it was, do NOT print message again */
if (last_stat.status != modem_status->status){
printk(KERN_INFO "%s: Modem Status Change: DCD=%s, CTS=%s\n",
card->devname,DCD(modem_status->status),CTS(modem_status->status));
last_stat.status = modem_status->status;
if (card->u.x.oob_on_modem){
mbox->cmd.pktType = mbox->cmd.command;
mbox->cmd.result = 0x08;
/* Send a OOB to all connected sockets */
for (dev = card->wandev.dev; dev;
dev = *((struct net_device**)dev->priv)) {
chan=dev->priv;
if (chan->common.usedby == API){
send_oob_msg(card,dev,mbox);
}
}
/* The modem OOB message will probably kill the
* the link. If we don't clear the flag here,
* a deadlock could occur */
if (atomic_read(&card->u.x.command_busy)){
atomic_set(&card->u.x.command_busy,0);
}
}
}
}
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
mbox->cmd.command = X25_HDLC_LINK_STATUS;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
if (err){
x25_error(card, err, X25_HDLC_LINK_STATUS, 0);
}
}
/*====================================================================
* Network event interrupt handler.
*===================================================================*/
static void event_intr (sdla_t* card)
{
x25_fetch_events(card);
}
/*====================================================================
* Spurious interrupt handler.
* o print a warning
* o
*====================================================================*/
static void spur_intr (sdla_t* card)
{
printk(KERN_INFO "%s: spurious interrupt!\n", card->devname);
}
/*
* Background Polling Routines
*/
/*====================================================================
* Main polling routine.
* This routine is repeatedly called by the WANPIPE 'thread' to allow for
* time-dependent housekeeping work.
*
* Notes:
* 1. This routine may be called on interrupt context with all interrupts
* enabled. Beware!
*====================================================================*/
static void wpx_poll (sdla_t *card)
{
if (!card->wandev.dev){
goto wpx_poll_exit;
}
if (card->open_cnt != card->u.x.num_of_ch){
goto wpx_poll_exit;
}
if (test_bit(PERI_CRIT,&card->wandev.critical)){
goto wpx_poll_exit;
}
if (test_bit(SEND_CRIT,&card->wandev.critical)){
goto wpx_poll_exit;
}
switch(card->wandev.state){
case WAN_CONNECTED:
poll_active(card);
break;
case WAN_CONNECTING:
poll_connecting(card);
break;
case WAN_DISCONNECTED:
poll_disconnected(card);
break;
}
wpx_poll_exit:
clear_bit(POLL_CRIT,&card->wandev.critical);
return;
}
static void trigger_x25_poll(sdla_t *card)
{
schedule_work(&card->u.x.x25_poll_work);
}
/*====================================================================
* Handle physical link establishment phase.
* o if connection timed out, disconnect the link.
*===================================================================*/
static void poll_connecting (sdla_t* card)
{
volatile TX25Status* status = card->flags;
if (status->gflags & X25_HDLC_ABM){
timer_intr_exec (card, TMR_INT_ENABLED_POLL_CONNECT_ON);
}else if ((jiffies - card->state_tick) > CONNECT_TIMEOUT){
timer_intr_exec (card, TMR_INT_ENABLED_POLL_CONNECT_OFF);
}
}
/*====================================================================
* Handle physical link disconnected phase.
* o if hold-down timeout has expired and there are open interfaces,
* connect link.
*===================================================================*/
static void poll_disconnected (sdla_t* card)
{
struct net_device *dev;
x25_channel_t *chan;
TX25Status* status = card->flags;
if (!card->u.x.LAPB_hdlc && card->open_cnt &&
((jiffies - card->state_tick) > HOLD_DOWN_TIME)){
timer_intr_exec(card, TMR_INT_ENABLED_POLL_DISCONNECT);
}
if ((dev=card->wandev.dev) == NULL)
return;
if ((chan=dev->priv) == NULL)
return;
if (chan->common.usedby == API &&
atomic_read(&chan->common.command) &&
card->u.x.LAPB_hdlc){
if (!(card->u.x.timer_int_enabled & TMR_INT_ENABLED_CMD_EXEC))
card->u.x.timer_int_enabled |= TMR_INT_ENABLED_CMD_EXEC;
if (!(status->imask & INTR_ON_TIMER))
status->imask |= INTR_ON_TIMER;
}
}
/*====================================================================
* Handle active link phase.
* o fetch X.25 asynchronous events.
* o kick off transmission on all interfaces.
*===================================================================*/
static void poll_active (sdla_t* card)
{
struct net_device* dev;
TX25Status* status = card->flags;
for (dev = card->wandev.dev; dev;
dev = *((struct net_device **)dev->priv)){
x25_channel_t* chan = dev->priv;
/* If SVC has been idle long enough, close virtual circuit */
if ( chan->common.svc &&
chan->common.state == WAN_CONNECTED &&
chan->common.usedby == WANPIPE ){
if( (jiffies - chan->i_timeout_sofar) / HZ > chan->idle_timeout ){
/* Close svc */
card->u.x.poll_device=dev;
timer_intr_exec (card, TMR_INT_ENABLED_POLL_ACTIVE);
}
}
#ifdef PRINT_DEBUG
chan->ifstats.tx_compressed = atomic_read(&chan->common.command);
chan->ifstats.tx_errors = chan->common.state;
chan->ifstats.rx_fifo_errors = atomic_read(&card->u.x.command_busy);
++chan->ifstats.tx_bytes;
chan->ifstats.rx_fifo_errors=atomic_read(&chan->common.disconnect);
chan->ifstats.multicast=atomic_read(&chan->bh_buff_used);
chan->ifstats.rx_length_errors=*card->u.x.hdlc_buf_status;
#endif
if (chan->common.usedby == API &&
atomic_read(&chan->common.command) &&
!card->u.x.LAPB_hdlc){
if (!(card->u.x.timer_int_enabled & TMR_INT_ENABLED_CMD_EXEC))
card->u.x.timer_int_enabled |= TMR_INT_ENABLED_CMD_EXEC;
if (!(status->imask & INTR_ON_TIMER))
status->imask |= INTR_ON_TIMER;
}
if ((chan->common.usedby == API) &&
atomic_read(&chan->common.disconnect)){
if (chan->common.state == WAN_DISCONNECTED){
atomic_set(&chan->common.disconnect,0);
return;
}
atomic_set(&chan->common.command,X25_CLEAR_CALL);
if (!(card->u.x.timer_int_enabled & TMR_INT_ENABLED_CMD_EXEC))
card->u.x.timer_int_enabled |= TMR_INT_ENABLED_CMD_EXEC;
if (!(status->imask & INTR_ON_TIMER))
status->imask |= INTR_ON_TIMER;
}
}
}
static void timer_intr_exec(sdla_t *card, unsigned char TYPE)
{
TX25Status* status = card->flags;
card->u.x.timer_int_enabled |= TYPE;
if (!(status->imask & INTR_ON_TIMER))
status->imask |= INTR_ON_TIMER;
}
/*====================================================================
* SDLA Firmware-Specific Functions
*
* Almost all X.25 commands can unexpetedly fail due to so called 'X.25
* asynchronous events' such as restart, interrupt, incoming call request,
* call clear request, etc. They can't be ignored and have to be delt with
* immediately. To tackle with this problem we execute each interface
* command in a loop until good return code is received or maximum number
* of retries is reached. Each interface command returns non-zero return
* code, an asynchronous event/error handler x25_error() is called.
*====================================================================*/
/*====================================================================
* Read X.25 firmware version.
* Put code version as ASCII string in str.
*===================================================================*/
static int x25_get_version (sdla_t* card, char* str)
{
TX25Mbox* mbox = card->mbox;
int retry = MAX_CMD_RETRY;
int err;
do
{
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
mbox->cmd.command = X25_READ_CODE_VERSION;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && retry-- &&
x25_error(card, err, X25_READ_CODE_VERSION, 0));
if (!err && str)
{
int len = mbox->cmd.length;
memcpy(str, mbox->data, len);
str[len] = '\0';
}
return err;
}
/*====================================================================
* Configure adapter.
*===================================================================*/
static int x25_configure (sdla_t* card, TX25Config* conf)
{
TX25Mbox* mbox = card->mbox;
int retry = MAX_CMD_RETRY;
int err;
do{
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
memcpy(mbox->data, (void*)conf, sizeof(TX25Config));
mbox->cmd.length = sizeof(TX25Config);
mbox->cmd.command = X25_SET_CONFIGURATION;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && retry-- && x25_error(card, err, X25_SET_CONFIGURATION, 0));
return err;
}
/*====================================================================
* Configure adapter for HDLC only.
*===================================================================*/
static int hdlc_configure (sdla_t* card, TX25Config* conf)
{
TX25Mbox* mbox = card->mbox;
int retry = MAX_CMD_RETRY;
int err;
do{
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
memcpy(mbox->data, (void*)conf, sizeof(TX25Config));
mbox->cmd.length = sizeof(TX25Config);
mbox->cmd.command = X25_HDLC_SET_CONFIG;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && retry-- && x25_error(card, err, X25_SET_CONFIGURATION, 0));
return err;
}
static int set_hdlc_level (sdla_t* card)
{
TX25Mbox* mbox = card->mbox;
int retry = MAX_CMD_RETRY;
int err;
do{
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
mbox->cmd.command = SET_PROTOCOL_LEVEL;
mbox->cmd.length = 1;
mbox->data[0] = HDLC_LEVEL; //| DO_HDLC_LEVEL_ERROR_CHECKING;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && retry-- && x25_error(card, err, SET_PROTOCOL_LEVEL, 0));
return err;
}
/*====================================================================
* Get communications error statistics.
*====================================================================*/
static int x25_get_err_stats (sdla_t* card)
{
TX25Mbox* mbox = card->mbox;
int retry = MAX_CMD_RETRY;
int err;
do
{
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
mbox->cmd.command = X25_HDLC_READ_COMM_ERR;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && retry-- && x25_error(card, err, X25_HDLC_READ_COMM_ERR, 0));
if (!err)
{
THdlcCommErr* stats = (void*)mbox->data;
card->wandev.stats.rx_over_errors = stats->rxOverrun;
card->wandev.stats.rx_crc_errors = stats->rxBadCrc;
card->wandev.stats.rx_missed_errors = stats->rxAborted;
card->wandev.stats.tx_aborted_errors = stats->txAborted;
}
return err;
}
/*====================================================================
* Get protocol statistics.
*===================================================================*/
static int x25_get_stats (sdla_t* card)
{
TX25Mbox* mbox = card->mbox;
int retry = MAX_CMD_RETRY;
int err;
do
{
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
mbox->cmd.command = X25_READ_STATISTICS;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && retry-- && x25_error(card, err, X25_READ_STATISTICS, 0)) ;
if (!err)
{
TX25Stats* stats = (void*)mbox->data;
card->wandev.stats.rx_packets = stats->rxData;
card->wandev.stats.tx_packets = stats->txData;
}
return err;
}
/*====================================================================
* Close HDLC link.
*===================================================================*/
static int x25_close_hdlc (sdla_t* card)
{
TX25Mbox* mbox = card->mbox;
int retry = MAX_CMD_RETRY;
int err;
do
{
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
mbox->cmd.command = X25_HDLC_LINK_CLOSE;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && retry-- && x25_error(card, err, X25_HDLC_LINK_CLOSE, 0));
return err;
}
/*====================================================================
* Open HDLC link.
*===================================================================*/
static int x25_open_hdlc (sdla_t* card)
{
TX25Mbox* mbox = card->mbox;
int retry = MAX_CMD_RETRY;
int err;
do
{
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
mbox->cmd.command = X25_HDLC_LINK_OPEN;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && retry-- && x25_error(card, err, X25_HDLC_LINK_OPEN, 0));
return err;
}
/*=====================================================================
* Setup HDLC link.
*====================================================================*/
static int x25_setup_hdlc (sdla_t* card)
{
TX25Mbox* mbox = card->mbox;
int retry = MAX_CMD_RETRY;
int err;
do
{
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
mbox->cmd.command = X25_HDLC_LINK_SETUP;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && retry-- && x25_error(card, err, X25_HDLC_LINK_SETUP, 0));
return err;
}
/*====================================================================
* Set (raise/drop) DTR.
*===================================================================*/
static int x25_set_dtr (sdla_t* card, int dtr)
{
TX25Mbox* mbox = card->mbox;
int retry = MAX_CMD_RETRY;
int err;
do
{
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
mbox->data[0] = 0;
mbox->data[2] = 0;
mbox->data[1] = dtr ? 0x02 : 0x01;
mbox->cmd.length = 3;
mbox->cmd.command = X25_SET_GLOBAL_VARS;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && retry-- && x25_error(card, err, X25_SET_GLOBAL_VARS, 0));
return err;
}
/*====================================================================
* Set interrupt mode.
*===================================================================*/
static int x25_set_intr_mode (sdla_t* card, int mode)
{
TX25Mbox* mbox = card->mbox;
int retry = MAX_CMD_RETRY;
int err;
do
{
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
mbox->data[0] = mode;
if (card->hw.fwid == SFID_X25_508){
mbox->data[1] = card->hw.irq;
mbox->data[2] = 2;
mbox->cmd.length = 3;
}else {
mbox->cmd.length = 1;
}
mbox->cmd.command = X25_SET_INTERRUPT_MODE;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && retry-- && x25_error(card, err, X25_SET_INTERRUPT_MODE, 0));
return err;
}
/*====================================================================
* Read X.25 channel configuration.
*===================================================================*/
static int x25_get_chan_conf (sdla_t* card, x25_channel_t* chan)
{
TX25Mbox* mbox = card->mbox;
int retry = MAX_CMD_RETRY;
int lcn = chan->common.lcn;
int err;
do{
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
mbox->cmd.lcn = lcn;
mbox->cmd.command = X25_READ_CHANNEL_CONFIG;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && retry-- && x25_error(card, err, X25_READ_CHANNEL_CONFIG, lcn));
if (!err)
{
TX25Status* status = card->flags;
/* calculate an offset into the array of status bytes */
if (card->u.x.hi_svc <= X25_MAX_CHAN){
chan->ch_idx = lcn - 1;
}else{
int offset;
/* FIX: Apr 14 2000 : Nenad Corbic
* The data field was being compared to 0x1F using
* '&&' instead of '&'.
* This caused X25API to fail for LCNs greater than 255.
*/
switch (mbox->data[0] & 0x1F)
{
case 0x01:
offset = status->pvc_map; break;
case 0x03:
offset = status->icc_map; break;
case 0x07:
offset = status->twc_map; break;
case 0x0B:
offset = status->ogc_map; break;
default:
offset = 0;
}
chan->ch_idx = lcn - 1 - offset;
}
/* get actual transmit packet size on this channel */
switch(mbox->data[1] & 0x38)
{
case 0x00:
chan->tx_pkt_size = 16;
break;
case 0x08:
chan->tx_pkt_size = 32;
break;
case 0x10:
chan->tx_pkt_size = 64;
break;
case 0x18:
chan->tx_pkt_size = 128;
break;
case 0x20:
chan->tx_pkt_size = 256;
break;
case 0x28:
chan->tx_pkt_size = 512;
break;
case 0x30:
chan->tx_pkt_size = 1024;
break;
}
if (card->u.x.logging)
printk(KERN_INFO "%s: X.25 packet size on LCN %d is %d.\n",
card->devname, lcn, chan->tx_pkt_size);
}
return err;
}
/*====================================================================
* Place X.25 call.
*====================================================================*/
static int x25_place_call (sdla_t* card, x25_channel_t* chan)
{
TX25Mbox* mbox = card->mbox;
int retry = MAX_CMD_RETRY;
int err;
char str[64];
if (chan->protocol == htons(ETH_P_IP)){
sprintf(str, "-d%s -uCC", chan->addr);
}else if (chan->protocol == htons(ETH_P_IPX)){
sprintf(str, "-d%s -u800000008137", chan->addr);
}
do
{
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
strcpy(mbox->data, str);
mbox->cmd.length = strlen(str);
mbox->cmd.command = X25_PLACE_CALL;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && retry-- && x25_error(card, err, X25_PLACE_CALL, 0));
if (!err){
bind_lcn_to_dev (card, chan->dev, mbox->cmd.lcn);
}
return err;
}
/*====================================================================
* Accept X.25 call.
*====================================================================*/
static int x25_accept_call (sdla_t* card, int lcn, int qdm)
{
TX25Mbox* mbox = card->mbox;
int retry = MAX_CMD_RETRY;
int err;
do
{
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
mbox->cmd.lcn = lcn;
mbox->cmd.qdm = qdm;
mbox->cmd.command = X25_ACCEPT_CALL;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && retry-- && x25_error(card, err, X25_ACCEPT_CALL, lcn));
return err;
}
/*====================================================================
* Clear X.25 call.
*====================================================================*/
static int x25_clear_call (sdla_t* card, int lcn, int cause, int diagn)
{
TX25Mbox* mbox = card->mbox;
int retry = MAX_CMD_RETRY;
int err;
do
{
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
mbox->cmd.lcn = lcn;
mbox->cmd.cause = cause;
mbox->cmd.diagn = diagn;
mbox->cmd.command = X25_CLEAR_CALL;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && retry-- && x25_error(card, err, X25_CLEAR_CALL, lcn));
return err;
}
/*====================================================================
* Send X.25 data packet.
*====================================================================*/
static int x25_send (sdla_t* card, int lcn, int qdm, int len, void* buf)
{
TX25Mbox* mbox = card->mbox;
int retry = MAX_CMD_RETRY;
int err;
unsigned char cmd;
if (card->u.x.LAPB_hdlc)
cmd = X25_HDLC_WRITE;
else
cmd = X25_WRITE;
do
{
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
memcpy(mbox->data, buf, len);
mbox->cmd.length = len;
mbox->cmd.lcn = lcn;
if (card->u.x.LAPB_hdlc){
mbox->cmd.pf = qdm;
}else{
mbox->cmd.qdm = qdm;
}
mbox->cmd.command = cmd;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && retry-- && x25_error(card, err, cmd , lcn));
/* If buffers are busy the return code for LAPB HDLC is
* 1. The above functions are looking for return code
* of X25RES_NOT_READY if busy. */
if (card->u.x.LAPB_hdlc && err == 1){
err = X25RES_NOT_READY;
}
return err;
}
/*====================================================================
* Fetch X.25 asynchronous events.
*===================================================================*/
static int x25_fetch_events (sdla_t* card)
{
TX25Status* status = card->flags;
TX25Mbox* mbox = card->mbox;
int err = 0;
if (status->gflags & 0x20)
{
memset(&mbox->cmd, 0, sizeof(TX25Cmd));
mbox->cmd.command = X25_IS_DATA_AVAILABLE;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
if (err) x25_error(card, err, X25_IS_DATA_AVAILABLE, 0);
}
return err;
}
/*====================================================================
* X.25 asynchronous event/error handler.
* This routine is called each time interface command returns
* non-zero return code to handle X.25 asynchronous events and
* common errors. Return non-zero to repeat command or zero to
* cancel it.
*
* Notes:
* 1. This function may be called recursively, as handling some of the
* asynchronous events (e.g. call request) requires execution of the
* interface command(s) that, in turn, may also return asynchronous
* events. To avoid re-entrancy problems we copy mailbox to dynamically
* allocated memory before processing events.
*====================================================================*/
static int x25_error (sdla_t* card, int err, int cmd, int lcn)
{
int retry = 1;
unsigned dlen = ((TX25Mbox*)card->mbox)->cmd.length;
TX25Mbox* mb;
mb = kmalloc(sizeof(TX25Mbox) + dlen, GFP_ATOMIC);
if (mb == NULL)
{
printk(KERN_ERR "%s: x25_error() out of memory!\n",
card->devname);
return 0;
}
memcpy(mb, card->mbox, sizeof(TX25Mbox) + dlen);
switch (err){
case X25RES_ASYNC_PACKET: /* X.25 asynchronous packet was received */
mb->data[dlen] = '\0';
switch (mb->cmd.pktType & 0x7F){
case ASE_CALL_RQST: /* incoming call */
retry = incoming_call(card, cmd, lcn, mb);
break;
case ASE_CALL_ACCEPTED: /* connected */
retry = call_accepted(card, cmd, lcn, mb);
break;
case ASE_CLEAR_RQST: /* call clear request */
retry = call_cleared(card, cmd, lcn, mb);
break;
case ASE_RESET_RQST: /* reset request */
printk(KERN_INFO "%s: X.25 reset request on LCN %d! "
"Cause:0x%02X Diagn:0x%02X\n",
card->devname, mb->cmd.lcn, mb->cmd.cause,
mb->cmd.diagn);
api_oob_event (card,mb);
break;
case ASE_RESTART_RQST: /* restart request */
retry = restart_event(card, cmd, lcn, mb);
break;
case ASE_CLEAR_CONFRM:
if (clear_confirm_event (card,mb))
break;
/* I use the goto statement here so if
* somebody inserts code between the
* case and default, we will not have
* ghost problems */
goto dflt_1;
default:
dflt_1:
printk(KERN_INFO "%s: X.25 event 0x%02X on LCN %d! "
"Cause:0x%02X Diagn:0x%02X\n",
card->devname, mb->cmd.pktType,
mb->cmd.lcn, mb->cmd.cause, mb->cmd.diagn);
}
break;
case X25RES_PROTO_VIOLATION: /* X.25 protocol violation indication */
/* Bug Fix: Mar 14 2000
* The Protocol violation error conditions were
* not handled previously */
switch (mb->cmd.pktType & 0x7F){
case PVE_CLEAR_RQST: /* Clear request */
retry = call_cleared(card, cmd, lcn, mb);
break;
case PVE_RESET_RQST: /* Reset request */
printk(KERN_INFO "%s: X.25 reset request on LCN %d! "
"Cause:0x%02X Diagn:0x%02X\n",
card->devname, mb->cmd.lcn, mb->cmd.cause,
mb->cmd.diagn);
api_oob_event (card,mb);
break;
case PVE_RESTART_RQST: /* Restart request */
retry = restart_event(card, cmd, lcn, mb);
break;
default :
printk(KERN_INFO
"%s: X.25 protocol violation on LCN %d! "
"Packet:0x%02X Cause:0x%02X Diagn:0x%02X\n",
card->devname, mb->cmd.lcn,
mb->cmd.pktType & 0x7F, mb->cmd.cause, mb->cmd.diagn);
api_oob_event(card,mb);
}
break;
case 0x42: /* X.25 timeout */
retry = timeout_event(card, cmd, lcn, mb);
break;
case 0x43: /* X.25 retry limit exceeded */
printk(KERN_INFO
"%s: exceeded X.25 retry limit on LCN %d! "
"Packet:0x%02X Diagn:0x%02X\n", card->devname,
mb->cmd.lcn, mb->cmd.pktType, mb->cmd.diagn)
;
break;
case 0x08: /* modem failure */
#ifndef MODEM_NOT_LOG
printk(KERN_INFO "%s: modem failure!\n", card->devname);
#endif /* MODEM_NOT_LOG */
api_oob_event(card,mb);
break;
case 0x09: /* N2 retry limit */
printk(KERN_INFO "%s: exceeded HDLC retry limit!\n",
card->devname);
api_oob_event(card,mb);
break;
case 0x06: /* unnumbered frame was received while in ABM */
printk(KERN_INFO "%s: received Unnumbered frame 0x%02X!\n",
card->devname, mb->data[0]);
api_oob_event(card,mb);
break;
case CMD_TIMEOUT:
printk(KERN_ERR "%s: command 0x%02X timed out!\n",
card->devname, cmd)
;
retry = 0; /* abort command */
break;
case X25RES_NOT_READY:
retry = 1;
break;
case 0x01:
if (card->u.x.LAPB_hdlc)
break;
if (mb->cmd.command == 0x16)
break;
/* I use the goto statement here so if
* somebody inserts code between the
* case and default, we will not have
* ghost problems */
goto dflt_2;
default:
dflt_2:
printk(KERN_INFO "%s: command 0x%02X returned 0x%02X! Lcn %i\n",
card->devname, cmd, err, mb->cmd.lcn)
;
retry = 0; /* abort command */
}
kfree(mb);
return retry;
}
/*====================================================================
* X.25 Asynchronous Event Handlers
* These functions are called by the x25_error() and should return 0, if
* the command resulting in the asynchronous event must be aborted.
*====================================================================*/
/*====================================================================
*Handle X.25 incoming call request.
* RFC 1356 establishes the following rules:
* 1. The first octet in the Call User Data (CUD) field of the call
* request packet contains NLPID identifying protocol encapsulation
* 2. Calls MUST NOT be accepted unless router supports requested
* protocol encapsulation.
* 3. A diagnostic code 249 defined by ISO/IEC 8208 may be used
* when clearing a call because protocol encapsulation is not
* supported.
* 4. If an incoming call is received while a call request is
* pending (i.e. call collision has occurred), the incoming call
* shall be rejected and call request shall be retried.
*====================================================================*/
static int incoming_call (sdla_t* card, int cmd, int lcn, TX25Mbox* mb)
{
struct wan_device* wandev = &card->wandev;
int new_lcn = mb->cmd.lcn;
struct net_device* dev = get_dev_by_lcn(wandev, new_lcn);
x25_channel_t* chan = NULL;
int accept = 0; /* set to '1' if o.k. to accept call */
unsigned int user_data;
x25_call_info_t* info;
/* Make sure there is no call collision */
if (dev != NULL)
{
printk(KERN_INFO
"%s: X.25 incoming call collision on LCN %d!\n",
card->devname, new_lcn);
x25_clear_call(card, new_lcn, 0, 0);
return 1;
}
/* Make sure D bit is not set in call request */
//FIXME: THIS IS NOT TURE !!!! TAKE IT OUT
// if (mb->cmd.qdm & 0x02)
// {
// printk(KERN_INFO
// "%s: X.25 incoming call on LCN %d with D-bit set!\n",
// card->devname, new_lcn);
//
// x25_clear_call(card, new_lcn, 0, 0);
// return 1;
// }
/* Parse call request data */
info = kmalloc(sizeof(x25_call_info_t), GFP_ATOMIC);
if (info == NULL)
{
printk(KERN_ERR
"%s: not enough memory to parse X.25 incoming call "
"on LCN %d!\n", card->devname, new_lcn);
x25_clear_call(card, new_lcn, 0, 0);
return 1;
}
parse_call_info(mb->data, info);
if (card->u.x.logging)
printk(KERN_INFO "\n%s: X.25 incoming call on LCN %d!\n",
card->devname, new_lcn);
/* Conver the first two ASCII characters into an
* interger. Used to check the incoming protocol
*/
user_data = hex_to_uint(info->user,2);
/* Find available channel */
for (dev = wandev->dev; dev; dev = *((struct net_device **)dev->priv)) {
chan = dev->priv;
if (chan->common.usedby == API)
continue;
if (!chan->common.svc || (chan->common.state != WAN_DISCONNECTED))
continue;
if (user_data == NLPID_IP && chan->protocol != htons(ETH_P_IP)){
printk(KERN_INFO "IP packet but configured for IPX : %x, %x\n",
htons(chan->protocol), info->user[0]);
continue;
}
if (user_data == NLPID_SNAP && chan->protocol != htons(ETH_P_IPX)){
printk(KERN_INFO "IPX packet but configured for IP: %x\n",
htons(chan->protocol));
continue;
}
if (strcmp(info->src, chan->addr) == 0)
break;
/* If just an '@' is specified, accept all incoming calls */
if (strcmp(chan->addr, "") == 0)
break;
}
if (dev == NULL){
/* If the call is not for any WANPIPE interfaces
* check to see if there is an API listening queue
* waiting for data. If there is send the packet
* up the stack.
*/
if (card->sk != NULL && card->func != NULL){
if (api_incoming_call(card,mb,new_lcn)){
x25_clear_call(card, new_lcn, 0, 0);
}
accept = 0;
}else{
printk(KERN_INFO "%s: no channels available!\n",
card->devname);
x25_clear_call(card, new_lcn, 0, 0);
}
}else if (info->nuser == 0){
printk(KERN_INFO
"%s: no user data in incoming call on LCN %d!\n",
card->devname, new_lcn)
;
x25_clear_call(card, new_lcn, 0, 0);
}else switch (info->user[0]){
case 0: /* multiplexed */
chan->protocol = htons(0);
accept = 1;
break;
case NLPID_IP: /* IP datagrams */
accept = 1;
break;
case NLPID_SNAP: /* IPX datagrams */
accept = 1;
break;
default:
printk(KERN_INFO
"%s: unsupported NLPID 0x%02X in incoming call "
"on LCN %d!\n", card->devname, info->user[0], new_lcn);
x25_clear_call(card, new_lcn, 0, 249);
}
if (accept && (x25_accept_call(card, new_lcn, 0) == CMD_OK)){
bind_lcn_to_dev (card, chan->dev, new_lcn);
if (x25_get_chan_conf(card, chan) == CMD_OK)
set_chan_state(dev, WAN_CONNECTED);
else
x25_clear_call(card, new_lcn, 0, 0);
}
kfree(info);
return 1;
}
/*====================================================================
* Handle accepted call.
*====================================================================*/
static int call_accepted (sdla_t* card, int cmd, int lcn, TX25Mbox* mb)
{
unsigned new_lcn = mb->cmd.lcn;
struct net_device* dev = find_channel(card, new_lcn);
x25_channel_t* chan;
if (dev == NULL){
printk(KERN_INFO
"%s: clearing orphaned connection on LCN %d!\n",
card->devname, new_lcn);
x25_clear_call(card, new_lcn, 0, 0);
return 1;
}
if (card->u.x.logging)
printk(KERN_INFO "%s: X.25 call accepted on Dev %s and LCN %d!\n",
card->devname, dev->name, new_lcn);
/* Get channel configuration and notify router */
chan = dev->priv;
if (x25_get_chan_conf(card, chan) != CMD_OK)
{
x25_clear_call(card, new_lcn, 0, 0);
return 1;
}
set_chan_state(dev, WAN_CONNECTED);
if (chan->common.usedby == API){
send_delayed_cmd_result(card,dev,mb);
bind_lcn_to_dev (card, dev, new_lcn);
}
return 1;
}
/*====================================================================
* Handle cleared call.
*====================================================================*/
static int call_cleared (sdla_t* card, int cmd, int lcn, TX25Mbox* mb)
{
unsigned new_lcn = mb->cmd.lcn;
struct net_device* dev = find_channel(card, new_lcn);
x25_channel_t *chan;
unsigned char old_state;
if (card->u.x.logging){
printk(KERN_INFO "%s: X.25 clear request on LCN %d! Cause:0x%02X "
"Diagn:0x%02X\n",
card->devname, new_lcn, mb->cmd.cause, mb->cmd.diagn);
}
if (dev == NULL){
printk(KERN_INFO "%s: X.25 clear request : No device for clear\n",
card->devname);
return 1;
}
chan=dev->priv;
old_state = chan->common.state;
set_chan_state(dev, WAN_DISCONNECTED);
if (chan->common.usedby == API){
switch (old_state){
case WAN_CONNECTING:
send_delayed_cmd_result(card,dev,mb);
break;
case WAN_CONNECTED:
send_oob_msg(card,dev,mb);
break;
}
}
return ((cmd == X25_WRITE) && (lcn == new_lcn)) ? 0 : 1;
}
/*====================================================================
* Handle X.25 restart event.
*====================================================================*/
static int restart_event (sdla_t* card, int cmd, int lcn, TX25Mbox* mb)
{
struct wan_device* wandev = &card->wandev;
struct net_device* dev;
x25_channel_t *chan;
unsigned char old_state;
printk(KERN_INFO
"%s: X.25 restart request! Cause:0x%02X Diagn:0x%02X\n",
card->devname, mb->cmd.cause, mb->cmd.diagn);
/* down all logical channels */
for (dev = wandev->dev; dev; dev = *((struct net_device **)dev->priv)) {
chan=dev->priv;
old_state = chan->common.state;
set_chan_state(dev, WAN_DISCONNECTED);
if (chan->common.usedby == API){
switch (old_state){
case WAN_CONNECTING:
send_delayed_cmd_result(card,dev,mb);
break;
case WAN_CONNECTED:
send_oob_msg(card,dev,mb);
break;
}
}
}
return (cmd == X25_WRITE) ? 0 : 1;
}
/*====================================================================
* Handle timeout event.
*====================================================================*/
static int timeout_event (sdla_t* card, int cmd, int lcn, TX25Mbox* mb)
{
unsigned new_lcn = mb->cmd.lcn;
if (mb->cmd.pktType == 0x05) /* call request time out */
{
struct net_device* dev = find_channel(card,new_lcn);
printk(KERN_INFO "%s: X.25 call timed timeout on LCN %d!\n",
card->devname, new_lcn);
if (dev){
x25_channel_t *chan = dev->priv;
set_chan_state(dev, WAN_DISCONNECTED);
if (chan->common.usedby == API){
send_delayed_cmd_result(card,dev,card->mbox);
}
}
}else{
printk(KERN_INFO "%s: X.25 packet 0x%02X timeout on LCN %d!\n",
card->devname, mb->cmd.pktType, new_lcn);
}
return 1;
}
/*
* Miscellaneous
*/
/*====================================================================
* Establish physical connection.
* o open HDLC and raise DTR
*
* Return: 0 connection established
* 1 connection is in progress
* <0 error
*===================================================================*/
static int connect (sdla_t* card)
{
TX25Status* status = card->flags;
if (x25_open_hdlc(card) || x25_setup_hdlc(card))
return -EIO;
wanpipe_set_state(card, WAN_CONNECTING);
x25_set_intr_mode(card, INTR_ON_TIMER);
status->imask &= ~INTR_ON_TIMER;
return 1;
}
/*
* Tear down physical connection.
* o close HDLC link
* o drop DTR
*
* Return: 0
* <0 error
*/
static int disconnect (sdla_t* card)
{
wanpipe_set_state(card, WAN_DISCONNECTED);
x25_set_intr_mode(card, INTR_ON_TIMER); /* disable all interrupt except timer */
x25_close_hdlc(card); /* close HDLC link */
x25_set_dtr(card, 0); /* drop DTR */
return 0;
}
/*
* Find network device by its channel number.
*/
static struct net_device* get_dev_by_lcn(struct wan_device* wandev,
unsigned lcn)
{
struct net_device* dev;
for (dev = wandev->dev; dev; dev = *((struct net_device **)dev->priv))
if (((x25_channel_t*)dev->priv)->common.lcn == lcn)
break;
return dev;
}
/*
* Initiate connection on the logical channel.
* o for PVC we just get channel configuration
* o for SVCs place an X.25 call
*
* Return: 0 connected
* >0 connection in progress
* <0 failure
*/
static int chan_connect(struct net_device* dev)
{
x25_channel_t* chan = dev->priv;
sdla_t* card = chan->card;
if (chan->common.svc && chan->common.usedby == WANPIPE){
if (!chan->addr[0]){
printk(KERN_INFO "%s: No Destination Address\n",
card->devname);
return -EINVAL; /* no destination address */
}
printk(KERN_INFO "%s: placing X.25 call to %s ...\n",
card->devname, chan->addr);
if (x25_place_call(card, chan) != CMD_OK)
return -EIO;
set_chan_state(dev, WAN_CONNECTING);
return 1;
}else{
if (x25_get_chan_conf(card, chan) != CMD_OK)
return -EIO;
set_chan_state(dev, WAN_CONNECTED);
}
return 0;
}
/*
* Disconnect logical channel.
* o if SVC then clear X.25 call
*/
static int chan_disc(struct net_device* dev)
{
x25_channel_t* chan = dev->priv;
if (chan->common.svc){
x25_clear_call(chan->card, chan->common.lcn, 0, 0);
/* For API we disconnect on clear
* confirmation.
*/
if (chan->common.usedby == API)
return 0;
}
set_chan_state(dev, WAN_DISCONNECTED);
return 0;
}
/*
* Set logical channel state.
*/
static void set_chan_state(struct net_device* dev, int state)
{
x25_channel_t* chan = dev->priv;
sdla_t* card = chan->card;
unsigned long flags;
save_flags(flags);
cli();
if (chan->common.state != state)
{
switch (state)
{
case WAN_CONNECTED:
if (card->u.x.logging){
printk (KERN_INFO
"%s: interface %s connected, lcn %i !\n",
card->devname, dev->name,chan->common.lcn);
}
*(unsigned short*)dev->dev_addr = htons(chan->common.lcn);
chan->i_timeout_sofar = jiffies;
/* LAPB is PVC Based */
if (card->u.x.LAPB_hdlc)
chan->common.svc=0;
break;
case WAN_CONNECTING:
if (card->u.x.logging){
printk (KERN_INFO
"%s: interface %s connecting, lcn %i ...\n",
card->devname, dev->name, chan->common.lcn);
}
break;
case WAN_DISCONNECTED:
if (card->u.x.logging){
printk (KERN_INFO
"%s: interface %s disconnected, lcn %i !\n",
card->devname, dev->name,chan->common.lcn);
}
atomic_set(&chan->common.disconnect,0);
if (chan->common.svc) {
*(unsigned short*)dev->dev_addr = 0;
card->u.x.svc_to_dev_map[(chan->common.lcn%X25_MAX_CHAN)]=NULL;
chan->common.lcn = 0;
}
if (chan->transmit_length){
chan->transmit_length=0;
atomic_set(&chan->common.driver_busy,0);
chan->tx_offset=0;
if (netif_queue_stopped(dev)){
netif_wake_queue(dev);
}
}
atomic_set(&chan->common.command,0);
break;
case WAN_DISCONNECTING:
if (card->u.x.logging){
printk (KERN_INFO
"\n%s: interface %s disconnecting, lcn %i ...\n",
card->devname, dev->name,chan->common.lcn);
}
atomic_set(&chan->common.disconnect,0);
break;
}
chan->common.state = state;
}
chan->state_tick = jiffies;
restore_flags(flags);
}
/*
* Send packet on a logical channel.
* When this function is called, tx_skb field of the channel data
* space points to the transmit socket buffer. When transmission
* is complete, release socket buffer and reset 'tbusy' flag.
*
* Return: 0 - transmission complete
* 1 - busy
*
* Notes:
* 1. If packet length is greater than MTU for this channel, we'll fragment
* the packet into 'complete sequence' using M-bit.
* 2. When transmission is complete, an event notification should be issued
* to the router.
*/
static int chan_send(struct net_device* dev, void* buff, unsigned data_len,
unsigned char tx_intr)
{
x25_channel_t* chan = dev->priv;
sdla_t* card = chan->card;
TX25Status* status = card->flags;
unsigned len=0, qdm=0, res=0, orig_len = 0;
void *data;
/* Check to see if channel is ready */
if ((!(status->cflags[chan->ch_idx] & 0x40) && !card->u.x.LAPB_hdlc) ||
!(*card->u.x.hdlc_buf_status & 0x40)){
if (!tx_intr){
setup_for_delayed_transmit (dev, buff, data_len);
return 0;
}else{
/* By returning 0 to tx_intr the packet will be dropped */
++card->wandev.stats.tx_dropped;
++chan->ifstats.tx_dropped;
printk(KERN_INFO "%s: ERROR, Tx intr could not send, dropping %s:\n",
card->devname,dev->name);
++chan->if_send_stat.if_send_bfr_not_passed_to_adptr;
return 0;
}
}
if (chan->common.usedby == API){
/* Remove the API Header */
x25api_hdr_t *api_data = (x25api_hdr_t *)buff;
/* Set the qdm bits from the packet header
* User has the option to set the qdm bits
*/
qdm = api_data->qdm;
orig_len = len = data_len - sizeof(x25api_hdr_t);
data = (unsigned char*)buff + sizeof(x25api_hdr_t);
}else{
data = buff;
orig_len = len = data_len;
}
if (tx_intr){
/* We are in tx_intr, minus the tx_offset from
* the total length. The tx_offset part of the
* data has already been sent. Also, move the
* data pointer to proper offset location.
*/
len -= chan->tx_offset;
data = (unsigned char*)data + chan->tx_offset;
}
/* Check if the packet length is greater than MTU
* If YES: Cut the len to MTU and set the M bit
*/
if (len > chan->tx_pkt_size && !card->u.x.LAPB_hdlc){
len = chan->tx_pkt_size;
qdm |= M_BIT;
}
/* Pass only first three bits of the qdm byte to the send
* routine. In case user sets any other bit which might
* cause errors.
*/
switch(x25_send(card, chan->common.lcn, (qdm&0x07), len, data)){
case 0x00: /* success */
chan->i_timeout_sofar = jiffies;
dev->trans_start=jiffies;
if ((qdm & M_BIT) && !card->u.x.LAPB_hdlc){
if (!tx_intr){
/* The M bit was set, which means that part of the
* packet has been sent. Copy the packet into a buffer
* and set the offset to len, so on next tx_inter
* the packet will be sent using the below offset.
*/
chan->tx_offset += len;
++chan->ifstats.tx_packets;
chan->ifstats.tx_bytes += len;
if (chan->tx_offset < orig_len){
setup_for_delayed_transmit (dev, buff, data_len);
}
res=0;
}else{
/* We are already in tx_inter, thus data is already
* in the buffer. Update the offset and wait for
* next tx_intr. We add on to the offset, since data can
* be X number of times larger than max data size.
*/
++chan->ifstats.tx_packets;
chan->ifstats.tx_bytes += len;
++chan->if_send_stat.if_send_bfr_passed_to_adptr;
chan->tx_offset += len;
/* The user can set the qdm bit as well.
* If the entire packet was sent and qdm is still
* set, than it's the user who has set the M bit. In that,
* case indicate that the packet was send by returning
* 0 and wait for a new packet. Otherwise, wait for next
* tx interrupt to send the rest of the packet */
if (chan->tx_offset < orig_len){
res=1;
}else{
res=0;
}
}
}else{
++chan->ifstats.tx_packets;
chan->ifstats.tx_bytes += len;
++chan->if_send_stat.if_send_bfr_passed_to_adptr;
res=0;
}
break;
case 0x33: /* Tx busy */
if (tx_intr){
printk(KERN_INFO "%s: Tx_intr: Big Error dropping packet %s\n",
card->devname,dev->name);
++chan->ifstats.tx_dropped;
++card->wandev.stats.tx_dropped;
++chan->if_send_stat.if_send_bfr_not_passed_to_adptr;
res=0;
}else{
DBG_PRINTK(KERN_INFO
"%s: Send: Big Error should have tx: storring %s\n",
card->devname,dev->name);
setup_for_delayed_transmit (dev, buff, data_len);
res=1;
}
break;
default: /* failure */
++chan->ifstats.tx_errors;
if (tx_intr){
printk(KERN_INFO "%s: Tx_intr: Failure to send, dropping %s\n",
card->devname,dev->name);
++chan->ifstats.tx_dropped;
++card->wandev.stats.tx_dropped;
++chan->if_send_stat.if_send_bfr_not_passed_to_adptr;
res=0;
}else{
DBG_PRINTK(KERN_INFO "%s: Send: Failure to send !!!, storing %s\n",
card->devname,dev->name);
setup_for_delayed_transmit (dev, buff, data_len);
res=1;
}
break;
}
return res;
}
/*
* Parse X.25 call request data and fill x25_call_info_t structure.
*/
static void parse_call_info (unsigned char* str, x25_call_info_t* info)
{
memset(info, 0, sizeof(x25_call_info_t));
for (; *str; ++str)
{
int i;
unsigned char ch;
if (*str == '-') switch (str[1]) {
/* Take minus 2 off the maximum size so that
* last byte is 0. This way we can use string
* manipulaton functions on call information.
*/
case 'd': /* destination address */
for (i = 0; i < (MAX_X25_ADDR_SIZE-2); ++i){
ch = str[2+i];
if (isspace(ch)) break;
info->dest[i] = ch;
}
break;
case 's': /* source address */
for (i = 0; i < (MAX_X25_ADDR_SIZE-2); ++i){
ch = str[2+i];
if (isspace(ch)) break;
info->src[i] = ch;
}
break;
case 'u': /* user data */
for (i = 0; i < (MAX_X25_DATA_SIZE-2); ++i){
ch = str[2+i];
if (isspace(ch)) break;
info->user[i] = ch;
}
info->nuser = i;
break;
case 'f': /* facilities */
for (i = 0; i < (MAX_X25_FACL_SIZE-2); ++i){
ch = str[2+i];
if (isspace(ch)) break;
info->facil[i] = ch;
}
info->nfacil = i;
break;
}
}
}
/*
* Convert line speed in bps to a number used by S502 code.
*/
static unsigned char bps_to_speed_code (unsigned long bps)
{
unsigned char number;
if (bps <= 1200) number = 0x01;
else if (bps <= 2400) number = 0x02;
else if (bps <= 4800) number = 0x03;
else if (bps <= 9600) number = 0x04;
else if (bps <= 19200) number = 0x05;
else if (bps <= 38400) number = 0x06;
else if (bps <= 45000) number = 0x07;
else if (bps <= 56000) number = 0x08;
else if (bps <= 64000) number = 0x09;
else if (bps <= 74000) number = 0x0A;
else if (bps <= 112000) number = 0x0B;
else if (bps <= 128000) number = 0x0C;
else number = 0x0D;
return number;
}
/*
* Convert decimal string to unsigned integer.
* If len != 0 then only 'len' characters of the string are converted.
*/
static unsigned int dec_to_uint (unsigned char* str, int len)
{
unsigned val;
if (!len)
len = strlen(str);
for (val = 0; len && is_digit(*str); ++str, --len)
val = (val * 10) + (*str - (unsigned)'0');
return val;
}
/*
* Convert hex string to unsigned integer.
* If len != 0 then only 'len' characters of the string are conferted.
*/
static unsigned int hex_to_uint (unsigned char* str, int len)
{
unsigned val, ch;
if (!len)
len = strlen(str);
for (val = 0; len; ++str, --len)
{
ch = *str;
if (is_digit(ch))
val = (val << 4) + (ch - (unsigned)'0');
else if (is_hex_digit(ch))
val = (val << 4) + ((ch & 0xDF) - (unsigned)'A' + 10);
else break;
}
return val;
}
static int handle_IPXWAN(unsigned char *sendpacket, char *devname, unsigned char enable_IPX, unsigned long network_number, unsigned short proto)
{
int i;
if( proto == ETH_P_IPX) {
/* It's an IPX packet */
if(!enable_IPX) {
/* Return 1 so we don't pass it up the stack. */
return 1;
}
} else {
/* It's not IPX so pass it up the stack.*/
return 0;
}
if( sendpacket[16] == 0x90 &&
sendpacket[17] == 0x04)
{
/* It's IPXWAN */
if( sendpacket[2] == 0x02 &&
sendpacket[34] == 0x00)
{
/* It's a timer request packet */
printk(KERN_INFO "%s: Received IPXWAN Timer Request packet\n",devname);
/* Go through the routing options and answer no to every
* option except Unnumbered RIP/SAP
*/
for(i = 41; sendpacket[i] == 0x00; i += 5)
{
/* 0x02 is the option for Unnumbered RIP/SAP */
if( sendpacket[i + 4] != 0x02)
{
sendpacket[i + 1] = 0;
}
}
/* Skip over the extended Node ID option */
if( sendpacket[i] == 0x04 )
{
i += 8;
}
/* We also want to turn off all header compression opt. */
for(; sendpacket[i] == 0x80 ;)
{
sendpacket[i + 1] = 0;
i += (sendpacket[i + 2] << 8) + (sendpacket[i + 3]) + 4;
}
/* Set the packet type to timer response */
sendpacket[34] = 0x01;
printk(KERN_INFO "%s: Sending IPXWAN Timer Response\n",devname);
}
else if( sendpacket[34] == 0x02 )
{
/* This is an information request packet */
printk(KERN_INFO "%s: Received IPXWAN Information Request packet\n",devname);
/* Set the packet type to information response */
sendpacket[34] = 0x03;
/* Set the router name */
sendpacket[51] = 'X';
sendpacket[52] = 'T';
sendpacket[53] = 'P';
sendpacket[54] = 'I';
sendpacket[55] = 'P';
sendpacket[56] = 'E';
sendpacket[57] = '-';
sendpacket[58] = CVHexToAscii(network_number >> 28);
sendpacket[59] = CVHexToAscii((network_number & 0x0F000000)>> 24);
sendpacket[60] = CVHexToAscii((network_number & 0x00F00000)>> 20);
sendpacket[61] = CVHexToAscii((network_number & 0x000F0000)>> 16);
sendpacket[62] = CVHexToAscii((network_number & 0x0000F000)>> 12);
sendpacket[63] = CVHexToAscii((network_number & 0x00000F00)>> 8);
sendpacket[64] = CVHexToAscii((network_number & 0x000000F0)>> 4);
sendpacket[65] = CVHexToAscii(network_number & 0x0000000F);
for(i = 66; i < 99; i+= 1)
{
sendpacket[i] = 0;
}
printk(KERN_INFO "%s: Sending IPXWAN Information Response packet\n",devname);
}
else
{
printk(KERN_INFO "%s: Unknown IPXWAN packet!\n",devname);
return 0;
}
/* Set the WNodeID to our network address */
sendpacket[35] = (unsigned char)(network_number >> 24);
sendpacket[36] = (unsigned char)((network_number & 0x00FF0000) >> 16);
sendpacket[37] = (unsigned char)((network_number & 0x0000FF00) >> 8);
sendpacket[38] = (unsigned char)(network_number & 0x000000FF);
return 1;
} else {
/*If we get here it's an IPX-data packet, so it'll get passed up the stack.
*/
/* switch the network numbers */
switch_net_numbers(sendpacket, network_number, 1);
return 0;
}
}
/*
* If incoming is 0 (outgoing)- if the net numbers is ours make it 0
* if incoming is 1 - if the net number is 0 make it ours
*/
static void switch_net_numbers(unsigned char *sendpacket, unsigned long network_number, unsigned char incoming)
{
unsigned long pnetwork_number;
pnetwork_number = (unsigned long)((sendpacket[6] << 24) +
(sendpacket[7] << 16) + (sendpacket[8] << 8) +
sendpacket[9]);
if (!incoming) {
/*If the destination network number is ours, make it 0 */
if( pnetwork_number == network_number) {
sendpacket[6] = sendpacket[7] = sendpacket[8] =
sendpacket[9] = 0x00;
}
} else {
/* If the incoming network is 0, make it ours */
if( pnetwork_number == 0) {
sendpacket[6] = (unsigned char)(network_number >> 24);
sendpacket[7] = (unsigned char)((network_number &
0x00FF0000) >> 16);
sendpacket[8] = (unsigned char)((network_number &
0x0000FF00) >> 8);
sendpacket[9] = (unsigned char)(network_number &
0x000000FF);
}
}
pnetwork_number = (unsigned long)((sendpacket[18] << 24) +
(sendpacket[19] << 16) + (sendpacket[20] << 8) +
sendpacket[21]);
if( !incoming ) {
/* If the source network is ours, make it 0 */
if( pnetwork_number == network_number) {
sendpacket[18] = sendpacket[19] = sendpacket[20] =
sendpacket[21] = 0x00;
}
} else {
/* If the source network is 0, make it ours */
if( pnetwork_number == 0 ) {
sendpacket[18] = (unsigned char)(network_number >> 24);
sendpacket[19] = (unsigned char)((network_number &
0x00FF0000) >> 16);
sendpacket[20] = (unsigned char)((network_number &
0x0000FF00) >> 8);
sendpacket[21] = (unsigned char)(network_number &
0x000000FF);
}
}
} /* switch_net_numbers */
/********************* X25API SPECIFIC FUNCTIONS ****************/
/*===============================================================
* find_channel
*
* Manages the lcn to device map. It increases performance
* because it eliminates the need to search through the link
* list for a device which is bounded to a specific lcn.
*
*===============================================================*/
struct net_device *find_channel(sdla_t *card, unsigned lcn)
{
if (card->u.x.LAPB_hdlc){
return card->wandev.dev;
}else{
/* We don't know whether the incoming lcn
* is a PVC or an SVC channel. But we do know that
* the lcn cannot be for both the PVC and the SVC
* channel.
* If the lcn number is greater or equal to 255,
* take the modulo 255 of that number. We only have
* 255 locations, thus higher numbers must be mapped
* to a number between 0 and 245.
* We must separate pvc's and svc's since two don't
* have to be contiguous. Meaning pvc's can start
* from 1 to 10 and svc's can start from 256 to 266.
* But 256%255 is 1, i.e. CONFLICT.
*/
/* Highest LCN number must be less or equal to 4096 */
if ((lcn <= MAX_LCN_NUM) && (lcn > 0)){
if (lcn < X25_MAX_CHAN){
if (card->u.x.svc_to_dev_map[lcn])
return card->u.x.svc_to_dev_map[lcn];
if (card->u.x.pvc_to_dev_map[lcn])
return card->u.x.pvc_to_dev_map[lcn];
}else{
int new_lcn = lcn%X25_MAX_CHAN;
if (card->u.x.svc_to_dev_map[new_lcn])
return card->u.x.svc_to_dev_map[new_lcn];
if (card->u.x.pvc_to_dev_map[new_lcn])
return card->u.x.pvc_to_dev_map[new_lcn];
}
}
return NULL;
}
}
void bind_lcn_to_dev(sdla_t *card, struct net_device *dev, unsigned lcn)
{
x25_channel_t *chan = dev->priv;
/* Modulo the lcn number by X25_MAX_CHAN (255)
* because the lcn number can be greater than 255
*
* We need to split svc and pvc since they don't have
* to be contigous.
*/
if (chan->common.svc){
card->u.x.svc_to_dev_map[(lcn % X25_MAX_CHAN)] = dev;
}else{
card->u.x.pvc_to_dev_map[(lcn % X25_MAX_CHAN)] = dev;
}
chan->common.lcn = lcn;
}
/*===============================================================
* x25api_bh
*
*
*==============================================================*/
static void x25api_bh(struct net_device* dev)
{
x25_channel_t* chan = dev->priv;
sdla_t* card = chan->card;
struct sk_buff *skb;
if (atomic_read(&chan->bh_buff_used) == 0){
printk(KERN_INFO "%s: BH Buffer Empty in BH\n",
card->devname);
clear_bit(0, &chan->tq_working);
return;
}
while (atomic_read(&chan->bh_buff_used)){
/* If the sock is in the process of unlinking the
* driver from the socket, we must get out.
* This never happends but is a sanity check. */
if (test_bit(0,&chan->common.common_critical)){
clear_bit(0, &chan->tq_working);
return;
}
/* If LAPB HDLC, do not drop packets if socket is
* not connected. Let the buffer fill up and
* turn off rx interrupt */
if (card->u.x.LAPB_hdlc){
if (chan->common.sk == NULL || chan->common.func == NULL){
clear_bit(0, &chan->tq_working);
return;
}
}
skb = ((bh_data_t *)&chan->bh_head[chan->bh_read])->skb;
if (skb == NULL){
printk(KERN_INFO "%s: BH Skb empty for read %i\n",
card->devname,chan->bh_read);
}else{
if (chan->common.sk == NULL || chan->common.func == NULL){
printk(KERN_INFO "%s: BH: Socket disconnected, dropping\n",
card->devname);
dev_kfree_skb_any(skb);
x25api_bh_cleanup(dev);
++chan->ifstats.rx_dropped;
++chan->rx_intr_stat.rx_intr_bfr_not_passed_to_stack;
continue;
}
if (chan->common.func(skb,dev,chan->common.sk) != 0){
/* Sock full cannot send, queue us for another
* try
*/
printk(KERN_INFO "%s: BH: !!! Packet failed to send !!!!! \n",
card->devname);
atomic_set(&chan->common.receive_block,1);
return;
}else{
x25api_bh_cleanup(dev);
++chan->rx_intr_stat.rx_intr_bfr_passed_to_stack;
}
}
}
clear_bit(0, &chan->tq_working);
return;
}
/*===============================================================
* x25api_bh_cleanup
*
*
*==============================================================*/
static int x25api_bh_cleanup(struct net_device *dev)
{
x25_channel_t* chan = dev->priv;
sdla_t *card = chan->card;
TX25Status* status = card->flags;
((bh_data_t *)&chan->bh_head[chan->bh_read])->skb = NULL;
if (chan->bh_read == MAX_BH_BUFF){
chan->bh_read=0;
}else{
++chan->bh_read;
}
/* If the Receive interrupt was off, it means
* that we filled up our circular buffer. Check
* that we have space in the buffer. If so
* turn the RX interrupt back on.
*/
if (!(status->imask & INTR_ON_RX_FRAME)){
if (atomic_read(&chan->bh_buff_used) < (MAX_BH_BUFF+1)){
printk(KERN_INFO "%s: BH: Turning on the interrupt\n",
card->devname);
status->imask |= INTR_ON_RX_FRAME;
}
}
atomic_dec(&chan->bh_buff_used);
return 0;
}
/*===============================================================
* bh_enqueue
*
*
*==============================================================*/
static int bh_enqueue(struct net_device *dev, struct sk_buff *skb)
{
x25_channel_t* chan = dev->priv;
sdla_t *card = chan->card;
TX25Status* status = card->flags;
if (atomic_read(&chan->bh_buff_used) == (MAX_BH_BUFF+1)){
printk(KERN_INFO "%s: Bottom half buffer FULL\n",
card->devname);
return 1;
}
((bh_data_t *)&chan->bh_head[chan->bh_write])->skb = skb;
if (chan->bh_write == MAX_BH_BUFF){
chan->bh_write=0;
}else{
++chan->bh_write;
}
atomic_inc(&chan->bh_buff_used);
if (atomic_read(&chan->bh_buff_used) == (MAX_BH_BUFF+1)){
printk(KERN_INFO "%s: Buffer is now full, Turning off RX Intr\n",
card->devname);
status->imask &= ~INTR_ON_RX_FRAME;
}
return 0;
}
/*===============================================================
* timer_intr_cmd_exec
*
* Called by timer interrupt to execute a command
*===============================================================*/
static int timer_intr_cmd_exec (sdla_t* card)
{
struct net_device *dev;
unsigned char more_to_exec=0;
volatile x25_channel_t *chan=NULL;
int i=0,bad_cmd=0,err=0;
if (card->u.x.cmd_dev == NULL){
card->u.x.cmd_dev = card->wandev.dev;
}
dev = card->u.x.cmd_dev;
for (;;){
chan = dev->priv;
if (atomic_read(&chan->common.command)){
bad_cmd = check_bad_command(card,dev);
if ((!chan->common.mbox || atomic_read(&chan->common.disconnect)) &&
!bad_cmd){
/* Socket has died or exited, We must bring the
* channel down before anybody else tries to
* use it */
err = channel_disconnect(card,dev);
}else{
err = execute_delayed_cmd(card, dev,
(mbox_cmd_t*)chan->common.mbox,
bad_cmd);
}
switch (err){
case RETURN_RESULT:
/* Return the result to the socket without
* delay. NO_WAIT Command */
atomic_set(&chan->common.command,0);
if (atomic_read(&card->u.x.command_busy))
atomic_set(&card->u.x.command_busy,0);
send_delayed_cmd_result(card,dev,card->mbox);
more_to_exec=0;
break;
case DELAY_RESULT:
/* Wait for the remote to respond, before
* sending the result up to the socket.
* WAIT command */
if (atomic_read(&card->u.x.command_busy))
atomic_set(&card->u.x.command_busy,0);
atomic_set(&chan->common.command,0);
more_to_exec=0;
break;
default:
/* If command could not be executed for
* some reason (i.e return code 0x33 busy)
* set the more_to_exec bit which will
* indicate that this command must be exectued
* again during next timer interrupt
*/
more_to_exec=1;
if (atomic_read(&card->u.x.command_busy) == 0)
atomic_set(&card->u.x.command_busy,1);
break;
}
bad_cmd=0;
/* If flags is set, there are no hdlc buffers,
* thus, wait for the next pass and try the
* same command again. Otherwise, start searching
* from next device on the next pass.
*/
if (!more_to_exec){
dev = move_dev_to_next(card,dev);
}
break;
}else{
/* This device has nothing to execute,
* go to next.
*/
if (atomic_read(&card->u.x.command_busy))
atomic_set(&card->u.x.command_busy,0);
dev = move_dev_to_next(card,dev);
}
if (++i == card->u.x.no_dev){
if (!more_to_exec){
DBG_PRINTK(KERN_INFO "%s: Nothing to execute in Timer\n",
card->devname);
if (atomic_read(&card->u.x.command_busy)){
atomic_set(&card->u.x.command_busy,0);
}
}
break;
}
} //End of FOR
card->u.x.cmd_dev = dev;
if (more_to_exec){
/* If more commands are pending, do not turn off timer
* interrupt */
return 1;
}else{
/* No more commands, turn off timer interrupt */
return 0;
}
}
/*===============================================================
* execute_delayed_cmd
*
* Execute an API command which was passed down from the
* sock. Sock is very limited in which commands it can
* execute. Wait and No Wait commands are supported.
* Place Call, Clear Call and Reset wait commands, where
* Accept Call is a no_wait command.
*
*===============================================================*/
static int execute_delayed_cmd(sdla_t* card, struct net_device *dev,
mbox_cmd_t *usr_cmd, char bad_cmd)
{
TX25Mbox* mbox = card->mbox;
int err;
x25_channel_t *chan = dev->priv;
int delay=RETURN_RESULT;
if (!(*card->u.x.hdlc_buf_status & 0x40) && !bad_cmd){
return TRY_CMD_AGAIN;
}
/* This way a command is guaranteed to be executed for
* a specific lcn, the network interface is bound to. */
usr_cmd->cmd.lcn = chan->common.lcn;
/* If channel is pvc, instead of place call
* run x25_channel configuration. If running LAPB HDLC
* enable communications.
*/
if ((!chan->common.svc) && (usr_cmd->cmd.command == X25_PLACE_CALL)){
if (card->u.x.LAPB_hdlc){
DBG_PRINTK(KERN_INFO "LAPB: Connecting\n");
connect(card);
set_chan_state(dev,WAN_CONNECTING);
return DELAY_RESULT;
}else{
DBG_PRINTK(KERN_INFO "%s: PVC is CONNECTING\n",card->devname);
if (x25_get_chan_conf(card, chan) == CMD_OK){
set_chan_state(dev, WAN_CONNECTED);
}else{
set_chan_state(dev, WAN_DISCONNECTED);
}
return RETURN_RESULT;
}
}
/* Copy the socket mbox command onto the board */
memcpy(&mbox->cmd, &usr_cmd->cmd, sizeof(TX25Cmd));
if (usr_cmd->cmd.length){
memcpy(mbox->data, usr_cmd->data, usr_cmd->cmd.length);
}
/* Check if command is bad. We need to copy the cmd into
* the buffer regardless since we return the, mbox to
* the user */
if (bad_cmd){
mbox->cmd.result=0x01;
return RETURN_RESULT;
}
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
if (err != CMD_OK && err != X25RES_NOT_READY)
x25_error(card, err, usr_cmd->cmd.command, usr_cmd->cmd.lcn);
if (mbox->cmd.result == X25RES_NOT_READY){
return TRY_CMD_AGAIN;
}
switch (mbox->cmd.command){
case X25_PLACE_CALL:
switch (mbox->cmd.result){
case CMD_OK:
/* Check if Place call is a wait command or a
* no wait command */
if (atomic_read(&chan->common.command) & 0x80)
delay=RETURN_RESULT;
else
delay=DELAY_RESULT;
DBG_PRINTK(KERN_INFO "\n%s: PLACE CALL Binding dev %s to lcn %i\n",
card->devname,dev->name, mbox->cmd.lcn);
bind_lcn_to_dev (card, dev, mbox->cmd.lcn);
set_chan_state(dev, WAN_CONNECTING);
break;
default:
delay=RETURN_RESULT;
set_chan_state(dev, WAN_DISCONNECTED);
break;
}
break;
case X25_ACCEPT_CALL:
switch (mbox->cmd.result){
case CMD_OK:
DBG_PRINTK(KERN_INFO "\n%s: ACCEPT Binding dev %s to lcn %i\n",
card->devname,dev->name,mbox->cmd.lcn);
bind_lcn_to_dev (card, dev, mbox->cmd.lcn);
if (x25_get_chan_conf(card, chan) == CMD_OK){
set_chan_state(dev, WAN_CONNECTED);
delay=RETURN_RESULT;
}else{
if (x25_clear_call(card, usr_cmd->cmd.lcn, 0, 0) == CMD_OK){
/* if clear is successful, wait for clear confirm
*/
delay=DELAY_RESULT;
}else{
/* Do not change the state here. If we fail
* the accept the return code is send up
*the stack, which will ether retry
* or clear the call
*/
DBG_PRINTK(KERN_INFO
"%s: ACCEPT: STATE MAY BE CURRUPTED 2 !!!!!\n",
card->devname);
delay=RETURN_RESULT;
}
}
break;
case X25RES_ASYNC_PACKET:
delay=TRY_CMD_AGAIN;
break;
default:
DBG_PRINTK(KERN_INFO "%s: ACCEPT FAILED\n",card->devname);
if (x25_clear_call(card, usr_cmd->cmd.lcn, 0, 0) == CMD_OK){
delay=DELAY_RESULT;
}else{
/* Do not change the state here. If we fail the accept. The
* return code is send up the stack, which will ether retry
* or clear the call */
DBG_PRINTK(KERN_INFO
"%s: ACCEPT: STATE MAY BE CORRUPTED 1 !!!!!\n",
card->devname);
delay=RETURN_RESULT;
}
}
break;
case X25_CLEAR_CALL:
switch (mbox->cmd.result){
case CMD_OK:
DBG_PRINTK(KERN_INFO
"CALL CLEAR OK: Dev %s Mbox Lcn %i Chan Lcn %i\n",
dev->name,mbox->cmd.lcn,chan->common.lcn);
set_chan_state(dev, WAN_DISCONNECTING);
delay = DELAY_RESULT;
break;
case X25RES_CHANNEL_IN_USE:
case X25RES_ASYNC_PACKET:
delay = TRY_CMD_AGAIN;
break;
case X25RES_LINK_NOT_IN_ABM:
case X25RES_INVAL_LCN:
case X25RES_INVAL_STATE:
set_chan_state(dev, WAN_DISCONNECTED);
delay = RETURN_RESULT;
break;
default:
/* If command did not execute because of user
* fault, do not change the state. This will
* signal the socket that clear command failed.
* User can retry or close the socket.
* When socket gets killed, it will set the
* chan->disconnect which will signal
* driver to clear the call */
printk(KERN_INFO "%s: Clear Command Failed, Rc %x\n",
card->devname,mbox->cmd.command);
delay = RETURN_RESULT;
}
break;
}
return delay;
}
/*===============================================================
* api_incoming_call
*
* Pass an incoming call request up the listening
* sock. If the API sock is not listening reject the
* call.
*
*===============================================================*/
static int api_incoming_call (sdla_t* card, TX25Mbox *mbox, int lcn)
{
struct sk_buff *skb;
int len = sizeof(TX25Cmd)+mbox->cmd.length;
if (alloc_and_init_skb_buf(card, &skb, len)){
printk(KERN_INFO "%s: API incoming call, no memory\n",card->devname);
return 1;
}
memcpy(skb_put(skb,len),&mbox->cmd,len);
skb->mac.raw = skb->data;
skb->protocol = htons(X25_PROT);
skb->pkt_type = WAN_PACKET_ASYNC;
if (card->func(skb,card->sk) < 0){
printk(KERN_INFO "%s: MAJOR ERROR: Failed to send up place call \n",card->devname);
dev_kfree_skb_any(skb);
return 1;
}
return 0;
}
/*===============================================================
* send_delayed_cmd_result
*
* Wait commands like PLEACE CALL or CLEAR CALL must wait
* until the result arrives. This function passes
* the result to a waiting sock.
*
*===============================================================*/
static void send_delayed_cmd_result(sdla_t *card, struct net_device *dev,
TX25Mbox* mbox)
{
x25_channel_t *chan = dev->priv;
mbox_cmd_t *usr_cmd = (mbox_cmd_t *)chan->common.mbox;
struct sk_buff *skb;
int len=sizeof(unsigned char);
atomic_set(&chan->common.command,0);
/* If the sock is in the process of unlinking the
* driver from the socket, we must get out.
* This never happends but is a sanity check. */
if (test_bit(0,&chan->common.common_critical)){
return;
}
if (!usr_cmd || !chan->common.sk || !chan->common.func){
DBG_PRINTK(KERN_INFO "Delay result: Sock not bounded sk: %u, func: %u, mbox: %u\n",
(unsigned int)chan->common.sk,
(unsigned int)chan->common.func,
(unsigned int)usr_cmd);
return;
}
memcpy(&usr_cmd->cmd, &mbox->cmd, sizeof(TX25Cmd));
if (mbox->cmd.length > 0){
memcpy(usr_cmd->data, mbox->data, mbox->cmd.length);
}
if (alloc_and_init_skb_buf(card,&skb,len)){
printk(KERN_INFO "Delay result: No sock buffers\n");
return;
}
memcpy(skb_put(skb,len),&mbox->cmd.command,len);
skb->mac.raw = skb->data;
skb->pkt_type = WAN_PACKET_CMD;
chan->common.func(skb,dev,chan->common.sk);
}
/*===============================================================
* clear_confirm_event
*
* Pass the clear confirmation event up the sock. The
* API will disconnect only after the clear confirmation
* has been received.
*
* Depending on the state, clear confirmation could
* be an OOB event, or a result of an API command.
*===============================================================*/
static int clear_confirm_event (sdla_t *card, TX25Mbox* mb)
{
struct net_device *dev;
x25_channel_t *chan;
unsigned char old_state;
dev = find_channel(card,mb->cmd.lcn);
if (!dev){
DBG_PRINTK(KERN_INFO "%s: *** GOT CLEAR BUT NO DEV %i\n",
card->devname,mb->cmd.lcn);
return 0;
}
chan=dev->priv;
DBG_PRINTK(KERN_INFO "%s: GOT CLEAR CONFIRM %s: Mbox lcn %i Chan lcn %i\n",
card->devname, dev->name, mb->cmd.lcn, chan->common.lcn);
/* If not API fall through to default.
* If API, send the result to a waiting
* socket.
*/
old_state = chan->common.state;
set_chan_state(dev, WAN_DISCONNECTED);
if (chan->common.usedby == API){
switch (old_state) {
case WAN_DISCONNECTING:
case WAN_CONNECTING:
send_delayed_cmd_result(card,dev,mb);
break;
case WAN_CONNECTED:
send_oob_msg(card,dev,mb);
break;
}
return 1;
}
return 0;
}
/*===============================================================
* send_oob_msg
*
* Construct an NEM Message and pass it up the connected
* sock. If the sock is not bounded discard the NEM.
*
*===============================================================*/
static void send_oob_msg(sdla_t *card, struct net_device *dev, TX25Mbox *mbox)
{
x25_channel_t *chan = dev->priv;
mbox_cmd_t *usr_cmd = (mbox_cmd_t *)chan->common.mbox;
struct sk_buff *skb;
int len=sizeof(x25api_hdr_t)+mbox->cmd.length;
x25api_t *api_hdr;
/* If the sock is in the process of unlinking the
* driver from the socket, we must get out.
* This never happends but is a sanity check. */
if (test_bit(0,&chan->common.common_critical)){
return;
}
if (!usr_cmd || !chan->common.sk || !chan->common.func){
DBG_PRINTK(KERN_INFO "OOB MSG: Sock not bounded\n");
return;
}
memcpy(&usr_cmd->cmd, &mbox->cmd, sizeof(TX25Cmd));
if (mbox->cmd.length > 0){
memcpy(usr_cmd->data, mbox->data, mbox->cmd.length);
}
if (alloc_and_init_skb_buf(card,&skb,len)){
printk(KERN_INFO "%s: OOB MSG: No sock buffers\n",card->devname);
return;
}
api_hdr = (x25api_t*)skb_put(skb,len);
api_hdr->hdr.pktType = mbox->cmd.pktType & 0x7F;
api_hdr->hdr.qdm = mbox->cmd.qdm;
api_hdr->hdr.cause = mbox->cmd.cause;
api_hdr->hdr.diagn = mbox->cmd.diagn;
api_hdr->hdr.length = mbox->cmd.length;
api_hdr->hdr.result = mbox->cmd.result;
api_hdr->hdr.lcn = mbox->cmd.lcn;
if (mbox->cmd.length > 0){
memcpy(api_hdr->data,mbox->data,mbox->cmd.length);
}
skb->mac.raw = skb->data;
skb->pkt_type = WAN_PACKET_ERR;
if (chan->common.func(skb,dev,chan->common.sk) < 0){
if (bh_enqueue(dev,skb)){
printk(KERN_INFO "%s: Dropping OOB MSG\n",card->devname);
dev_kfree_skb_any(skb);
}
}
DBG_PRINTK(KERN_INFO "%s: OOB MSG OK, %s, lcn %i\n",
card->devname, dev->name, mbox->cmd.lcn);
}
/*===============================================================
* alloc_and_init_skb_buf
*
* Allocate and initialize an skb buffer.
*
*===============================================================*/
static int alloc_and_init_skb_buf (sdla_t *card, struct sk_buff **skb, int len)
{
struct sk_buff *new_skb = *skb;
new_skb = dev_alloc_skb(len + X25_HRDHDR_SZ);
if (new_skb == NULL){
printk(KERN_INFO "%s: no socket buffers available!\n",
card->devname);
return 1;
}
if (skb_tailroom(new_skb) < len){
/* No room for the packet. Call off the whole thing! */
dev_kfree_skb_any(new_skb);
printk(KERN_INFO "%s: Listen: unexpectedly long packet sequence\n"
,card->devname);
*skb = NULL;
return 1;
}
*skb = new_skb;
return 0;
}
/*===============================================================
* api_oob_event
*
* Send an OOB event up to the sock
*
*===============================================================*/
static void api_oob_event (sdla_t *card,TX25Mbox *mbox)
{
struct net_device *dev = find_channel(card, mbox->cmd.lcn);
x25_channel_t *chan;
if (!dev)
return;
chan=dev->priv;
if (chan->common.usedby == API)
send_oob_msg(card,dev,mbox);
}
static int channel_disconnect(sdla_t* card, struct net_device *dev)
{
int err;
x25_channel_t *chan = dev->priv;
DBG_PRINTK(KERN_INFO "%s: TIMER: %s, Device down disconnecting\n",
card->devname,dev->name);
if (chan->common.svc){
err = x25_clear_call(card,chan->common.lcn,0,0);
}else{
/* If channel is PVC or LAPB HDLC, there is no call
* to be cleared, thus drop down to the default
* area
*/
err = 1;
}
switch (err){
case X25RES_CHANNEL_IN_USE:
case X25RES_NOT_READY:
err = TRY_CMD_AGAIN;
break;
case CMD_OK:
DBG_PRINTK(KERN_INFO "CALL CLEAR OK: Dev %s Chan Lcn %i\n",
dev->name,chan->common.lcn);
set_chan_state(dev,WAN_DISCONNECTING);
atomic_set(&chan->common.command,0);
err = DELAY_RESULT;
break;
default:
/* If LAPB HDLC protocol, bring the whole link down
* once the application terminates
*/
set_chan_state(dev,WAN_DISCONNECTED);
if (card->u.x.LAPB_hdlc){
DBG_PRINTK(KERN_INFO "LAPB: Disconnecting Link\n");
hdlc_link_down (card);
}
atomic_set(&chan->common.command,0);
err = RETURN_RESULT;
break;
}
return err;
}
static void hdlc_link_down (sdla_t *card)
{
TX25Mbox* mbox = card->mbox;
int retry = 5;
int err=0;
do {
memset(mbox,0,sizeof(TX25Mbox));
mbox->cmd.command = X25_HDLC_LINK_DISC;
mbox->cmd.length = 1;
mbox->data[0]=0;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && retry-- && x25_error(card, err, X25_HDLC_LINK_DISC, 0));
if (err)
printk(KERN_INFO "%s: Hdlc Link Down Failed %x\n",card->devname,err);
disconnect (card);
}
static int check_bad_command(sdla_t* card, struct net_device *dev)
{
x25_channel_t *chan = dev->priv;
int bad_cmd = 0;
switch (atomic_read(&chan->common.command)&0x7F){
case X25_PLACE_CALL:
if (chan->common.state != WAN_DISCONNECTED)
bad_cmd=1;
break;
case X25_CLEAR_CALL:
if (chan->common.state == WAN_DISCONNECTED)
bad_cmd=1;
break;
case X25_ACCEPT_CALL:
if (chan->common.state != WAN_CONNECTING)
bad_cmd=1;
break;
case X25_RESET:
if (chan->common.state != WAN_CONNECTED)
bad_cmd=1;
break;
default:
bad_cmd=1;
break;
}
if (bad_cmd){
printk(KERN_INFO "%s: Invalid State, BAD Command %x, dev %s, lcn %i, st %i\n",
card->devname,atomic_read(&chan->common.command),dev->name,
chan->common.lcn, chan->common.state);
}
return bad_cmd;
}
/*************************** XPIPEMON FUNCTIONS **************************/
/*==============================================================================
* Process UDP call of type XPIPE
*/
static int process_udp_mgmt_pkt(sdla_t *card)
{
int c_retry = MAX_CMD_RETRY;
unsigned int len;
struct sk_buff *new_skb;
TX25Mbox *mbox = card->mbox;
int err;
int udp_mgmt_req_valid = 1;
struct net_device *dev;
x25_channel_t *chan;
unsigned short lcn;
struct timeval tv;
x25_udp_pkt_t *x25_udp_pkt;
x25_udp_pkt = (x25_udp_pkt_t *)card->u.x.udp_pkt_data;
dev = card->u.x.udp_dev;
chan = dev->priv;
lcn = chan->common.lcn;
switch(x25_udp_pkt->cblock.command) {
/* XPIPE_ENABLE_TRACE */
case XPIPE_ENABLE_TRACING:
/* XPIPE_GET_TRACE_INFO */
case XPIPE_GET_TRACE_INFO:
/* SET FT1 MODE */
case XPIPE_SET_FT1_MODE:
if(card->u.x.udp_pkt_src == UDP_PKT_FRM_NETWORK) {
++chan->pipe_mgmt_stat.UDP_PIPE_mgmt_direction_err;
udp_mgmt_req_valid = 0;
break;
}
/* XPIPE_FT1_READ_STATUS */
case XPIPE_FT1_READ_STATUS:
/* FT1 MONITOR STATUS */
case XPIPE_FT1_STATUS_CTRL:
if(card->hw.fwid != SFID_X25_508) {
++chan->pipe_mgmt_stat.UDP_PIPE_mgmt_adptr_type_err;
udp_mgmt_req_valid = 0;
break;
}
default:
break;
}
if(!udp_mgmt_req_valid) {
/* set length to 0 */
x25_udp_pkt->cblock.length = 0;
/* set return code */
x25_udp_pkt->cblock.result = (card->hw.fwid != SFID_X25_508) ? 0x1F : 0xCD;
} else {
switch (x25_udp_pkt->cblock.command) {
case XPIPE_FLUSH_DRIVER_STATS:
init_x25_channel_struct(chan);
init_global_statistics(card);
mbox->cmd.length = 0;
break;
case XPIPE_DRIVER_STAT_IFSEND:
memcpy(x25_udp_pkt->data, &chan->if_send_stat, sizeof(if_send_stat_t));
mbox->cmd.length = sizeof(if_send_stat_t);
x25_udp_pkt->cblock.length = mbox->cmd.length;
break;
case XPIPE_DRIVER_STAT_INTR:
memcpy(&x25_udp_pkt->data[0], &card->statistics, sizeof(global_stats_t));
memcpy(&x25_udp_pkt->data[sizeof(global_stats_t)],
&chan->rx_intr_stat, sizeof(rx_intr_stat_t));
mbox->cmd.length = sizeof(global_stats_t) +
sizeof(rx_intr_stat_t);
x25_udp_pkt->cblock.length = mbox->cmd.length;
break;
case XPIPE_DRIVER_STAT_GEN:
memcpy(x25_udp_pkt->data,
&chan->pipe_mgmt_stat.UDP_PIPE_mgmt_kmalloc_err,
sizeof(pipe_mgmt_stat_t));
memcpy(&x25_udp_pkt->data[sizeof(pipe_mgmt_stat_t)],
&card->statistics, sizeof(global_stats_t));
x25_udp_pkt->cblock.result = 0;
x25_udp_pkt->cblock.length = sizeof(global_stats_t)+
sizeof(rx_intr_stat_t);
mbox->cmd.length = x25_udp_pkt->cblock.length;
break;
case XPIPE_ROUTER_UP_TIME:
do_gettimeofday(&tv);
chan->router_up_time = tv.tv_sec - chan->router_start_time;
*(unsigned long *)&x25_udp_pkt->data = chan->router_up_time;
x25_udp_pkt->cblock.length = mbox->cmd.length = 4;
x25_udp_pkt->cblock.result = 0;
break;
default :
do {
memcpy(&mbox->cmd, &x25_udp_pkt->cblock.command, sizeof(TX25Cmd));
if(mbox->cmd.length){
memcpy(&mbox->data,
(char *)x25_udp_pkt->data,
mbox->cmd.length);
}
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
} while (err && c_retry-- && x25_error(card, err, mbox->cmd.command, 0));
if ( err == CMD_OK ||
(err == 1 &&
(mbox->cmd.command == 0x06 ||
mbox->cmd.command == 0x16) ) ){
++chan->pipe_mgmt_stat.UDP_PIPE_mgmt_adptr_cmnd_OK;
} else {
++chan->pipe_mgmt_stat.UDP_PIPE_mgmt_adptr_cmnd_timeout;
}
/* copy the result back to our buffer */
memcpy(&x25_udp_pkt->cblock.command, &mbox->cmd, sizeof(TX25Cmd));
if(mbox->cmd.length) {
memcpy(&x25_udp_pkt->data, &mbox->data, mbox->cmd.length);
}
break;
} //switch
}
/* Fill UDP TTL */
x25_udp_pkt->ip_pkt.ttl = card->wandev.ttl;
len = reply_udp(card->u.x.udp_pkt_data, mbox->cmd.length);
if(card->u.x.udp_pkt_src == UDP_PKT_FRM_NETWORK) {
err = x25_send(card, lcn, 0, len, card->u.x.udp_pkt_data);
if (!err)
++chan->pipe_mgmt_stat.UDP_PIPE_mgmt_adptr_send_passed;
else
++chan->pipe_mgmt_stat.UDP_PIPE_mgmt_adptr_send_failed;
} else {
/* Allocate socket buffer */
if((new_skb = dev_alloc_skb(len)) != NULL) {
void *buf;
/* copy data into new_skb */
buf = skb_put(new_skb, len);
memcpy(buf, card->u.x.udp_pkt_data, len);
/* Decapsulate packet and pass it up the protocol
stack */
new_skb->dev = dev;
if (chan->common.usedby == API)
new_skb->protocol = htons(X25_PROT);
else
new_skb->protocol = htons(ETH_P_IP);
new_skb->mac.raw = new_skb->data;
netif_rx(new_skb);
++chan->pipe_mgmt_stat.UDP_PIPE_mgmt_passed_to_stack;
} else {
++chan->pipe_mgmt_stat.UDP_PIPE_mgmt_no_socket;
printk(KERN_INFO
"%s: UDP mgmt cmnd, no socket buffers available!\n",
card->devname);
}
}
card->u.x.udp_pkt_lgth = 0;
return 1;
}
/*==============================================================================
* Determine what type of UDP call it is. DRVSTATS or XPIPE8ND ?
*/
static int udp_pkt_type( struct sk_buff *skb, sdla_t* card )
{
x25_udp_pkt_t *x25_udp_pkt = (x25_udp_pkt_t *)skb->data;
if((x25_udp_pkt->ip_pkt.protocol == UDPMGMT_UDP_PROTOCOL) &&
(x25_udp_pkt->ip_pkt.ver_inet_hdr_length == 0x45) &&
(x25_udp_pkt->udp_pkt.udp_dst_port == ntohs(card->wandev.udp_port)) &&
(x25_udp_pkt->wp_mgmt.request_reply == UDPMGMT_REQUEST)) {
if(!strncmp(x25_udp_pkt->wp_mgmt.signature,
UDPMGMT_XPIPE_SIGNATURE, 8)){
return UDP_XPIPE_TYPE;
}else{
printk(KERN_INFO "%s: UDP Packet, Failed Signature !\n",
card->devname);
}
}
return UDP_INVALID_TYPE;
}
/*============================================================================
* Reply to UDP Management system.
* Return nothing.
*/
static int reply_udp( unsigned char *data, unsigned int mbox_len )
{
unsigned short len, udp_length, temp, ip_length;
unsigned long ip_temp;
int even_bound = 0;
x25_udp_pkt_t *x25_udp_pkt = (x25_udp_pkt_t *)data;
/* Set length of packet */
len = sizeof(ip_pkt_t)+
sizeof(udp_pkt_t)+
sizeof(wp_mgmt_t)+
sizeof(cblock_t)+
mbox_len;
/* fill in UDP reply */
x25_udp_pkt->wp_mgmt.request_reply = UDPMGMT_REPLY;
/* fill in UDP length */
udp_length = sizeof(udp_pkt_t)+
sizeof(wp_mgmt_t)+
sizeof(cblock_t)+
mbox_len;
/* put it on an even boundary */
if ( udp_length & 0x0001 ) {
udp_length += 1;
len += 1;
even_bound = 1;
}
temp = (udp_length<<8)|(udp_length>>8);
x25_udp_pkt->udp_pkt.udp_length = temp;
/* swap UDP ports */
temp = x25_udp_pkt->udp_pkt.udp_src_port;
x25_udp_pkt->udp_pkt.udp_src_port =
x25_udp_pkt->udp_pkt.udp_dst_port;
x25_udp_pkt->udp_pkt.udp_dst_port = temp;
/* add UDP pseudo header */
temp = 0x1100;
*((unsigned short *)
(x25_udp_pkt->data+mbox_len+even_bound)) = temp;
temp = (udp_length<<8)|(udp_length>>8);
*((unsigned short *)
(x25_udp_pkt->data+mbox_len+even_bound+2)) = temp;
/* calculate UDP checksum */
x25_udp_pkt->udp_pkt.udp_checksum = 0;
x25_udp_pkt->udp_pkt.udp_checksum =
calc_checksum(&data[UDP_OFFSET], udp_length+UDP_OFFSET);
/* fill in IP length */
ip_length = len;
temp = (ip_length<<8)|(ip_length>>8);
x25_udp_pkt->ip_pkt.total_length = temp;
/* swap IP addresses */
ip_temp = x25_udp_pkt->ip_pkt.ip_src_address;
x25_udp_pkt->ip_pkt.ip_src_address =
x25_udp_pkt->ip_pkt.ip_dst_address;
x25_udp_pkt->ip_pkt.ip_dst_address = ip_temp;
/* fill in IP checksum */
x25_udp_pkt->ip_pkt.hdr_checksum = 0;
x25_udp_pkt->ip_pkt.hdr_checksum = calc_checksum(data, sizeof(ip_pkt_t));
return len;
} /* reply_udp */
unsigned short calc_checksum (char *data, int len)
{
unsigned short temp;
unsigned long sum=0;
int i;
for( i = 0; i <len; i+=2 ) {
memcpy(&temp,&data[i],2);
sum += (unsigned long)temp;
}
while (sum >> 16 ) {
sum = (sum & 0xffffUL) + (sum >> 16);
}
temp = (unsigned short)sum;
temp = ~temp;
if( temp == 0 )
temp = 0xffff;
return temp;
}
/*=============================================================================
* Store a UDP management packet for later processing.
*/
static int store_udp_mgmt_pkt(int udp_type, char udp_pkt_src, sdla_t* card,
struct net_device *dev, struct sk_buff *skb,
int lcn)
{
int udp_pkt_stored = 0;
if(!card->u.x.udp_pkt_lgth && (skb->len <= MAX_LGTH_UDP_MGNT_PKT)){
card->u.x.udp_pkt_lgth = skb->len;
card->u.x.udp_type = udp_type;
card->u.x.udp_pkt_src = udp_pkt_src;
card->u.x.udp_lcn = lcn;
card->u.x.udp_dev = dev;
memcpy(card->u.x.udp_pkt_data, skb->data, skb->len);
card->u.x.timer_int_enabled |= TMR_INT_ENABLED_UDP_PKT;
udp_pkt_stored = 1;
}else{
printk(KERN_INFO "%s: ERROR: UDP packet not stored for LCN %d\n",
card->devname,lcn);
}
if(udp_pkt_src == UDP_PKT_FRM_STACK){
dev_kfree_skb_any(skb);
}else{
dev_kfree_skb_any(skb);
}
return(udp_pkt_stored);
}
/*=============================================================================
* Initial the ppp_private_area structure.
*/
static void init_x25_channel_struct( x25_channel_t *chan )
{
memset(&chan->if_send_stat.if_send_entry,0,sizeof(if_send_stat_t));
memset(&chan->rx_intr_stat.rx_intr_no_socket,0,sizeof(rx_intr_stat_t));
memset(&chan->pipe_mgmt_stat.UDP_PIPE_mgmt_kmalloc_err,0,sizeof(pipe_mgmt_stat_t));
}
/*============================================================================
* Initialize Global Statistics
*/
static void init_global_statistics( sdla_t *card )
{
memset(&card->statistics.isr_entry,0,sizeof(global_stats_t));
}
/*===============================================================
* SMP Support
* ==============================================================*/
static void S508_S514_lock(sdla_t *card, unsigned long *smp_flags)
{
spin_lock_irqsave(&card->wandev.lock, *smp_flags);
}
static void S508_S514_unlock(sdla_t *card, unsigned long *smp_flags)
{
spin_unlock_irqrestore(&card->wandev.lock, *smp_flags);
}
/*===============================================================
* x25_timer_routine
*
* A more efficient polling routine. Each half a second
* queue a polling task. We want to do the polling in a
* task not timer, because timer runs in interrupt time.
*
* FIXME Polling should be rethinked.
*==============================================================*/
static void x25_timer_routine(unsigned long data)
{
sdla_t *card = (sdla_t*)data;
if (!card->wandev.dev){
printk(KERN_INFO "%s: Stopping the X25 Poll Timer: No Dev.\n",
card->devname);
return;
}
if (card->open_cnt != card->u.x.num_of_ch){
printk(KERN_INFO "%s: Stopping the X25 Poll Timer: Interface down.\n",
card->devname);
return;
}
if (test_bit(PERI_CRIT,&card->wandev.critical)){
printk(KERN_INFO "%s: Stopping the X25 Poll Timer: Shutting down.\n",
card->devname);
return;
}
if (!test_and_set_bit(POLL_CRIT,&card->wandev.critical)){
trigger_x25_poll(card);
}
card->u.x.x25_timer.expires=jiffies+(HZ>>1);
add_timer(&card->u.x.x25_timer);
return;
}
void disable_comm_shutdown(sdla_t *card)
{
TX25Mbox* mbox = card->mbox;
int err;
/* Turn of interrutps */
mbox->data[0] = 0;
if (card->hw.fwid == SFID_X25_508){
mbox->data[1] = card->hw.irq;
mbox->data[2] = 2;
mbox->cmd.length = 3;
}else {
mbox->cmd.length = 1;
}
mbox->cmd.command = X25_SET_INTERRUPT_MODE;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
if (err)
printk(KERN_INFO "INTERRUPT OFF FAIED %x\n",err);
/* Bring down HDLC */
mbox->cmd.command = X25_HDLC_LINK_CLOSE;
mbox->cmd.length = 0;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
if (err)
printk(KERN_INFO "LINK CLOSED FAILED %x\n",err);
/* Brind down DTR */
mbox->data[0] = 0;
mbox->data[2] = 0;
mbox->data[1] = 0x01;
mbox->cmd.length = 3;
mbox->cmd.command = X25_SET_GLOBAL_VARS;
err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
if (err)
printk(KERN_INFO "DTR DOWN FAILED %x\n",err);
}
MODULE_LICENSE("GPL");
/****** End *****************************************************************/
Reference in New Issue Copy Permalink