git.oblomov.eu Git - linux-2.6/blob - drivers/net/wan/sdla_x25.c

   1 /*****************************************************************************
   2 * sdla_x25.c    WANPIPE(tm) Multiprotocol WAN Link Driver.  X.25 module.
   3 *
   4 * Author:       Nenad Corbic    <ncorbic@sangoma.com>
   5 *
   6 * Copyright:    (c) 1995-2001 Sangoma Technologies Inc.
   7 *
   8 *               This program is free software; you can redistribute it and/or
   9 *               modify it under the terms of the GNU General Public License
  10 *               as published by the Free Software Foundation; either version
  11 *               2 of the License, or (at your option) any later version.
  12 * ============================================================================
  13 * Apr 03, 2001  Nenad Corbic     o Fixed the rx_skb=NULL bug in x25 in rx_intr().
  14 * Dec 26, 2000  Nenad Corbic     o Added a new polling routine, that uses
  15 *                                  a kernel timer (more efficient).
  16 * Dec 25, 2000  Nenad Corbic     o Updated for 2.4.X kernel
  17 * Jul 26, 2000  Nenad Corbic     o Increased the local packet buffering
  18 *                                  for API to 4096+header_size.
  19 * Jul 17, 2000  Nenad Corbic     o Fixed the x25 startup bug. Enable
  20 *                                  communications only after all interfaces
  21 *                                  come up.  HIGH SVC/PVC is used to calculate
  22 *                                  the number of channels.
  23 *                                  Enable protocol only after all interfaces
  24 *                                  are enabled.
  25 * Jul 10, 2000  Nenad Corbic     o Fixed the M_BIT bug.
  26 * Apr 25, 2000  Nenad Corbic     o Pass Modem messages to the API.
  27 *                                  Disable idle timeout in X25 API.
  28 * Apr 14, 2000  Nenad Corbic     o Fixed: Large LCN number support.
  29 *                                  Maximum LCN number is 4095.
  30 *                                  Maximum number of X25 channels is 255.
  31 * Apr 06, 2000  Nenad Corbic     o Added SMP Support.
  32 * Mar 29, 2000  Nenad Corbic     o Added support for S514 PCI Card
  33 * Mar 23, 2000  Nenad Corbic     o Improved task queue, BH handling.
  34 * Mar 14, 2000  Nenad Corbic     o Updated Protocol Violation handling
  35 *                                  routines.  Bug Fix.
  36 * Mar 10, 2000  Nenad Corbic     o Bug Fix: corrupted mbox recovery.
  37 * Mar 09, 2000  Nenad Corbic     o Fixed the auto HDLC bug.
  38 * Mar 08, 2000  Nenad Corbic     o Fixed LAPB HDLC startup problems.
  39 *                                  Application must bring the link up
  40 *                                  before tx/rx, and bring the
  41 *                                  link down on close().
  42 * Mar 06, 2000  Nenad Corbic     o Added an option for logging call setup
  43 *                                  information.
  44 * Feb 29, 2000  Nenad Corbic     o Added support for LAPB HDLC API
  45 * Feb 25, 2000  Nenad Corbic     o Fixed the modem failure handling.
  46 *                                  No Modem OOB message will be passed
  47 *                                  to the user.
  48 * Feb 21, 2000  Nenad Corbic     o Added Xpipemon Debug Support
  49 * Dec 30, 1999  Nenad Corbic     o Socket based X25API
  50 * Sep 17, 1998  Jaspreet Singh   o Updates for 2.2.X  kernel
  51 * Mar 15, 1998  Alan Cox         o 2.1.x porting
  52 * Dec 19, 1997  Jaspreet Singh   o Added multi-channel IPX support
  53 * Nov 27, 1997  Jaspreet Singh   o Added protection against enabling of irqs
  54 *                                  when they are disabled.
  55 * Nov 17, 1997  Farhan Thawar    o Added IPX support
  56 *                                o Changed if_send() to now buffer packets when
  57 *                                  the board is busy
  58 *                                o Removed queueing of packets via the polling
  59 *                                  routing
  60 *                                o Changed if_send() critical flags to properly
  61 *                                  handle race conditions
  62 * Nov 06, 1997  Farhan Thawar    o Added support for SVC timeouts
  63 *                                o Changed PVC encapsulation to ETH_P_IP
  64 * Jul 21, 1997  Jaspreet Singh   o Fixed freeing up of buffers using kfree()
  65 *                                  when packets are received.
  66 * Mar 11, 1997  Farhan Thawar   Version 3.1.1
  67 *                                o added support for V35
  68 *                                o changed if_send() to return 0 if
  69 *                                  wandev.critical() is true
  70 *                                o free socket buffer in if_send() if
  71 *                                  returning 0
  72 *                                o added support for single '@' address to
  73 *                                  accept all incoming calls
  74 *                                o fixed bug in set_chan_state() to disconnect
  75 * Jan 15, 1997  Gene Kozin      Version 3.1.0
  76 *                                o implemented exec() entry point
  77 * Jan 07, 1997  Gene Kozin      Initial version.
  78 *****************************************************************************/
  79
  80 /*======================================================
  81  *      Includes
  82  *=====================================================*/
  83
  84 #include <linux/module.h>
  85 #include <linux/kernel.h>       /* printk(), and other useful stuff */
  86 #include <linux/stddef.h>       /* offsetof(), etc. */
  87 #include <linux/errno.h>        /* return codes */
  88 #include <linux/string.h>       /* inline memset(), etc. */
  89 #include <linux/ctype.h>
  90 #include <linux/slab.h> /* kmalloc(), kfree() */
  91 #include <linux/wanrouter.h>    /* WAN router definitions */
  92 #include <linux/wanpipe.h>      /* WANPIPE common user API definitions */
  93 #include <linux/workqueue.h>
  94 #include <asm/byteorder.h>      /* htons(), etc. */
  95 #include <asm/atomic.h>
  96 #include <linux/delay.h>        /* Experimental delay */
  97
  98 #include <asm/uaccess.h>
  99
 100 #include <linux/if.h>
 101 #include <linux/if_arp.h>
 102 #include <linux/sdla_x25.h>     /* X.25 firmware API definitions */
 103 #include <linux/if_wanpipe_common.h>
 104 #include <linux/if_wanpipe.h>
 105
 106
 107 /*======================================================
 108  *      Defines & Macros
 109  *=====================================================*/
 110
 111
 112 #define CMD_OK          0               /* normal firmware return code */
 113 #define CMD_TIMEOUT     0xFF            /* firmware command timed out */
 114 #define MAX_CMD_RETRY   10              /* max number of firmware retries */
 115
 116 #define X25_CHAN_MTU    4096            /* unfragmented logical channel MTU */
 117 #define X25_HRDHDR_SZ   7               /* max encapsulation header size */
 118 #define X25_CONCT_TMOUT (90*HZ)         /* link connection timeout */
 119 #define X25_RECON_TMOUT (10*HZ)         /* link connection timeout */
 120 #define CONNECT_TIMEOUT (90*HZ)         /* link connection timeout */
 121 #define HOLD_DOWN_TIME  (30*HZ)         /* link hold down time */
 122 #define MAX_BH_BUFF     10
 123 #define M_BIT           0x01
 124
 125 //#define PRINT_DEBUG 1
 126 #ifdef PRINT_DEBUG
 127 #define DBG_PRINTK(format, a...) printk(format, ## a)
 128 #else
 129 #define DBG_PRINTK(format, a...)
 130 #endif
 131
 132 #define TMR_INT_ENABLED_POLL_ACTIVE      0x01
 133 #define TMR_INT_ENABLED_POLL_CONNECT_ON  0x02
 134 #define TMR_INT_ENABLED_POLL_CONNECT_OFF 0x04
 135 #define TMR_INT_ENABLED_POLL_DISCONNECT  0x08
 136 #define TMR_INT_ENABLED_CMD_EXEC         0x10
 137 #define TMR_INT_ENABLED_UPDATE           0x20
 138 #define TMR_INT_ENABLED_UDP_PKT          0x40
 139
 140 #define MAX_X25_ADDR_SIZE       16
 141 #define MAX_X25_DATA_SIZE       129
 142 #define MAX_X25_FACL_SIZE       110
 143
 144 #define TRY_CMD_AGAIN   2
 145 #define DELAY_RESULT    1
 146 #define RETURN_RESULT   0
 147
 148 #define DCD(x) (x & 0x03 ? "HIGH" : "LOW")
 149 #define CTS(x) (x & 0x05 ? "HIGH" : "LOW")
 150
 151
 152 /* Driver will not write log messages about
 153  * modem status if defined.*/
 154 #define MODEM_NOT_LOG 1
 155
 156 /*====================================================
 157  *      For IPXWAN
 158  *===================================================*/
 159
 160 #define CVHexToAscii(b) (((unsigned char)(b) > (unsigned char)9) ? ((unsigned char)'A' + ((unsigned char)(b) - (unsigned char)10)) : ((unsigned char)'0' + (unsigned char)(b)))
 161
 162
 163 /*====================================================
 164  *           MEMORY DEBUGGING FUNCTION
 165  *====================================================
 166
 167 #define KMEM_SAFETYZONE 8
 168
 169 static void * dbg_kmalloc(unsigned int size, int prio, int line) {
 170         int i = 0;
 171         void * v = kmalloc(size+sizeof(unsigned int)+2*KMEM_SAFETYZONE*8,prio);
 172         char * c1 = v;
 173         c1 += sizeof(unsigned int);
 174         *((unsigned int *)v) = size;
 175
 176         for (i = 0; i < KMEM_SAFETYZONE; i++) {
 177                 c1[0] = 'D'; c1[1] = 'E'; c1[2] = 'A'; c1[3] = 'D';
 178                 c1[4] = 'B'; c1[5] = 'E'; c1[6] = 'E'; c1[7] = 'F';
 179                 c1 += 8;
 180         }
 181         c1 += size;
 182         for (i = 0; i < KMEM_SAFETYZONE; i++) {
 183                 c1[0] = 'M'; c1[1] = 'U'; c1[2] = 'N'; c1[3] = 'G';
 184                 c1[4] = 'W'; c1[5] = 'A'; c1[6] = 'L'; c1[7] = 'L';
 185                 c1 += 8;
 186         }
 187         v = ((char *)v) + sizeof(unsigned int) + KMEM_SAFETYZONE*8;
 188         printk(KERN_INFO "line %d  kmalloc(%d,%d) = %p\n",line,size,prio,v);
 189         return v;
 190 }
 191 static void dbg_kfree(void * v, int line) {
 192         unsigned int * sp = (unsigned int *)(((char *)v) - (sizeof(unsigned int) + KMEM_SAFETYZONE*8));
 193         unsigned int size = *sp;
 194         char * c1 = ((char *)v) - KMEM_SAFETYZONE*8;
 195         int i = 0;
 196         for (i = 0; i < KMEM_SAFETYZONE; i++) {
 197                 if (   c1[0] != 'D' || c1[1] != 'E' || c1[2] != 'A' || c1[3] != 'D'
 198                     || c1[4] != 'B' || c1[5] != 'E' || c1[6] != 'E' || c1[7] != 'F') {
 199                         printk(KERN_INFO "kmalloced block at %p has been corrupted (underrun)!\n",v);
 200                         printk(KERN_INFO " %4x: %2x %2x %2x %2x %2x %2x %2x %2x\n", i*8,
 201                                         c1[0],c1[1],c1[2],c1[3],c1[4],c1[5],c1[6],c1[7] );
 202                 }
 203                 c1 += 8;
 204         }
 205         c1 += size;
 206         for (i = 0; i < KMEM_SAFETYZONE; i++) {
 207                 if (   c1[0] != 'M' || c1[1] != 'U' || c1[2] != 'N' || c1[3] != 'G'
 208                     || c1[4] != 'W' || c1[5] != 'A' || c1[6] != 'L' || c1[7] != 'L'
 209                    ) {
 210                         printk(KERN_INFO "kmalloced block at %p has been corrupted (overrun):\n",v);
 211                         printk(KERN_INFO " %4x: %2x %2x %2x %2x %2x %2x %2x %2x\n", i*8,
 212                                         c1[0],c1[1],c1[2],c1[3],c1[4],c1[5],c1[6],c1[7] );
 213                 }
 214                 c1 += 8;
 215         }
 216         printk(KERN_INFO "line %d  kfree(%p)\n",line,v);
 217         v = ((char *)v) - (sizeof(unsigned int) + KMEM_SAFETYZONE*8);
 218         kfree(v);
 219 }
 220
 221 #define kmalloc(x,y) dbg_kmalloc(x,y,__LINE__)
 222 #define kfree(x) dbg_kfree(x,__LINE__)
 223
 224 ==============================================================*/
 225
 226
 227
 228 /*===============================================
 229  *      Data Structures
 230  *===============================================*/
 231
 232
 233 /*========================================================
 234  * Name:        x25_channel
 235  *
 236  * Purpose:     To hold private informaton for each
 237  *              logical channel.
 238  *
 239  * Rationale:   Per-channel debugging is possible if each
 240  *              channel has its own private area.
 241  *
 242  * Assumptions:
 243  *
 244  * Description: This is an extention of the struct net_device
 245  *              we create for each network interface to keep
 246  *              the rest of X.25 channel-specific data.
 247  *
 248  * Construct:   Typedef
 249  */
 250 typedef struct x25_channel
 251 {
 252         wanpipe_common_t common;        /* common area for x25api and socket */
 253         char name[WAN_IFNAME_SZ+1];     /* interface name, ASCIIZ */
 254         char addr[WAN_ADDRESS_SZ+1];    /* media address, ASCIIZ */
 255         unsigned tx_pkt_size;
 256         unsigned short protocol;        /* ethertype, 0 - multiplexed */
 257         char drop_sequence;             /* mark sequence for dropping */
 258         unsigned long state_tick;       /* time of the last state change */
 259         unsigned idle_timeout;          /* sec, before disconnecting */
 260         unsigned long i_timeout_sofar;  /* # of sec's we've been idle */
 261         unsigned hold_timeout;          /* sec, before re-connecting */
 262         unsigned long tick_counter;     /* counter for transmit time out */
 263         char devtint;                   /* Weather we should dev_tint() */
 264         struct sk_buff* rx_skb;         /* receive socket buffer */
 265         struct sk_buff* tx_skb;         /* transmit socket buffer */
 266
 267         bh_data_t *bh_head;               /* Circular buffer for x25api_bh */
 268         unsigned long  tq_working;
 269         volatile int  bh_write;
 270         volatile int  bh_read;
 271         atomic_t  bh_buff_used;
 272
 273         sdla_t* card;                   /* -> owner */
 274         struct net_device *dev;         /* -> bound devce */
 275
 276         int ch_idx;
 277         unsigned char enable_IPX;
 278         unsigned long network_number;
 279         struct net_device_stats ifstats;        /* interface statistics */
 280         unsigned short transmit_length;
 281         unsigned short tx_offset;
 282         char transmit_buffer[X25_CHAN_MTU+sizeof(x25api_hdr_t)];
 283
 284         if_send_stat_t   if_send_stat;
 285         rx_intr_stat_t   rx_intr_stat;
 286         pipe_mgmt_stat_t pipe_mgmt_stat;
 287
 288         unsigned long router_start_time; /* Router start time in seconds */
 289         unsigned long router_up_time;
 290
 291 } x25_channel_t;
 292
 293 /* FIXME Take this out */
 294
 295 #ifdef NEX_OLD_CALL_INFO
 296 typedef struct x25_call_info
 297 {
 298         char dest[17];                  PACKED;/* ASCIIZ destination address */
 299         char src[17];                   PACKED;/* ASCIIZ source address */
 300         char nuser;                     PACKED;/* number of user data bytes */
 301         unsigned char user[127];        PACKED;/* user data */
 302         char nfacil;                    PACKED;/* number of facilities */
 303         struct
 304         {
 305                 unsigned char code;     PACKED;
 306                 unsigned char parm;     PACKED;
 307         } facil[64];                            /* facilities */
 308 } x25_call_info_t;
 309 #else
 310 typedef struct x25_call_info
 311 {
 312         char dest[MAX_X25_ADDR_SIZE]            PACKED;/* ASCIIZ destination address */
 313         char src[MAX_X25_ADDR_SIZE]             PACKED;/* ASCIIZ source address */
 314         unsigned char nuser                     PACKED;
 315         unsigned char user[MAX_X25_DATA_SIZE]   PACKED;/* user data */
 316         unsigned char nfacil                    PACKED;
 317         unsigned char facil[MAX_X25_FACL_SIZE]  PACKED;
 318         unsigned short lcn                      PACKED;
 319 } x25_call_info_t;
 320 #endif
 321
 322
 323
 324 /*===============================================
 325  *      Private Function Prototypes
 326  *==============================================*/
 327
 328
 329 /*=================================================
 330  * WAN link driver entry points. These are
 331  * called by the WAN router module.
 332  */
 333 static int update(struct wan_device* wandev);
 334 static int new_if(struct wan_device* wandev, struct net_device* dev,
 335                   wanif_conf_t* conf);
 336 static int del_if(struct wan_device* wandev, struct net_device* dev);
 337 static void disable_comm (sdla_t* card);
 338 static void disable_comm_shutdown(sdla_t *card);
 339
 340
 341
 342 /*=================================================
 343  *      WANPIPE-specific entry points
 344  */
 345 static int wpx_exec (struct sdla* card, void* u_cmd, void* u_data);
 346 static void x25api_bh(struct net_device *dev);
 347 static int x25api_bh_cleanup(struct net_device *dev);
 348 static int bh_enqueue(struct net_device *dev, struct sk_buff *skb);
 349
 350
 351 /*=================================================
 352  *      Network device interface
 353  */
 354 static int if_init(struct net_device* dev);
 355 static int if_open(struct net_device* dev);
 356 static int if_close(struct net_device* dev);
 357 static int if_header(struct sk_buff* skb, struct net_device* dev,
 358         unsigned short type, void* daddr, void* saddr, unsigned len);
 359 static int if_rebuild_hdr (struct sk_buff* skb);
 360 static int if_send(struct sk_buff* skb, struct net_device* dev);
 361 static struct net_device_stats *if_stats(struct net_device* dev);
 362
 363 static void if_tx_timeout(struct net_device *dev);
 364
 365 /*=================================================
 366  *      Interrupt handlers
 367  */
 368 static void wpx_isr     (sdla_t *);
 369 static void rx_intr     (sdla_t *);
 370 static void tx_intr     (sdla_t *);
 371 static void status_intr (sdla_t *);
 372 static void event_intr  (sdla_t *);
 373 static void spur_intr   (sdla_t *);
 374 static void timer_intr  (sdla_t *);
 375
 376 static int tx_intr_send(sdla_t *card, struct net_device *dev);
 377 static struct net_device *move_dev_to_next(sdla_t *card,
 378                                            struct net_device *dev);
 379
 380 /*=================================================
 381  *      Background polling routines
 382  */
 383 static void wpx_poll (sdla_t* card);
 384 static void poll_disconnected (sdla_t* card);
 385 static void poll_connecting (sdla_t* card);
 386 static void poll_active (sdla_t* card);
 387 static void trigger_x25_poll(sdla_t *card);
 388 static void x25_timer_routine(unsigned long data);
 389
 390
 391
 392 /*=================================================
 393  *      X.25 firmware interface functions
 394  */
 395 static int x25_get_version (sdla_t* card, char* str);
 396 static int x25_configure (sdla_t* card, TX25Config* conf);
 397 static int hdlc_configure (sdla_t* card, TX25Config* conf);
 398 static int set_hdlc_level (sdla_t* card);
 399 static int x25_get_err_stats (sdla_t* card);
 400 static int x25_get_stats (sdla_t* card);
 401 static int x25_set_intr_mode (sdla_t* card, int mode);
 402 static int x25_close_hdlc (sdla_t* card);
 403 static int x25_open_hdlc (sdla_t* card);
 404 static int x25_setup_hdlc (sdla_t* card);
 405 static int x25_set_dtr (sdla_t* card, int dtr);
 406 static int x25_get_chan_conf (sdla_t* card, x25_channel_t* chan);
 407 static int x25_place_call (sdla_t* card, x25_channel_t* chan);
 408 static int x25_accept_call (sdla_t* card, int lcn, int qdm);
 409 static int x25_clear_call (sdla_t* card, int lcn, int cause, int diagn);
 410 static int x25_send (sdla_t* card, int lcn, int qdm, int len, void* buf);
 411 static int x25_fetch_events (sdla_t* card);
 412 static int x25_error (sdla_t* card, int err, int cmd, int lcn);
 413
 414 /*=================================================
 415  *      X.25 asynchronous event handlers
 416  */
 417 static int incoming_call (sdla_t* card, int cmd, int lcn, TX25Mbox* mb);
 418 static int call_accepted (sdla_t* card, int cmd, int lcn, TX25Mbox* mb);
 419 static int call_cleared (sdla_t* card, int cmd, int lcn, TX25Mbox* mb);
 420 static int timeout_event (sdla_t* card, int cmd, int lcn, TX25Mbox* mb);
 421 static int restart_event (sdla_t* card, int cmd, int lcn, TX25Mbox* mb);
 422
 423
 424 /*=================================================
 425  *      Miscellaneous functions
 426  */
 427 static int connect (sdla_t* card);
 428 static int disconnect (sdla_t* card);
 429 static struct net_device* get_dev_by_lcn(struct wan_device* wandev,
 430                                          unsigned lcn);
 431 static int chan_connect(struct net_device* dev);
 432 static int chan_disc(struct net_device* dev);
 433 static void set_chan_state(struct net_device* dev, int state);
 434 static int chan_send(struct net_device *dev, void* buff, unsigned data_len,
 435                      unsigned char tx_intr);
 436 static unsigned char bps_to_speed_code (unsigned long bps);
 437 static unsigned int dec_to_uint (unsigned char* str, int len);
 438 static unsigned int hex_to_uint (unsigned char*, int);
 439 static void parse_call_info (unsigned char*, x25_call_info_t*);
 440 static struct net_device *find_channel(sdla_t *card, unsigned lcn);
 441 static void bind_lcn_to_dev(sdla_t *card, struct net_device *dev, unsigned lcn);
 442 static void setup_for_delayed_transmit(struct net_device *dev,
 443                                        void *buf, unsigned len);
 444
 445
 446 /*=================================================
 447  *      X25 API Functions
 448  */
 449 static int wanpipe_pull_data_in_skb(sdla_t *card, struct net_device *dev,
 450                                     struct sk_buff **);
 451 static void timer_intr_exec(sdla_t *, unsigned char);
 452 static int execute_delayed_cmd(sdla_t *card, struct net_device *dev,
 453                                mbox_cmd_t *usr_cmd, char bad_cmd);
 454 static int api_incoming_call (sdla_t*, TX25Mbox *, int);
 455 static int alloc_and_init_skb_buf (sdla_t *,struct sk_buff **, int);
 456 static void send_delayed_cmd_result(sdla_t *card, struct net_device *dev,
 457                                     TX25Mbox* mbox);
 458 static int clear_confirm_event (sdla_t *, TX25Mbox*);
 459 static void send_oob_msg (sdla_t *card, struct net_device *dev, TX25Mbox *mbox);
 460 static int timer_intr_cmd_exec(sdla_t *card);
 461 static void api_oob_event (sdla_t *card,TX25Mbox *mbox);
 462 static int check_bad_command(sdla_t *card, struct net_device *dev);
 463 static int channel_disconnect(sdla_t* card, struct net_device *dev);
 464 static void hdlc_link_down (sdla_t*);
 465
 466 /*=================================================
 467  *     XPIPEMON Functions
 468  */
 469 static int process_udp_mgmt_pkt(sdla_t *);
 470 static int udp_pkt_type( struct sk_buff *, sdla_t*);
 471 static int reply_udp( unsigned char *, unsigned int);
 472 static void init_x25_channel_struct( x25_channel_t *);
 473 static void init_global_statistics( sdla_t *);
 474 static int store_udp_mgmt_pkt(int udp_type, char udp_pkt_src, sdla_t *card,
 475                               struct net_device *dev,
 476                               struct sk_buff *skb, int lcn);
 477 static unsigned short calc_checksum (char *, int);
 478
 479
 480
 481 /*=================================================
 482  *      IPX functions
 483  */
 484 static void switch_net_numbers(unsigned char *, unsigned long, unsigned char);
 485 static int handle_IPXWAN(unsigned char *, char *, unsigned char ,
 486                          unsigned long , unsigned short );
 487
 488 extern void disable_irq(unsigned int);
 489 extern void enable_irq(unsigned int);
 490
 491 static void S508_S514_lock(sdla_t *, unsigned long *);
 492 static void S508_S514_unlock(sdla_t *, unsigned long *);
 493
 494
 495 /*=================================================
 496  *      Global Variables
 497  *=================================================*/
 498
 499
 500
 501 /*=================================================
 502  *      Public Functions
 503  *=================================================*/
 504
 505
 506
 507
 508 /*===================================================================
 509  * wpx_init:    X.25 Protocol Initialization routine.
 510  *
 511  * Purpose:     To initialize the protocol/firmware.
 512  *
 513  * Rationale:   This function is called by setup() function, in
 514  *              sdlamain.c, to dynamically setup the x25 protocol.
 515  *              This is the first protocol specific function, which
 516  *              executes once on startup.
 517  *
 518  * Description: This procedure initializes the x25 firmware and
 519  *              sets up the mailbox, transmit and receive buffer
 520  *              pointers. It also initializes all debugging structures
 521  *              and sets up the X25 environment.
 522  *
 523  *              Sets up hardware options defined by user in [wanpipe#]
 524  *              section of wanpipe#.conf configuration file.
 525  *
 526  *              At this point adapter is completely initialized
 527  *              and X.25 firmware is running.
 528  *              o read firmware version (to make sure it's alive)
 529  *              o configure adapter
 530  *              o initialize protocol-specific fields of the
 531  *                adapter data space.
 532  *
 533  * Called by:   setup() function in sdlamain.c
 534  *
 535  * Assumptions: None
 536  *
 537  * Warnings:    None
 538  *
 539  * Return:      0       o.k.
 540  *              < 0     failure.
 541  */
 542
 543 int wpx_init (sdla_t* card, wandev_conf_t* conf)
 544 {
 545         union{
 546                 char str[80];
 547                 TX25Config cfg;
 548         } u;
 549
 550         /* Verify configuration ID */
 551         if (conf->config_id != WANCONFIG_X25){
 552                 printk(KERN_INFO "%s: invalid configuration ID %u!\n",
 553                         card->devname, conf->config_id)
 554                 ;
 555                 return -EINVAL;
 556         }
 557
 558         /* Initialize protocol-specific fields */
 559         card->mbox  = (void*)(card->hw.dpmbase + X25_MBOX_OFFS);
 560         card->rxmb  = (void*)(card->hw.dpmbase + X25_RXMBOX_OFFS);
 561         card->flags = (void*)(card->hw.dpmbase + X25_STATUS_OFFS);
 562
 563         /* Initialize for S514 Card */
 564         if(card->hw.type == SDLA_S514) {
 565                 card->mbox += X25_MB_VECTOR;
 566                 card->flags += X25_MB_VECTOR;
 567                 card->rxmb += X25_MB_VECTOR;
 568         }
 569
 570
 571         /* Read firmware version.  Note that when adapter initializes, it
 572          * clears the mailbox, so it may appear that the first command was
 573          * executed successfully when in fact it was merely erased. To work
 574          * around this, we execute the first command twice.
 575          */
 576         if (x25_get_version(card, NULL) || x25_get_version(card, u.str))
 577                 return -EIO;
 578
 579
 580         /* X25 firmware can run ether in X25 or LAPB HDLC mode.
 581          * Check the user defined option and configure accordingly */
 582         if (conf->u.x25.LAPB_hdlc_only == WANOPT_YES){
 583                 if (set_hdlc_level(card) != CMD_OK){
 584                         return -EIO;
 585                 }else{
 586                         printk(KERN_INFO "%s: running LAP_B HDLC firmware v%s\n",
 587                                 card->devname, u.str);
 588                 }
 589                 card->u.x.LAPB_hdlc = 1;
 590         }else{
 591                 printk(KERN_INFO "%s: running X.25 firmware v%s\n",
 592                                 card->devname, u.str);
 593                 card->u.x.LAPB_hdlc = 0;
 594         }
 595
 596         /* Configure adapter. Here we set resonable defaults, then parse
 597          * device configuration structure and set configuration options.
 598          * Most configuration options are verified and corrected (if
 599          * necessary) since we can't rely on the adapter to do so.
 600          */
 601         memset(&u.cfg, 0, sizeof(u.cfg));
 602         u.cfg.t1                = 3;
 603         u.cfg.n2                = 10;
 604         u.cfg.autoHdlc          = 1;            /* automatic HDLC connection */
 605         u.cfg.hdlcWindow        = 7;
 606         u.cfg.pktWindow         = 2;
 607         u.cfg.station           = 1;            /* DTE */
 608         u.cfg.options           = 0x0090;       /* disable D-bit pragmatics */
 609         u.cfg.ccittCompat       = 1988;
 610         u.cfg.t10t20            = 30;
 611         u.cfg.t11t21            = 30;
 612         u.cfg.t12t22            = 30;
 613         u.cfg.t13t23            = 30;
 614         u.cfg.t16t26            = 30;
 615         u.cfg.t28               = 30;
 616         u.cfg.r10r20            = 5;
 617         u.cfg.r12r22            = 5;
 618         u.cfg.r13r23            = 5;
 619         u.cfg.responseOpt       = 1;            /* RR's after every packet */
 620
 621         if (card->u.x.LAPB_hdlc){
 622                 u.cfg.hdlcMTU = 1027;
 623         }
 624
 625         if (conf->u.x25.x25_conf_opt){
 626                 u.cfg.options = conf->u.x25.x25_conf_opt;
 627         }
 628
 629         if (conf->clocking != WANOPT_EXTERNAL)
 630                 u.cfg.baudRate = bps_to_speed_code(conf->bps);
 631
 632         if (conf->station != WANOPT_DTE){
 633                 u.cfg.station = 0;              /* DCE mode */
 634         }
 635
 636         if (conf->interface != WANOPT_RS232 ){
 637                 u.cfg.hdlcOptions |= 0x80;      /* V35 mode */
 638         }
 639
 640         /* adjust MTU */
 641         if (!conf->mtu || (conf->mtu >= 1024))
 642                 card->wandev.mtu = 1024;
 643         else if (conf->mtu >= 512)
 644                 card->wandev.mtu = 512;
 645         else if (conf->mtu >= 256)
 646                 card->wandev.mtu = 256;
 647         else if (conf->mtu >= 128)
 648                 card->wandev.mtu = 128;
 649         else
 650                 card->wandev.mtu = 64;
 651
 652         u.cfg.defPktSize = u.cfg.pktMTU = card->wandev.mtu;
 653
 654         if (conf->u.x25.hi_pvc){
 655                 card->u.x.hi_pvc = min_t(unsigned int, conf->u.x25.hi_pvc, MAX_LCN_NUM);
 656                 card->u.x.lo_pvc = min_t(unsigned int, conf->u.x25.lo_pvc, card->u.x.hi_pvc);
 657         }
 658
 659         if (conf->u.x25.hi_svc){
 660                 card->u.x.hi_svc = min_t(unsigned int, conf->u.x25.hi_svc, MAX_LCN_NUM);
 661                 card->u.x.lo_svc = min_t(unsigned int, conf->u.x25.lo_svc, card->u.x.hi_svc);
 662         }
 663
 664         /* Figure out the total number of channels to configure */
 665         card->u.x.num_of_ch = 0;
 666         if (card->u.x.hi_svc != 0){
 667                 card->u.x.num_of_ch = (card->u.x.hi_svc - card->u.x.lo_svc) + 1;
 668         }
 669         if (card->u.x.hi_pvc != 0){
 670                 card->u.x.num_of_ch += (card->u.x.hi_pvc - card->u.x.lo_pvc) + 1;
 671         }
 672
 673         if (card->u.x.num_of_ch == 0){
 674                 printk(KERN_INFO "%s: ERROR, Minimum number of PVC/SVC channels is 1 !\n"
 675                                  "%s: Please set the Lowest/Highest PVC/SVC values !\n",
 676                                  card->devname,card->devname);
 677                 return -ECHRNG;
 678         }
 679
 680         u.cfg.loPVC = card->u.x.lo_pvc;
 681         u.cfg.hiPVC = card->u.x.hi_pvc;
 682         u.cfg.loTwoWaySVC = card->u.x.lo_svc;
 683         u.cfg.hiTwoWaySVC = card->u.x.hi_svc;
 684
 685         if (conf->u.x25.hdlc_window)
 686                 u.cfg.hdlcWindow = min_t(unsigned int, conf->u.x25.hdlc_window, 7);
 687         if (conf->u.x25.pkt_window)
 688                 u.cfg.pktWindow = min_t(unsigned int, conf->u.x25.pkt_window, 7);
 689
 690         if (conf->u.x25.t1)
 691                 u.cfg.t1 = min_t(unsigned int, conf->u.x25.t1, 30);
 692         if (conf->u.x25.t2)
 693                 u.cfg.t2 = min_t(unsigned int, conf->u.x25.t2, 29);
 694         if (conf->u.x25.t4)
 695                 u.cfg.t4 = min_t(unsigned int, conf->u.x25.t4, 240);
 696         if (conf->u.x25.n2)
 697                 u.cfg.n2 = min_t(unsigned int, conf->u.x25.n2, 30);
 698
 699         if (conf->u.x25.t10_t20)
 700                 u.cfg.t10t20 = min_t(unsigned int, conf->u.x25.t10_t20,255);
 701         if (conf->u.x25.t11_t21)
 702                 u.cfg.t11t21 = min_t(unsigned int, conf->u.x25.t11_t21,255);
 703         if (conf->u.x25.t12_t22)
 704                 u.cfg.t12t22 = min_t(unsigned int, conf->u.x25.t12_t22,255);
 705         if (conf->u.x25.t13_t23)
 706                 u.cfg.t13t23 = min_t(unsigned int, conf->u.x25.t13_t23,255);
 707         if (conf->u.x25.t16_t26)
 708                 u.cfg.t16t26 = min_t(unsigned int, conf->u.x25.t16_t26, 255);
 709         if (conf->u.x25.t28)
 710                 u.cfg.t28 = min_t(unsigned int, conf->u.x25.t28, 255);
 711
 712         if (conf->u.x25.r10_r20)
 713                 u.cfg.r10r20 = min_t(unsigned int, conf->u.x25.r10_r20,250);
 714         if (conf->u.x25.r12_r22)
 715                 u.cfg.r12r22 = min_t(unsigned int, conf->u.x25.r12_r22,250);
 716         if (conf->u.x25.r13_r23)
 717                 u.cfg.r13r23 = min_t(unsigned int, conf->u.x25.r13_r23,250);
 718
 719
 720         if (conf->u.x25.ccitt_compat)
 721                 u.cfg.ccittCompat = conf->u.x25.ccitt_compat;
 722
 723         /* initialize adapter */
 724         if (card->u.x.LAPB_hdlc){
 725                 if (hdlc_configure(card, &u.cfg) != CMD_OK)
 726                         return -EIO;
 727         }else{
 728                 if (x25_configure(card, &u.cfg) != CMD_OK)
 729                         return -EIO;
 730         }
 731
 732         if ((x25_close_hdlc(card) != CMD_OK) ||         /* close HDLC link */
 733             (x25_set_dtr(card, 0) != CMD_OK))           /* drop DTR */
 734                 return -EIO;
 735
 736         /* Initialize protocol-specific fields of adapter data space */
 737         card->wandev.bps        = conf->bps;
 738         card->wandev.interface  = conf->interface;
 739         card->wandev.clocking   = conf->clocking;
 740         card->wandev.station    = conf->station;
 741         card->isr               = &wpx_isr;
 742         card->poll              = NULL; //&wpx_poll;
 743         card->disable_comm      = &disable_comm;
 744         card->exec              = &wpx_exec;
 745         card->wandev.update     = &update;
 746         card->wandev.new_if     = &new_if;
 747         card->wandev.del_if     = &del_if;
 748
 749         /* WARNING: This function cannot exit with an error
 750          *          after the change of state */
 751         card->wandev.state      = WAN_DISCONNECTED;
 752
 753         card->wandev.enable_tx_int = 0;
 754         card->irq_dis_if_send_count = 0;
 755         card->irq_dis_poll_count = 0;
 756         card->u.x.tx_dev = NULL;
 757         card->u.x.no_dev = 0;
 758
 759
 760         /* Configure for S514 PCI Card */
 761         if (card->hw.type == SDLA_S514) {
 762                 card->u.x.hdlc_buf_status =
 763                         (volatile unsigned char *)
 764                                 (card->hw.dpmbase + X25_MB_VECTOR+ X25_MISC_HDLC_BITS);
 765         }else{
 766                 card->u.x.hdlc_buf_status =
 767                         (volatile unsigned char *)(card->hw.dpmbase + X25_MISC_HDLC_BITS);
 768         }
 769
 770         card->u.x.poll_device=NULL;
 771         card->wandev.udp_port = conf->udp_port;
 772
 773         /* Enable or disable call setup logging */
 774         if (conf->u.x25.logging == WANOPT_YES){
 775                 printk(KERN_INFO "%s: Enabling Call Logging.\n",
 776                         card->devname);
 777                 card->u.x.logging = 1;
 778         }else{
 779                 card->u.x.logging = 0;
 780         }
 781
 782         /* Enable or disable modem status reporting */
 783         if (conf->u.x25.oob_on_modem == WANOPT_YES){
 784                 printk(KERN_INFO "%s: Enabling OOB on Modem change.\n",
 785                         card->devname);
 786                 card->u.x.oob_on_modem = 1;
 787         }else{
 788                 card->u.x.oob_on_modem = 0;
 789         }
 790
 791         init_global_statistics(card);
 792
 793         INIT_WORK(&card->u.x.x25_poll_work, (void *)wpx_poll, card);
 794
 795         init_timer(&card->u.x.x25_timer);
 796         card->u.x.x25_timer.data = (unsigned long)card;
 797         card->u.x.x25_timer.function = x25_timer_routine;
 798
 799         return 0;
 800 }
 801
 802 /*=========================================================
 803  *      WAN Device Driver Entry Points
 804  *========================================================*/
 805
 806 /*============================================================
 807  * Name:        update(),  Update device status & statistics.
 808  *
 809  * Purpose:     To provide debugging and statitical
 810  *              information to the /proc file system.
 811  *              /proc/net/wanrouter/wanpipe#
 812  *
 813  * Rationale:   The /proc file system is used to collect
 814  *              information about the kernel and drivers.
 815  *              Using the /proc file system the user
 816  *              can see exactly what the sangoma drivers are
 817  *              doing. And in what state they are in.
 818  *
 819  * Description: Collect all driver statistical information
 820  *              and pass it to the top laywer.
 821  *
 822  *              Since we have to execute a debugging command,
 823  *              to obtain firmware statitics, we trigger a
 824  *              UPDATE function within the timer interrtup.
 825  *              We wait until the timer update is complete.
 826  *              Once complete return the appropriate return
 827  *              code to indicate that the update was successful.
 828  *
 829  * Called by:   device_stat() in wanmain.c
 830  *
 831  * Assumptions:
 832  *
 833  * Warnings:    This function will degrade the performance
 834  *              of the router, since it uses the mailbox.
 835  *
 836  * Return:      0       OK
 837  *              <0      Failed (or busy).
 838  */
 839
 840 static int update(struct wan_device* wandev)
 841 {
 842         volatile sdla_t* card;
 843         TX25Status* status;
 844         unsigned long timeout;
 845
 846         /* sanity checks */
 847         if ((wandev == NULL) || (wandev->private == NULL))
 848                 return -EFAULT;
 849
 850         if (wandev->state == WAN_UNCONFIGURED)
 851                 return -ENODEV;
 852
 853         if (test_bit(SEND_CRIT, (void*)&wandev->critical))
 854                 return -EAGAIN;
 855
 856         if (!wandev->dev)
 857                 return -ENODEV;
 858
 859         card = wandev->private;
 860         status = card->flags;
 861
 862         card->u.x.timer_int_enabled |= TMR_INT_ENABLED_UPDATE;
 863         status->imask |= INTR_ON_TIMER;
 864         timeout = jiffies;
 865
 866         for (;;){
 867                 if (!(card->u.x.timer_int_enabled & TMR_INT_ENABLED_UPDATE)){
 868                         break;
 869                 }
 870                 if ((jiffies-timeout) > 1*HZ){
 871                         card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE;
 872                         return -EAGAIN;
 873                 }
 874         }
 875         return 0;
 876 }
 877
 878
 879 /*===================================================================
 880  * Name:        new_if
 881  *
 882  * Purpose:     To allocate and initialize resources for a
 883  *              new logical channel.
 884  *
 885  * Rationale:   A new channel can be added dynamically via
 886  *              ioctl call.
 887  *
 888  * Description: Allocate a private channel structure, x25_channel_t.
 889  *              Parse the user interface options from wanpipe#.conf
 890  *              configuration file.
 891  *              Bind the private are into the network device private
 892  *              area pointer (dev->priv).
 893  *              Prepare the network device structure for registration.
 894  *
 895  * Called by:   ROUTER_IFNEW Ioctl call, from wanrouter_ioctl()
 896  *              (wanmain.c)
 897  *
 898  * Assumptions: None
 899  *
 900  * Warnings:    None
 901  *
 902  * Return:      0       Ok
 903  *              <0      Failed (channel will not be created)
 904  */
 905 static int new_if(struct wan_device* wandev, struct net_device* dev,
 906                   wanif_conf_t* conf)
 907 {
 908         sdla_t* card = wandev->private;
 909         x25_channel_t* chan;
 910         int err = 0;
 911
 912         if ((conf->name[0] == '\0') || (strlen(conf->name) > WAN_IFNAME_SZ)){
 913                 printk(KERN_INFO "%s: invalid interface name!\n",
 914                         card->devname);
 915                 return -EINVAL;
 916         }
 917
 918         if(card->wandev.new_if_cnt++ > 0 && card->u.x.LAPB_hdlc) {
 919                 printk(KERN_INFO "%s: Error: Running LAPB HDLC Mode !\n",
 920                                                 card->devname);
 921                 printk(KERN_INFO
 922                         "%s: Maximum number of network interfaces must be one !\n",
 923                                                 card->devname);
 924                 return -EEXIST;
 925         }
 926
 927         /* allocate and initialize private data */
 928         chan = kmalloc(sizeof(x25_channel_t), GFP_ATOMIC);
 929         if (chan == NULL){
 930                 return -ENOMEM;
 931         }
 932
 933         memset(chan, 0, sizeof(x25_channel_t));
 934
 935         /* Bug Fix: Seg Err on PVC startup
 936          * It must be here since bind_lcn_to_dev expects
 937          * it bellow */
 938         dev->priv = chan;
 939
 940         strcpy(chan->name, conf->name);
 941         chan->card = card;
 942         chan->dev = dev;
 943         chan->common.sk = NULL;
 944         chan->common.func = NULL;
 945         chan->common.rw_bind = 0;
 946         chan->tx_skb = chan->rx_skb = NULL;
 947
 948         /* verify media address */
 949         if (conf->addr[0] == '@'){              /* SVC */
 950                 chan->common.svc = 1;
 951                 strncpy(chan->addr, &conf->addr[1], WAN_ADDRESS_SZ);
 952
 953                 /* Set channel timeouts (default if not specified) */
 954                 chan->idle_timeout = (conf->idle_timeout) ?
 955                                         conf->idle_timeout : 90;
 956                 chan->hold_timeout = (conf->hold_timeout) ?
 957                                         conf->hold_timeout : 10;
 958
 959         }else if (is_digit(conf->addr[0])){     /* PVC */
 960                 int lcn = dec_to_uint(conf->addr, 0);
 961
 962                 if ((lcn >= card->u.x.lo_pvc) && (lcn <= card->u.x.hi_pvc)){
 963                         bind_lcn_to_dev (card, dev, lcn);
 964                 }else{
 965                         printk(KERN_ERR
 966                                 "%s: PVC %u is out of range on interface %s!\n",
 967                                 wandev->name, lcn, chan->name);
 968                         err = -EINVAL;
 969                 }
 970         }else{
 971                 printk(KERN_ERR
 972                         "%s: invalid media address on interface %s!\n",
 973                         wandev->name, chan->name);
 974                 err = -EINVAL;
 975         }
 976
 977         if(strcmp(conf->usedby, "WANPIPE") == 0){
 978                 printk(KERN_INFO "%s: Running in WANPIPE mode %s\n",
 979                         wandev->name, chan->name);
 980                 chan->common.usedby = WANPIPE;
 981                 chan->protocol = htons(ETH_P_IP);
 982
 983         }else if(strcmp(conf->usedby, "API") == 0){
 984                 chan->common.usedby = API;
 985                 printk(KERN_INFO "%s: Running in API mode %s\n",
 986                         wandev->name, chan->name);
 987                 chan->protocol = htons(X25_PROT);
 988         }
 989
 990
 991         if (err){
 992                 kfree(chan);
 993                 dev->priv = NULL;
 994                 return err;
 995         }
 996
 997         chan->enable_IPX = conf->enable_IPX;
 998
 999         if (chan->enable_IPX)
1000                 chan->protocol = htons(ETH_P_IPX);
1001
1002         if (conf->network_number)
1003                 chan->network_number = conf->network_number;
1004         else
1005                 chan->network_number = 0xDEADBEEF;
1006
1007         /* prepare network device data space for registration */
1008         strcpy(dev->name,chan->name);
1009
1010         dev->init = &if_init;
1011
1012         init_x25_channel_struct(chan);
1013
1014         return 0;
1015 }
1016
1017 /*===================================================================
1018  * Name:        del_if(),  Remove a logical channel.
1019  *
1020  * Purpose:     To dynamically remove a logical channel.
1021  *
1022  * Rationale:   Each logical channel should be dynamically
1023  *              removable. This functin is called by an
1024  *              IOCTL_IFDEL ioctl call or shutdown().
1025  *
1026  * Description: Do nothing.
1027  *
1028  * Called by:   IOCTL_IFDEL : wanrouter_ioctl() from wanmain.c
1029  *              shutdown() from sdlamain.c
1030  *
1031  * Assumptions:
1032  *
1033  * Warnings:
1034  *
1035  * Return:      0 Ok. Void function.
1036  */
1037
1038 //FIXME Del IF Should be taken out now.
1039
1040 static int del_if(struct wan_device* wandev, struct net_device* dev)
1041 {
1042         return 0;
1043 }
1044
1045
1046 /*============================================================
1047  * Name:        wpx_exec
1048  *
1049  * Description: Execute adapter interface command.
1050  *              This option is currently dissabled.
1051  *===========================================================*/
1052
1053 static int wpx_exec (struct sdla* card, void* u_cmd, void* u_data)
1054 {
1055         return 0;
1056 }
1057
1058 /*============================================================
1059  * Name:        disable_comm
1060  *
1061  * Description: Disable communications during shutdown.
1062  *              Dont check return code because there is
1063  *              nothing we can do about it.
1064  *
1065  * Warning:     Dev and private areas are gone at this point.
1066  *===========================================================*/
1067
1068 static void disable_comm(sdla_t* card)
1069 {
1070         disable_comm_shutdown(card);
1071         del_timer(&card->u.x.x25_timer);
1072         return;
1073 }
1074
1075
1076 /*============================================================
1077  *      Network Device Interface
1078  *===========================================================*/
1079
1080 /*===================================================================
1081  * Name:        if_init(),   Netowrk Interface Initialization
1082  *
1083  * Purpose:     To initialize a network interface device structure.
1084  *
1085  * Rationale:   During network interface startup, the if_init
1086  *              is called by the kernel to initialize the
1087  *              netowrk device structure.  Thus a driver
1088  *              can customze a network device.
1089  *
1090  * Description: Initialize the netowrk device call back
1091  *              routines.  This is where we tell the kernel
1092  *              which function to use when it wants to send
1093  *              via our interface.
1094  *              Furthermore, we initialize the device flags,
1095  *              MTU and physical address of the board.
1096  *
1097  * Called by:   Kernel (/usr/src/linux/net/core/dev.c)
1098  *              (dev->init())
1099  *
1100  * Assumptions: None
1101  *
1102  * Warnings:    None
1103  *
1104  * Return:      0       Ok : Void function.
1105  */
1106 static int if_init(struct net_device* dev)
1107 {
1108         x25_channel_t* chan = dev->priv;
1109         sdla_t* card = chan->card;
1110         struct wan_device* wandev = &card->wandev;
1111
1112         /* Initialize device driver entry points */
1113         dev->open               = &if_open;
1114         dev->stop               = &if_close;
1115         dev->hard_header        = &if_header;
1116         dev->rebuild_header     = &if_rebuild_hdr;
1117         dev->hard_start_xmit    = &if_send;
1118         dev->get_stats          = &if_stats;
1119         dev->tx_timeout         = &if_tx_timeout;
1120         dev->watchdog_timeo     = TX_TIMEOUT;
1121
1122         /* Initialize media-specific parameters */
1123         dev->type               = ARPHRD_PPP;           /* ARP h/w type */
1124         dev->flags              |= IFF_POINTOPOINT;
1125         dev->flags              |= IFF_NOARP;
1126
1127         if (chan->common.usedby == API){
1128                 dev->mtu        = X25_CHAN_MTU+sizeof(x25api_hdr_t);
1129         }else{
1130                 dev->mtu        = card->wandev.mtu;
1131         }
1132
1133         dev->hard_header_len    = X25_HRDHDR_SZ; /* media header length */
1134         dev->addr_len           = 2;            /* hardware address length */
1135
1136         if (!chan->common.svc){
1137                 *(unsigned short*)dev->dev_addr = htons(chan->common.lcn);
1138         }
1139
1140         /* Initialize hardware parameters (just for reference) */
1141         dev->irq        = wandev->irq;
1142         dev->dma        = wandev->dma;
1143         dev->base_addr  = wandev->ioport;
1144         dev->mem_start  = (unsigned long)wandev->maddr;
1145         dev->mem_end    = wandev->maddr + wandev->msize - 1;
1146
1147         /* Set transmit buffer queue length */
1148         dev->tx_queue_len = 100;
1149         SET_MODULE_OWNER(dev);
1150
1151         /* FIXME Why are we doing this */
1152         set_chan_state(dev, WAN_DISCONNECTED);
1153         return 0;
1154 }
1155
1156
1157 /*===================================================================
1158  * Name:        if_open(),   Open/Bring up the Netowrk Interface
1159  *
1160  * Purpose:     To bring up a network interface.
1161  *
1162  * Rationale:
1163  *
1164  * Description: Open network interface.
1165  *              o prevent module from unloading by incrementing use count
1166  *              o if link is disconnected then initiate connection
1167  *
1168  * Called by:   Kernel (/usr/src/linux/net/core/dev.c)
1169  *              (dev->open())
1170  *
1171  * Assumptions: None
1172  *
1173  * Warnings:    None
1174  *
1175  * Return:      0       Ok
1176  *              <0      Failure: Interface will not come up.
1177  */
1178
1179 static int if_open(struct net_device* dev)
1180 {
1181         x25_channel_t* chan = dev->priv;
1182         sdla_t* card = chan->card;
1183         struct timeval tv;
1184         unsigned long smp_flags;
1185
1186         if (netif_running(dev))
1187                 return -EBUSY;
1188
1189         chan->tq_working = 0;
1190
1191         /* Initialize the workqueue */
1192         INIT_WORK(&chan->common.wanpipe_work, (void *)x25api_bh, dev);
1193
1194         /* Allocate and initialize BH circular buffer */
1195         /* Add 1 to MAX_BH_BUFF so we don't have test with (MAX_BH_BUFF-1) */
1196         chan->bh_head = kmalloc((sizeof(bh_data_t)*(MAX_BH_BUFF+1)),GFP_ATOMIC);
1197
1198         if (chan->bh_head == NULL){
1199                 printk(KERN_INFO "%s: ERROR, failed to allocate memory ! BH_BUFFERS !\n",
1200                                 card->devname);
1201
1202                 return -ENOBUFS;
1203         }
1204         memset(chan->bh_head,0,(sizeof(bh_data_t)*(MAX_BH_BUFF+1)));
1205         atomic_set(&chan->bh_buff_used, 0);
1206
1207         /* Increment the number of interfaces */
1208         ++card->u.x.no_dev;
1209
1210         wanpipe_open(card);
1211
1212         /* LAPB protocol only uses one interface, thus
1213          * start the protocol after it comes up. */
1214         if (card->u.x.LAPB_hdlc){
1215                 if (card->open_cnt == 1){
1216                         TX25Status* status = card->flags;
1217                         S508_S514_lock(card, &smp_flags);
1218                         x25_set_intr_mode(card, INTR_ON_TIMER);
1219                         status->imask &= ~INTR_ON_TIMER;
1220                         S508_S514_unlock(card, &smp_flags);
1221                 }
1222         }else{
1223                 /* X25 can have multiple interfaces thus, start the
1224                  * protocol once all interfaces are up */
1225
1226                 //FIXME: There is a bug here. If interface is
1227                 //brought down and up, it will try to enable comm.
1228                 if (card->open_cnt == card->u.x.num_of_ch){
1229
1230                         S508_S514_lock(card, &smp_flags);
1231                         connect(card);
1232                         S508_S514_unlock(card, &smp_flags);
1233
1234                         mod_timer(&card->u.x.x25_timer, jiffies + HZ);
1235                 }
1236         }
1237         /* Device is not up until the we are in connected state */
1238         do_gettimeofday( &tv );
1239         chan->router_start_time = tv.tv_sec;
1240
1241         netif_start_queue(dev);
1242
1243         return 0;
1244 }
1245
1246 /*===================================================================
1247  * Name:        if_close(),   Close/Bring down the Netowrk Interface
1248  *
1249  * Purpose:     To bring down a network interface.
1250  *
1251  * Rationale:
1252  *
1253  * Description: Close network interface.
1254  *              o decrement use module use count
1255  *
1256  * Called by:   Kernel (/usr/src/linux/net/core/dev.c)
1257  *              (dev->close())
1258  *              ifconfig <name> down: will trigger the kernel
1259  *              which will call this function.
1260  *
1261  * Assumptions: None
1262  *
1263  * Warnings:    None
1264  *
1265  * Return:      0       Ok
1266  *              <0      Failure: Interface will not exit properly.
1267  */
1268 static int if_close(struct net_device* dev)
1269 {
1270         x25_channel_t* chan = dev->priv;
1271         sdla_t* card = chan->card;
1272         unsigned long smp_flags;
1273
1274         netif_stop_queue(dev);
1275
1276         if ((chan->common.state == WAN_CONNECTED) ||
1277             (chan->common.state == WAN_CONNECTING)){
1278                 S508_S514_lock(card, &smp_flags);
1279                 chan_disc(dev);
1280                 S508_S514_unlock(card, &smp_flags);
1281         }
1282
1283         wanpipe_close(card);
1284
1285         S508_S514_lock(card, &smp_flags);
1286         if (chan->bh_head){
1287                 int i;
1288                 struct sk_buff *skb;
1289
1290                 for (i=0; i<(MAX_BH_BUFF+1); i++){
1291                         skb = ((bh_data_t *)&chan->bh_head[i])->skb;
1292                         if (skb != NULL){
1293                                 dev_kfree_skb_any(skb);
1294                         }
1295                 }
1296                 kfree(chan->bh_head);
1297                 chan->bh_head=NULL;
1298         }
1299         S508_S514_unlock(card, &smp_flags);
1300
1301         /* If this is the last close, disconnect physical link */
1302         if (!card->open_cnt){
1303                 S508_S514_lock(card, &smp_flags);
1304                 disconnect(card);
1305                 x25_set_intr_mode(card, 0);
1306                 S508_S514_unlock(card, &smp_flags);
1307         }
1308
1309         /* Decrement the number of interfaces */
1310         --card->u.x.no_dev;
1311         return 0;
1312 }
1313
1314 /*======================================================================
1315  *      Build media header.
1316  *      o encapsulate packet according to encapsulation type.
1317  *
1318  *      The trick here is to put packet type (Ethertype) into 'protocol'
1319  *      field of the socket buffer, so that we don't forget it.
1320  *      If encapsulation fails, set skb->protocol to 0 and discard
1321  *      packet later.
1322  *
1323  *      Return:         media header length.
1324  *======================================================================*/
1325
1326 static int if_header(struct sk_buff* skb, struct net_device* dev,
1327                      unsigned short type, void* daddr, void* saddr,
1328                      unsigned len)
1329 {
1330         x25_channel_t* chan = dev->priv;
1331         int hdr_len = dev->hard_header_len;
1332
1333         skb->protocol = htons(type);
1334         if (!chan->protocol){
1335                 hdr_len = wanrouter_encapsulate(skb, dev, type);
1336                 if (hdr_len < 0){
1337                         hdr_len = 0;
1338                         skb->protocol = htons(0);
1339                 }
1340         }
1341         return hdr_len;
1342 }
1343
1344 /*===============================================================
1345  *      Re-build media header.
1346  *
1347  *      Return:         1       physical address resolved.
1348  *                      0       physical address not resolved
1349  *==============================================================*/
1350
1351 static int if_rebuild_hdr (struct sk_buff* skb)
1352 {
1353         struct net_device *dev = skb->dev;
1354         x25_channel_t* chan = dev->priv;
1355         sdla_t* card = chan->card;
1356
1357         printk(KERN_INFO "%s: rebuild_header() called for interface %s!\n",
1358                 card->devname, dev->name);
1359         return 1;
1360 }
1361
1362
1363 /*============================================================================
1364  * Handle transmit timeout event from netif watchdog
1365  */
1366 static void if_tx_timeout(struct net_device *dev)
1367 {
1368         x25_channel_t* chan = dev->priv;
1369         sdla_t *card = chan->card;
1370
1371         /* If our device stays busy for at least 5 seconds then we will
1372          * kick start the device by making dev->tbusy = 0.  We expect
1373          * that our device never stays busy more than 5 seconds. So this
1374          * is only used as a last resort.
1375          */
1376
1377         ++chan->if_send_stat.if_send_tbusy_timeout;
1378         printk (KERN_INFO "%s: Transmit timed out on %s\n",
1379                         card->devname, dev->name);
1380         netif_wake_queue (dev);
1381 }
1382
1383
1384 /*=========================================================================
1385  *      Send a packet on a network interface.
1386  *      o set tbusy flag (marks start of the transmission).
1387  *      o check link state. If link is not up, then drop the packet.
1388  *      o check channel status. If it's down then initiate a call.
1389  *      o pass a packet to corresponding WAN device.
1390  *      o free socket buffer
1391  *
1392  *      Return: 0       complete (socket buffer must be freed)
1393  *              non-0   packet may be re-transmitted (tbusy must be set)
1394  *
1395  *      Notes:
1396  *      1. This routine is called either by the protocol stack or by the "net
1397  *      bottom half" (with interrupts enabled).
1398  *      2. Setting tbusy flag will inhibit further transmit requests from the
1399  *      protocol stack and can be used for flow control with protocol layer.
1400  *
1401  *========================================================================*/
1402
1403 static int if_send(struct sk_buff* skb, struct net_device* dev)
1404 {
1405         x25_channel_t* chan = dev->priv;
1406         sdla_t* card = chan->card;
1407         TX25Status* status = card->flags;
1408         int udp_type;
1409         unsigned long smp_flags=0;
1410
1411         ++chan->if_send_stat.if_send_entry;
1412
1413         netif_stop_queue(dev);
1414
1415         /* No need to check frame length, since socket code
1416          * will perform the check for us */
1417
1418         chan->tick_counter = jiffies;
1419
1420         /* Critical region starts here */
1421         S508_S514_lock(card, &smp_flags);
1422
1423         if (test_and_set_bit(SEND_CRIT, (void*)&card->wandev.critical)){
1424                 printk(KERN_INFO "Hit critical in if_send()! %lx\n",card->wandev.critical);
1425                 goto if_send_crit_exit;
1426         }
1427
1428         udp_type = udp_pkt_type(skb, card);
1429
1430         if(udp_type != UDP_INVALID_TYPE) {
1431
1432                 if(store_udp_mgmt_pkt(udp_type, UDP_PKT_FRM_STACK, card, dev, skb,
1433                         chan->common.lcn)) {
1434
1435                         status->imask |= INTR_ON_TIMER;
1436                         if (udp_type == UDP_XPIPE_TYPE){
1437                                 chan->if_send_stat.if_send_PIPE_request++;
1438                         }
1439                 }
1440                 netif_start_queue(dev);
1441                 clear_bit(SEND_CRIT,(void*)&card->wandev.critical);
1442                 S508_S514_unlock(card, &smp_flags);
1443                 return 0;
1444         }
1445
1446         if (chan->transmit_length){
1447                 //FIXME: This check doesn't make sense any more
1448                 if (chan->common.state != WAN_CONNECTED){
1449                         chan->transmit_length=0;
1450                         atomic_set(&chan->common.driver_busy,0);
1451                 }else{
1452                         netif_stop_queue(dev);
1453                         ++card->u.x.tx_interrupts_pending;
1454                         status->imask |= INTR_ON_TX_FRAME;
1455                         clear_bit(SEND_CRIT,(void*)&card->wandev.critical);
1456                         S508_S514_unlock(card, &smp_flags);
1457                         return 1;
1458                 }
1459         }
1460
1461         if (card->wandev.state != WAN_CONNECTED){
1462                 ++chan->ifstats.tx_dropped;
1463                 ++card->wandev.stats.tx_dropped;
1464                 ++chan->if_send_stat.if_send_wan_disconnected;
1465
1466         }else if ( chan->protocol && (chan->protocol != skb->protocol)){
1467                 printk(KERN_INFO
1468                         "%s: unsupported Ethertype 0x%04X on interface %s!\n",
1469                         chan->name, htons(skb->protocol), dev->name);
1470
1471                 printk(KERN_INFO "PROTO %Xn", htons(chan->protocol));
1472                 ++chan->ifstats.tx_errors;
1473                 ++chan->ifstats.tx_dropped;
1474                 ++card->wandev.stats.tx_dropped;
1475                 ++chan->if_send_stat.if_send_protocol_error;
1476
1477         }else switch (chan->common.state){
1478
1479                 case WAN_DISCONNECTED:
1480                         /* Try to establish connection. If succeded, then start
1481                          * transmission, else drop a packet.
1482                          */
1483                         if (chan->common.usedby == API){
1484                                 ++chan->ifstats.tx_dropped;
1485                                 ++card->wandev.stats.tx_dropped;
1486                                 break;
1487                         }else{
1488                                 if (chan_connect(dev) != 0){
1489                                         ++chan->ifstats.tx_dropped;
1490                                         ++card->wandev.stats.tx_dropped;
1491                                         break;
1492                                 }
1493                         }
1494                         /* fall through */
1495
1496                 case WAN_CONNECTED:
1497                         if( skb->protocol == htons(ETH_P_IPX)) {
1498                                 if(chan->enable_IPX) {
1499                                         switch_net_numbers( skb->data,
1500                                                 chan->network_number, 0);
1501                                 } else {
1502                                         ++card->wandev.stats.tx_dropped;
1503                                         ++chan->ifstats.tx_dropped;
1504                                         ++chan->if_send_stat.if_send_protocol_error;
1505                                         goto if_send_crit_exit;
1506                                 }
1507                         }
1508                         /* We never drop here, if cannot send than, copy
1509                          * a packet into a transmit buffer
1510                          */
1511                         chan_send(dev, skb->data, skb->len, 0);
1512                         break;
1513
1514                 default:
1515                         ++chan->ifstats.tx_dropped;
1516                         ++card->wandev.stats.tx_dropped;
1517                         break;
1518         }
1519
1520
1521 if_send_crit_exit:
1522
1523         dev_kfree_skb_any(skb);
1524
1525         netif_start_queue(dev);
1526         clear_bit(SEND_CRIT,(void*)&card->wandev.critical);
1527         S508_S514_unlock(card, &smp_flags);
1528         return 0;
1529 }
1530
1531 /*============================================================================
1532  * Setup so that a frame can be transmitted on the occurrence of a transmit
1533  * interrupt.
1534  *===========================================================================*/
1535
1536 static void setup_for_delayed_transmit(struct net_device* dev, void* buf,
1537                                        unsigned len)
1538 {
1539         x25_channel_t* chan = dev->priv;
1540         sdla_t* card = chan->card;
1541         TX25Status* status = card->flags;
1542
1543         ++chan->if_send_stat.if_send_adptr_bfrs_full;
1544
1545         if(chan->transmit_length) {
1546                 printk(KERN_INFO "%s: Error, transmit length set in delayed transmit!\n",
1547                                 card->devname);
1548                 return;
1549         }
1550
1551         if (chan->common.usedby == API){
1552                 if (len > X25_CHAN_MTU+sizeof(x25api_hdr_t)) {
1553                         ++chan->ifstats.tx_dropped;
1554                         ++card->wandev.stats.tx_dropped;
1555                         printk(KERN_INFO "%s: Length is too big for delayed transmit\n",
1556                                 card->devname);
1557                         return;
1558                 }
1559         }else{
1560                 if (len > X25_MAX_DATA) {
1561                         ++chan->ifstats.tx_dropped;
1562                         ++card->wandev.stats.tx_dropped;
1563                         printk(KERN_INFO "%s: Length is too big for delayed transmit\n",
1564                                 card->devname);
1565                         return;
1566                 }
1567         }
1568
1569         chan->transmit_length = len;
1570         atomic_set(&chan->common.driver_busy,1);
1571         memcpy(chan->transmit_buffer, buf, len);
1572
1573         ++chan->if_send_stat.if_send_tx_int_enabled;
1574
1575         /* Enable Transmit Interrupt */
1576         ++card->u.x.tx_interrupts_pending;
1577         status->imask |= INTR_ON_TX_FRAME;
1578 }
1579
1580
1581 /*===============================================================
1582  * net_device_stats
1583  *
1584  *      Get ethernet-style interface statistics.
1585  *      Return a pointer to struct enet_statistics.
1586  *
1587  *==============================================================*/
1588 static struct net_device_stats *if_stats(struct net_device* dev)
1589 {
1590         x25_channel_t *chan = dev->priv;
1591
1592         if(chan == NULL)
1593                 return NULL;
1594
1595         return &chan->ifstats;
1596 }
1597
1598
1599 /*
1600  *      Interrupt Handlers
1601  */
1602
1603 /*
1604  * X.25 Interrupt Service Routine.
1605  */
1606
1607 static void wpx_isr (sdla_t* card)
1608 {
1609         TX25Status* status = card->flags;
1610
1611         card->in_isr = 1;
1612         ++card->statistics.isr_entry;
1613
1614         if (test_bit(PERI_CRIT,(void*)&card->wandev.critical)){
1615                 card->in_isr=0;
1616                 status->iflags = 0;
1617                 return;
1618         }
1619
1620         if (test_bit(SEND_CRIT, (void*)&card->wandev.critical)){
1621
1622                 printk(KERN_INFO "%s: wpx_isr: wandev.critical set to 0x%02lx, int type = 0x%02x\n",
1623                         card->devname, card->wandev.critical, status->iflags);
1624                 card->in_isr = 0;
1625                 status->iflags = 0;
1626                 return;
1627         }
1628
1629         /* For all interrupts set the critical flag to CRITICAL_RX_INTR.
1630          * If the if_send routine is called with this flag set it will set
1631          * the enable transmit flag to 1. (for a delayed interrupt)
1632          */
1633         switch (status->iflags){
1634
1635                 case RX_INTR_PENDING:           /* receive interrupt */
1636                         rx_intr(card);
1637                         break;
1638
1639                 case TX_INTR_PENDING:           /* transmit interrupt */
1640                         tx_intr(card);
1641                         break;
1642
1643                 case MODEM_INTR_PENDING:        /* modem status interrupt */
1644                         status_intr(card);
1645                         break;
1646
1647                 case X25_ASY_TRANS_INTR_PENDING:        /* network event interrupt */
1648                         event_intr(card);
1649                         break;
1650
1651                 case TIMER_INTR_PENDING:
1652                         timer_intr(card);
1653                         break;
1654
1655                 default:                /* unwanted interrupt */
1656                         spur_intr(card);
1657         }
1658
1659         card->in_isr = 0;
1660         status->iflags = 0;     /* clear interrupt condition */
1661 }
1662
1663 /*
1664  *      Receive interrupt handler.
1665  *      This routine handles fragmented IP packets using M-bit according to the
1666  *      RFC1356.
1667  *      o map ligical channel number to network interface.
1668  *      o allocate socket buffer or append received packet to the existing one.
1669  *      o if M-bit is reset (i.e. it's the last packet in a sequence) then
1670  *      decapsulate packet and pass socket buffer to the protocol stack.
1671  *
1672  *      Notes:
1673  *      1. When allocating a socket buffer, if M-bit is set then more data is
1674  *      coming and we have to allocate buffer for the maximum IP packet size
1675  *      expected on this channel.
1676  *      2. If something goes wrong and X.25 packet has to be dropped (e.g. no
1677  *      socket buffers available) the whole packet sequence must be discarded.
1678  */
1679
1680 static void rx_intr (sdla_t* card)
1681 {
1682         TX25Mbox* rxmb = card->rxmb;
1683         unsigned lcn = rxmb->cmd.lcn;
1684         struct net_device* dev = find_channel(card,lcn);
1685         x25_channel_t* chan;
1686         struct sk_buff* skb=NULL;
1687
1688         if (dev == NULL){
1689                 /* Invalid channel, discard packet */
1690                 printk(KERN_INFO "%s: receiving on orphaned LCN %d!\n",
1691                         card->devname, lcn);
1692                 return;
1693         }
1694
1695         chan = dev->priv;
1696         chan->i_timeout_sofar = jiffies;
1697
1698
1699         /* Copy the data from the board, into an
1700          * skb buffer
1701          */
1702         if (wanpipe_pull_data_in_skb(card,dev,&skb)){
1703                 ++chan->ifstats.rx_dropped;
1704                 ++card->wandev.stats.rx_dropped;
1705                 ++chan->rx_intr_stat.rx_intr_no_socket;
1706                 ++chan->rx_intr_stat.rx_intr_bfr_not_passed_to_stack;
1707                 return;
1708         }
1709
1710         dev->last_rx = jiffies;         /* timestamp */
1711
1712
1713         /* ------------ API ----------------*/
1714
1715         if (chan->common.usedby == API){
1716
1717                 if (bh_enqueue(dev, skb)){
1718                         ++chan->ifstats.rx_dropped;
1719                         ++card->wandev.stats.rx_dropped;
1720                         ++chan->rx_intr_stat.rx_intr_bfr_not_passed_to_stack;
1721                         dev_kfree_skb_any(skb);
1722                         return;
1723                 }
1724
1725                 ++chan->ifstats.rx_packets;
1726                 chan->ifstats.rx_bytes += skb->len;
1727
1728
1729                 chan->rx_skb = NULL;
1730                 if (!test_and_set_bit(0, &chan->tq_working)){
1731                         wanpipe_queue_work(&chan->common.wanpipe_work);
1732                 }
1733                 return;
1734         }
1735
1736
1737         /* ------------- WANPIPE -------------------*/
1738
1739         /* set rx_skb to NULL so we won't access it later when kernel already owns it */
1740         chan->rx_skb=NULL;
1741
1742         /* Decapsulate packet, if necessary */
1743         if (!skb->protocol && !wanrouter_type_trans(skb, dev)){
1744                 /* can't decapsulate packet */
1745                 dev_kfree_skb_any(skb);
1746                 ++chan->ifstats.rx_errors;
1747                 ++chan->ifstats.rx_dropped;
1748                 ++card->wandev.stats.rx_dropped;
1749                 ++chan->rx_intr_stat.rx_intr_bfr_not_passed_to_stack;
1750
1751         }else{
1752                 if( handle_IPXWAN(skb->data, chan->name,
1753                                   chan->enable_IPX, chan->network_number,
1754                                   skb->protocol)){
1755
1756                         if( chan->enable_IPX ){
1757                                 if(chan_send(dev, skb->data, skb->len,0)){
1758                                         chan->tx_skb = skb;
1759                                 }else{
1760                                         dev_kfree_skb_any(skb);
1761                                         ++chan->rx_intr_stat.rx_intr_bfr_not_passed_to_stack;
1762                                 }
1763                         }else{
1764                                 /* increment IPX packet dropped statistic */
1765                                 ++chan->ifstats.rx_dropped;
1766                                 ++chan->rx_intr_stat.rx_intr_bfr_not_passed_to_stack;
1767                         }
1768                 }else{
1769                         skb->mac.raw = skb->data;
1770                         chan->ifstats.rx_bytes += skb->len;
1771                         ++chan->ifstats.rx_packets;
1772                         ++chan->rx_intr_stat.rx_intr_bfr_passed_to_stack;
1773                         netif_rx(skb);
1774                 }
1775         }
1776
1777         return;
1778 }
1779
1780
1781 static int wanpipe_pull_data_in_skb(sdla_t *card, struct net_device *dev,
1782                                     struct sk_buff **skb)
1783 {
1784         void *bufptr;
1785         TX25Mbox* rxmb = card->rxmb;
1786         unsigned len = rxmb->cmd.length;        /* packet length */
1787         unsigned qdm = rxmb->cmd.qdm;           /* Q,D and M bits */
1788         x25_channel_t *chan = dev->priv;
1789         struct sk_buff *new_skb = *skb;
1790
1791         if (chan->common.usedby == WANPIPE){
1792                 if (chan->drop_sequence){
1793                         if (!(qdm & 0x01)){
1794                                 chan->drop_sequence = 0;
1795                         }
1796                         return 1;
1797                 }
1798                 new_skb = chan->rx_skb;
1799         }else{
1800                 /* Add on the API header to the received
1801                  * data
1802                  */
1803                 len += sizeof(x25api_hdr_t);
1804         }
1805
1806         if (new_skb == NULL){
1807                 int bufsize;
1808
1809                 if (chan->common.usedby == WANPIPE){
1810                         bufsize = (qdm & 0x01) ? dev->mtu : len;
1811                 }else{
1812                         bufsize = len;
1813                 }
1814
1815                 /* Allocate new socket buffer */
1816                 new_skb = dev_alloc_skb(bufsize + dev->hard_header_len);
1817                 if (new_skb == NULL){
1818                         printk(KERN_INFO "%s: no socket buffers available!\n",
1819                                 card->devname);
1820                         chan->drop_sequence = 1;        /* set flag */
1821                         ++chan->ifstats.rx_dropped;
1822                         return 1;
1823                 }
1824         }
1825
1826         if (skb_tailroom(new_skb) < len){
1827                 /* No room for the packet. Call off the whole thing! */
1828                 dev_kfree_skb_any(new_skb);
1829                 if (chan->common.usedby == WANPIPE){
1830                         chan->rx_skb = NULL;
1831                         if (qdm & 0x01){
1832                                 chan->drop_sequence = 1;
1833                         }
1834                 }
1835
1836                 printk(KERN_INFO "%s: unexpectedly long packet sequence "
1837                         "on interface %s!\n", card->devname, dev->name);
1838                 ++chan->ifstats.rx_length_errors;
1839                 return 1;
1840         }
1841
1842         bufptr = skb_put(new_skb,len);
1843
1844
1845         if (chan->common.usedby == API){
1846                 /* Fill in the x25api header
1847                  */
1848                 x25api_t * api_data = (x25api_t*)bufptr;
1849                 api_data->hdr.qdm = rxmb->cmd.qdm;
1850                 api_data->hdr.cause = rxmb->cmd.cause;
1851                 api_data->hdr.diagn = rxmb->cmd.diagn;
1852                 api_data->hdr.length = rxmb->cmd.length;
1853                 memcpy(api_data->data, rxmb->data, rxmb->cmd.length);
1854         }else{
1855                 memcpy(bufptr, rxmb->data, len);
1856         }
1857
1858         new_skb->dev = dev;
1859
1860         if (chan->common.usedby == API){
1861                 new_skb->mac.raw = new_skb->data;
1862                 new_skb->protocol = htons(X25_PROT);
1863                 new_skb->pkt_type = WAN_PACKET_DATA;
1864         }else{
1865                 new_skb->protocol = chan->protocol;
1866                 chan->rx_skb = new_skb;
1867         }
1868
1869         /* If qdm bit is set, more data is coming
1870          * thus, exit and wait for more data before
1871          * sending the packet up. (Used by router only)
1872          */
1873         if ((qdm & 0x01) && (chan->common.usedby == WANPIPE))
1874                 return 1;
1875
1876         *skb = new_skb;
1877
1878         return 0;
1879 }
1880
1881 /*===============================================================
1882  * tx_intr
1883  *
1884  *      Transmit interrupt handler.
1885  *      For each dev, check that there is something to send.
1886  *      If data available, transmit.
1887  *
1888  *===============================================================*/
1889
1890 static void tx_intr (sdla_t* card)
1891 {
1892         struct net_device *dev;
1893         TX25Status* status = card->flags;
1894         unsigned char more_to_tx=0;
1895         x25_channel_t *chan=NULL;
1896         int i=0;
1897
1898         if (card->u.x.tx_dev == NULL){
1899                 card->u.x.tx_dev = card->wandev.dev;
1900         }
1901
1902         dev = card->u.x.tx_dev;
1903
1904         for (;;){
1905
1906                 chan = dev->priv;
1907                 if (chan->transmit_length){
1908                         /* Device was set to transmit, check if the TX
1909                          * buffers are available
1910                          */
1911                         if (chan->common.state != WAN_CONNECTED){
1912                                 chan->transmit_length = 0;
1913                                 atomic_set(&chan->common.driver_busy,0);
1914                                 chan->tx_offset=0;
1915                                 if (netif_queue_stopped(dev)){
1916                                         if (chan->common.usedby == API){
1917                                                 netif_start_queue(dev);
1918                                                 wakeup_sk_bh(dev);
1919                                         }else{
1920                                                 netif_wake_queue(dev);
1921                                         }
1922                                 }
1923                                 dev = move_dev_to_next(card,dev);
1924                                 break;
1925                         }
1926
1927                         if ((status->cflags[chan->ch_idx] & 0x40 || card->u.x.LAPB_hdlc) &&
1928                              (*card->u.x.hdlc_buf_status & 0x40) ){
1929                                 /* Tx buffer available, we can send */
1930
1931                                 if (tx_intr_send(card, dev)){
1932                                         more_to_tx=1;
1933                                 }
1934
1935                                 /* If more than one interface present, move the
1936                                  * device pointer to the next interface, so on the
1937                                  * next TX interrupt we will try sending from it.
1938                                  */
1939                                 dev = move_dev_to_next(card,dev);
1940                                 break;
1941                         }else{
1942                                 /* Tx buffers not available, but device set
1943                                  * the TX interrupt.  Set more_to_tx and try
1944                                  * to transmit for other devices.
1945                                  */
1946                                 more_to_tx=1;
1947                                 dev = move_dev_to_next(card,dev);
1948                         }
1949
1950                 }else{
1951                         /* This device was not set to transmit,
1952                          * go to next
1953                          */
1954                         dev = move_dev_to_next(card,dev);
1955                 }
1956
1957                 if (++i == card->u.x.no_dev){
1958                         if (!more_to_tx){
1959                                 DBG_PRINTK(KERN_INFO "%s: Nothing to Send in TX INTR\n",
1960                                         card->devname);
1961                         }
1962                         break;
1963                 }
1964
1965         } //End of FOR
1966
1967         card->u.x.tx_dev = dev;
1968
1969         if (!more_to_tx){
1970                 /* if any other interfaces have transmit interrupts pending, */
1971                 /* do not disable the global transmit interrupt */
1972                 if (!(--card->u.x.tx_interrupts_pending)){
1973                         status->imask &= ~INTR_ON_TX_FRAME;
1974                 }
1975         }
1976         return;
1977 }
1978
1979 /*===============================================================
1980  * move_dev_to_next
1981  *
1982  *
1983  *===============================================================*/
1984
1985
1986 struct net_device *move_dev_to_next(sdla_t *card, struct net_device *dev)
1987 {
1988         if (card->u.x.no_dev != 1){
1989                 if (!*((struct net_device **)dev->priv))
1990                         return card->wandev.dev;
1991                 else
1992                         return *((struct net_device **)dev->priv);
1993         }
1994         return dev;
1995 }
1996
1997 /*===============================================================
1998  *  tx_intr_send
1999  *
2000  *
2001  *===============================================================*/
2002
2003 static int tx_intr_send(sdla_t *card, struct net_device *dev)
2004 {
2005         x25_channel_t* chan = dev->priv;
2006
2007         if (chan_send (dev,chan->transmit_buffer,chan->transmit_length,1)){
2008
2009                 /* Packet was split up due to its size, do not disable
2010                  * tx_intr
2011                  */
2012                 return 1;
2013         }
2014
2015         chan->transmit_length=0;
2016         atomic_set(&chan->common.driver_busy,0);
2017         chan->tx_offset=0;
2018
2019         /* If we are in API mode, wakeup the
2020          * sock BH handler, not the NET_BH */
2021         if (netif_queue_stopped(dev)){
2022                 if (chan->common.usedby == API){
2023                         netif_start_queue(dev);
2024                         wakeup_sk_bh(dev);
2025                 }else{
2026                         netif_wake_queue(dev);
2027                 }
2028         }
2029         return 0;
2030 }
2031
2032
2033 /*===============================================================
2034  * timer_intr
2035  *
2036  *      Timer interrupt handler.
2037  *      Check who called the timer interrupt and perform
2038  *      action accordingly.
2039  *
2040  *===============================================================*/
2041
2042 static void timer_intr (sdla_t *card)
2043 {
2044         TX25Status* status = card->flags;
2045
2046         if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_CMD_EXEC){
2047
2048                 if (timer_intr_cmd_exec(card) == 0){
2049                         card->u.x.timer_int_enabled &=
2050                                 ~TMR_INT_ENABLED_CMD_EXEC;
2051                 }
2052
2053         }else  if(card->u.x.timer_int_enabled & TMR_INT_ENABLED_UDP_PKT) {
2054
2055                 if ((*card->u.x.hdlc_buf_status & 0x40) &&
2056                     card->u.x.udp_type == UDP_XPIPE_TYPE){
2057
2058                         if(process_udp_mgmt_pkt(card)) {
2059                                 card->u.x.timer_int_enabled &=
2060                                         ~TMR_INT_ENABLED_UDP_PKT;
2061                         }
2062                 }
2063
2064         }else if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_POLL_ACTIVE) {
2065
2066                 struct net_device *dev = card->u.x.poll_device;
2067                 x25_channel_t *chan = NULL;
2068
2069                 if (!dev){
2070                         card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_POLL_ACTIVE;
2071                         return;
2072                 }
2073                 chan = dev->priv;
2074
2075                 printk(KERN_INFO
2076                         "%s: Closing down Idle link %s on LCN %d\n",
2077                                         card->devname,chan->name,chan->common.lcn);
2078                 chan->i_timeout_sofar = jiffies;
2079                 chan_disc(dev);
2080                 card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_POLL_ACTIVE;
2081                 card->u.x.poll_device=NULL;
2082
2083         }else if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_POLL_CONNECT_ON) {
2084
2085                 wanpipe_set_state(card, WAN_CONNECTED);
2086                 if (card->u.x.LAPB_hdlc){
2087                         struct net_device *dev = card->wandev.dev;
2088                         set_chan_state(dev,WAN_CONNECTED);
2089                         send_delayed_cmd_result(card,dev,card->mbox);
2090                 }
2091
2092                 /* 0x8F enable all interrupts */
2093                 x25_set_intr_mode(card, INTR_ON_RX_FRAME|
2094                                         INTR_ON_TX_FRAME|
2095                                         INTR_ON_MODEM_STATUS_CHANGE|
2096                                         //INTR_ON_COMMAND_COMPLETE|
2097                                         X25_ASY_TRANS_INTR_PENDING |
2098                                         INTR_ON_TIMER |
2099                                         DIRECT_RX_INTR_USAGE
2100                                 );
2101
2102                 status->imask &= ~INTR_ON_TX_FRAME;     /* mask Tx interrupts */
2103                 card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_POLL_CONNECT_ON;
2104
2105         }else if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_POLL_CONNECT_OFF) {
2106
2107                 //printk(KERN_INFO "Poll connect, Turning OFF\n");
2108                 disconnect(card);
2109                 card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_POLL_CONNECT_OFF;
2110
2111         }else if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_POLL_DISCONNECT) {
2112
2113                 //printk(KERN_INFO "POll disconnect, trying to connect\n");
2114                 connect(card);
2115                 card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_POLL_DISCONNECT;
2116
2117         }else if (card->u.x.timer_int_enabled & TMR_INT_ENABLED_UPDATE){
2118
2119                 if (*card->u.x.hdlc_buf_status & 0x40){
2120                         x25_get_err_stats(card);
2121                         x25_get_stats(card);
2122                         card->u.x.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE;
2123                 }
2124         }
2125
2126         if(!card->u.x.timer_int_enabled){
2127                 //printk(KERN_INFO "Turning Timer Off \n");
2128                 status->imask &= ~INTR_ON_TIMER;
2129         }
2130 }
2131
2132 /*====================================================================
2133  *      Modem status interrupt handler.
2134  *===================================================================*/
2135 static void status_intr (sdla_t* card)
2136 {
2137
2138         /* Added to avoid Modem status message flooding */
2139         static TX25ModemStatus last_stat;
2140
2141         TX25Mbox* mbox = card->mbox;
2142         TX25ModemStatus *modem_status;
2143         struct net_device *dev;
2144         x25_channel_t *chan;
2145         int err;
2146
2147         memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2148         mbox->cmd.command = X25_READ_MODEM_STATUS;
2149         err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2150         if (err){
2151                 x25_error(card, err, X25_READ_MODEM_STATUS, 0);
2152         }else{
2153
2154                 modem_status = (TX25ModemStatus*)mbox->data;
2155
2156                 /* Check if the last status was the same
2157                  * if it was, do NOT print message again */
2158
2159                 if (last_stat.status != modem_status->status){
2160
2161                         printk(KERN_INFO "%s: Modem Status Change: DCD=%s, CTS=%s\n",
2162                                 card->devname,DCD(modem_status->status),CTS(modem_status->status));
2163
2164                         last_stat.status = modem_status->status;
2165
2166                         if (card->u.x.oob_on_modem){
2167
2168                                 mbox->cmd.pktType = mbox->cmd.command;
2169                                 mbox->cmd.result = 0x08;
2170
2171                                 /* Send a OOB to all connected sockets */
2172                                 for (dev = card->wandev.dev; dev;
2173                                      dev = *((struct net_device**)dev->priv)) {
2174                                         chan=dev->priv;
2175                                         if (chan->common.usedby == API){
2176                                                 send_oob_msg(card,dev,mbox);
2177                                         }
2178                                 }
2179
2180                                 /* The modem OOB message will probably kill the
2181                                  * the link. If we don't clear the flag here,
2182                                  * a deadlock could occur */
2183                                 if (atomic_read(&card->u.x.command_busy)){
2184                                         atomic_set(&card->u.x.command_busy,0);
2185                                 }
2186                         }
2187                 }
2188         }
2189
2190         memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2191         mbox->cmd.command = X25_HDLC_LINK_STATUS;
2192         err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2193         if (err){
2194                 x25_error(card, err, X25_HDLC_LINK_STATUS, 0);
2195         }
2196
2197 }
2198
2199 /*====================================================================
2200  *      Network event interrupt handler.
2201  *===================================================================*/
2202 static void event_intr (sdla_t* card)
2203 {
2204         x25_fetch_events(card);
2205 }
2206
2207 /*====================================================================
2208  *      Spurious interrupt handler.
2209  *      o print a warning
2210  *      o
2211  *====================================================================*/
2212
2213 static void spur_intr (sdla_t* card)
2214 {
2215         printk(KERN_INFO "%s: spurious interrupt!\n", card->devname);
2216 }
2217
2218
2219 /*
2220  *      Background Polling Routines
2221  */
2222
2223 /*====================================================================
2224  *      Main polling routine.
2225  *      This routine is repeatedly called by the WANPIPE 'thread' to allow for
2226  *      time-dependent housekeeping work.
2227  *
2228  *      Notes:
2229  *      1. This routine may be called on interrupt context with all interrupts
2230  *      enabled. Beware!
2231  *====================================================================*/
2232
2233 static void wpx_poll (sdla_t *card)
2234 {
2235         if (!card->wandev.dev){
2236                 goto wpx_poll_exit;
2237         }
2238
2239         if (card->open_cnt != card->u.x.num_of_ch){
2240                 goto wpx_poll_exit;
2241         }
2242
2243         if (test_bit(PERI_CRIT,&card->wandev.critical)){
2244                 goto wpx_poll_exit;
2245         }
2246
2247         if (test_bit(SEND_CRIT,&card->wandev.critical)){
2248                 goto wpx_poll_exit;
2249         }
2250
2251         switch(card->wandev.state){
2252                 case WAN_CONNECTED:
2253                         poll_active(card);
2254                         break;
2255
2256                 case WAN_CONNECTING:
2257                         poll_connecting(card);
2258                         break;
2259
2260                 case WAN_DISCONNECTED:
2261                         poll_disconnected(card);
2262                         break;
2263         }
2264
2265 wpx_poll_exit:
2266         clear_bit(POLL_CRIT,&card->wandev.critical);
2267         return;
2268 }
2269
2270 static void trigger_x25_poll(sdla_t *card)
2271 {
2272         schedule_work(&card->u.x.x25_poll_work);
2273 }
2274
2275 /*====================================================================
2276  *      Handle physical link establishment phase.
2277  *      o if connection timed out, disconnect the link.
2278  *===================================================================*/
2279
2280 static void poll_connecting (sdla_t* card)
2281 {
2282         volatile TX25Status* status = card->flags;
2283
2284         if (status->gflags & X25_HDLC_ABM){
2285
2286                 timer_intr_exec (card, TMR_INT_ENABLED_POLL_CONNECT_ON);
2287
2288         }else if ((jiffies - card->state_tick) > CONNECT_TIMEOUT){
2289
2290                 timer_intr_exec (card, TMR_INT_ENABLED_POLL_CONNECT_OFF);
2291
2292         }
2293 }
2294
2295 /*====================================================================
2296  *      Handle physical link disconnected phase.
2297  *      o if hold-down timeout has expired and there are open interfaces,
2298  *      connect link.
2299  *===================================================================*/
2300
2301 static void poll_disconnected (sdla_t* card)
2302 {
2303         struct net_device *dev;
2304         x25_channel_t *chan;
2305         TX25Status* status = card->flags;
2306
2307         if (!card->u.x.LAPB_hdlc && card->open_cnt &&
2308             ((jiffies - card->state_tick) > HOLD_DOWN_TIME)){
2309                 timer_intr_exec(card, TMR_INT_ENABLED_POLL_DISCONNECT);
2310         }
2311
2312
2313         if ((dev=card->wandev.dev) == NULL)
2314                 return;
2315
2316         if ((chan=dev->priv) == NULL)
2317                 return;
2318
2319         if (chan->common.usedby == API &&
2320             atomic_read(&chan->common.command) &&
2321             card->u.x.LAPB_hdlc){
2322
2323                 if (!(card->u.x.timer_int_enabled & TMR_INT_ENABLED_CMD_EXEC))
2324                         card->u.x.timer_int_enabled |= TMR_INT_ENABLED_CMD_EXEC;
2325
2326                 if (!(status->imask & INTR_ON_TIMER))
2327                         status->imask |= INTR_ON_TIMER;
2328         }
2329
2330 }
2331
2332 /*====================================================================
2333  *      Handle active link phase.
2334  *      o fetch X.25 asynchronous events.
2335  *      o kick off transmission on all interfaces.
2336  *===================================================================*/
2337
2338 static void poll_active (sdla_t* card)
2339 {
2340         struct net_device* dev;
2341         TX25Status* status = card->flags;
2342
2343         for (dev = card->wandev.dev; dev;
2344              dev = *((struct net_device **)dev->priv)){
2345                 x25_channel_t* chan = dev->priv;
2346
2347                 /* If SVC has been idle long enough, close virtual circuit */
2348                 if ( chan->common.svc &&
2349                      chan->common.state == WAN_CONNECTED &&
2350                      chan->common.usedby == WANPIPE ){
2351
2352                         if( (jiffies - chan->i_timeout_sofar) / HZ > chan->idle_timeout ){
2353                                 /* Close svc */
2354                                 card->u.x.poll_device=dev;
2355                                 timer_intr_exec (card, TMR_INT_ENABLED_POLL_ACTIVE);
2356                         }
2357                 }
2358
2359 #ifdef PRINT_DEBUG
2360                 chan->ifstats.tx_compressed = atomic_read(&chan->common.command);
2361                 chan->ifstats.tx_errors = chan->common.state;
2362                 chan->ifstats.rx_fifo_errors = atomic_read(&card->u.x.command_busy);
2363                 ++chan->ifstats.tx_bytes;
2364
2365                 chan->ifstats.rx_fifo_errors=atomic_read(&chan->common.disconnect);
2366                 chan->ifstats.multicast=atomic_read(&chan->bh_buff_used);
2367                 chan->ifstats.rx_length_errors=*card->u.x.hdlc_buf_status;
2368 #endif
2369
2370                 if (chan->common.usedby == API &&
2371                     atomic_read(&chan->common.command) &&
2372                     !card->u.x.LAPB_hdlc){
2373
2374                         if (!(card->u.x.timer_int_enabled & TMR_INT_ENABLED_CMD_EXEC))
2375                                 card->u.x.timer_int_enabled |= TMR_INT_ENABLED_CMD_EXEC;
2376
2377                         if (!(status->imask & INTR_ON_TIMER))
2378                                 status->imask |= INTR_ON_TIMER;
2379                 }
2380
2381                 if ((chan->common.usedby == API) &&
2382                      atomic_read(&chan->common.disconnect)){
2383
2384                         if (chan->common.state == WAN_DISCONNECTED){
2385                                 atomic_set(&chan->common.disconnect,0);
2386                                 return;
2387                         }
2388
2389                         atomic_set(&chan->common.command,X25_CLEAR_CALL);
2390                         if (!(card->u.x.timer_int_enabled & TMR_INT_ENABLED_CMD_EXEC))
2391                                 card->u.x.timer_int_enabled |= TMR_INT_ENABLED_CMD_EXEC;
2392
2393                         if (!(status->imask & INTR_ON_TIMER))
2394                                 status->imask |= INTR_ON_TIMER;
2395                 }
2396         }
2397 }
2398
2399 static void timer_intr_exec(sdla_t *card, unsigned char TYPE)
2400 {
2401         TX25Status* status = card->flags;
2402         card->u.x.timer_int_enabled |= TYPE;
2403         if (!(status->imask & INTR_ON_TIMER))
2404                 status->imask |= INTR_ON_TIMER;
2405 }
2406
2407
2408 /*====================================================================
2409  * SDLA Firmware-Specific Functions
2410  *
2411  *  Almost all X.25 commands can unexpetedly fail due to so called 'X.25
2412  *  asynchronous events' such as restart, interrupt, incoming call request,
2413  *  call clear request, etc.  They can't be ignored and have to be delt with
2414  *  immediately.  To tackle with this problem we execute each interface
2415  *  command in a loop until good return code is received or maximum number
2416  *  of retries is reached.  Each interface command returns non-zero return
2417  *  code, an asynchronous event/error handler x25_error() is called.
2418  *====================================================================*/
2419
2420 /*====================================================================
2421  *      Read X.25 firmware version.
2422  *              Put code version as ASCII string in str.
2423  *===================================================================*/
2424
2425 static int x25_get_version (sdla_t* card, char* str)
2426 {
2427         TX25Mbox* mbox = card->mbox;
2428         int retry = MAX_CMD_RETRY;
2429         int err;
2430
2431         do
2432         {
2433                 memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2434                 mbox->cmd.command = X25_READ_CODE_VERSION;
2435                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2436         } while (err && retry-- &&
2437                  x25_error(card, err, X25_READ_CODE_VERSION, 0));
2438
2439         if (!err && str)
2440         {
2441                 int len = mbox->cmd.length;
2442
2443                 memcpy(str, mbox->data, len);
2444                 str[len] = '\0';
2445         }
2446         return err;
2447 }
2448
2449 /*====================================================================
2450  *      Configure adapter.
2451  *===================================================================*/
2452
2453 static int x25_configure (sdla_t* card, TX25Config* conf)
2454 {
2455         TX25Mbox* mbox = card->mbox;
2456         int retry = MAX_CMD_RETRY;
2457         int err;
2458
2459         do{
2460                 memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2461                 memcpy(mbox->data, (void*)conf, sizeof(TX25Config));
2462                 mbox->cmd.length  = sizeof(TX25Config);
2463                 mbox->cmd.command = X25_SET_CONFIGURATION;
2464                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2465         } while (err && retry-- && x25_error(card, err, X25_SET_CONFIGURATION, 0));
2466         return err;
2467 }
2468
2469 /*====================================================================
2470  *      Configure adapter for HDLC only.
2471  *===================================================================*/
2472
2473 static int hdlc_configure (sdla_t* card, TX25Config* conf)
2474 {
2475         TX25Mbox* mbox = card->mbox;
2476         int retry = MAX_CMD_RETRY;
2477         int err;
2478
2479         do{
2480                 memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2481                 memcpy(mbox->data, (void*)conf, sizeof(TX25Config));
2482                 mbox->cmd.length  = sizeof(TX25Config);
2483                 mbox->cmd.command = X25_HDLC_SET_CONFIG;
2484                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2485         } while (err && retry-- && x25_error(card, err, X25_SET_CONFIGURATION, 0));
2486
2487         return err;
2488 }
2489
2490 static int set_hdlc_level (sdla_t* card)
2491 {
2492
2493         TX25Mbox* mbox = card->mbox;
2494         int retry = MAX_CMD_RETRY;
2495         int err;
2496
2497         do{
2498                 memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2499                 mbox->cmd.command = SET_PROTOCOL_LEVEL;
2500                 mbox->cmd.length = 1;
2501                 mbox->data[0] = HDLC_LEVEL; //| DO_HDLC_LEVEL_ERROR_CHECKING;
2502                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2503         } while (err && retry-- && x25_error(card, err, SET_PROTOCOL_LEVEL, 0));
2504
2505         return err;
2506 }
2507
2508
2509
2510 /*====================================================================
2511  * Get communications error statistics.
2512  *====================================================================*/
2513
2514 static int x25_get_err_stats (sdla_t* card)
2515 {
2516         TX25Mbox* mbox = card->mbox;
2517         int retry = MAX_CMD_RETRY;
2518         int err;
2519
2520         do
2521         {
2522                 memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2523                 mbox->cmd.command = X25_HDLC_READ_COMM_ERR;
2524                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2525         } while (err && retry-- && x25_error(card, err, X25_HDLC_READ_COMM_ERR, 0));
2526
2527         if (!err)
2528         {
2529                 THdlcCommErr* stats = (void*)mbox->data;
2530
2531                 card->wandev.stats.rx_over_errors    = stats->rxOverrun;
2532                 card->wandev.stats.rx_crc_errors     = stats->rxBadCrc;
2533                 card->wandev.stats.rx_missed_errors  = stats->rxAborted;
2534                 card->wandev.stats.tx_aborted_errors = stats->txAborted;
2535         }
2536         return err;
2537 }
2538
2539 /*====================================================================
2540  *      Get protocol statistics.
2541  *===================================================================*/
2542
2543 static int x25_get_stats (sdla_t* card)
2544 {
2545         TX25Mbox* mbox = card->mbox;
2546         int retry = MAX_CMD_RETRY;
2547         int err;
2548
2549         do
2550         {
2551                 memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2552                 mbox->cmd.command = X25_READ_STATISTICS;
2553                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2554         } while (err && retry-- && x25_error(card, err, X25_READ_STATISTICS, 0)) ;
2555
2556         if (!err)
2557         {
2558                 TX25Stats* stats = (void*)mbox->data;
2559
2560                 card->wandev.stats.rx_packets = stats->rxData;
2561                 card->wandev.stats.tx_packets = stats->txData;
2562         }
2563         return err;
2564 }
2565
2566 /*====================================================================
2567  *      Close HDLC link.
2568  *===================================================================*/
2569
2570 static int x25_close_hdlc (sdla_t* card)
2571 {
2572         TX25Mbox* mbox = card->mbox;
2573         int retry = MAX_CMD_RETRY;
2574         int err;
2575
2576         do
2577         {
2578                 memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2579                 mbox->cmd.command = X25_HDLC_LINK_CLOSE;
2580                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2581         } while (err && retry-- && x25_error(card, err, X25_HDLC_LINK_CLOSE, 0));
2582
2583         return err;
2584 }
2585
2586
2587 /*====================================================================
2588  *      Open HDLC link.
2589  *===================================================================*/
2590
2591 static int x25_open_hdlc (sdla_t* card)
2592 {
2593         TX25Mbox* mbox = card->mbox;
2594         int retry = MAX_CMD_RETRY;
2595         int err;
2596
2597         do
2598         {
2599                 memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2600                 mbox->cmd.command = X25_HDLC_LINK_OPEN;
2601                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2602         } while (err && retry-- && x25_error(card, err, X25_HDLC_LINK_OPEN, 0));
2603
2604         return err;
2605 }
2606
2607 /*=====================================================================
2608  * Setup HDLC link.
2609  *====================================================================*/
2610 static int x25_setup_hdlc (sdla_t* card)
2611 {
2612         TX25Mbox* mbox = card->mbox;
2613         int retry = MAX_CMD_RETRY;
2614         int err;
2615
2616         do
2617         {
2618                 memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2619                 mbox->cmd.command = X25_HDLC_LINK_SETUP;
2620                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2621         } while (err && retry-- && x25_error(card, err, X25_HDLC_LINK_SETUP, 0));
2622
2623         return err;
2624 }
2625
2626 /*====================================================================
2627  * Set (raise/drop) DTR.
2628  *===================================================================*/
2629
2630 static int x25_set_dtr (sdla_t* card, int dtr)
2631 {
2632         TX25Mbox* mbox = card->mbox;
2633         int retry = MAX_CMD_RETRY;
2634         int err;
2635
2636         do
2637         {
2638                 memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2639                 mbox->data[0] = 0;
2640                 mbox->data[2] = 0;
2641                 mbox->data[1] = dtr ? 0x02 : 0x01;
2642                 mbox->cmd.length  = 3;
2643                 mbox->cmd.command = X25_SET_GLOBAL_VARS;
2644                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2645         } while (err && retry-- && x25_error(card, err, X25_SET_GLOBAL_VARS, 0));
2646
2647         return err;
2648 }
2649
2650 /*====================================================================
2651  *      Set interrupt mode.
2652  *===================================================================*/
2653
2654 static int x25_set_intr_mode (sdla_t* card, int mode)
2655 {
2656         TX25Mbox* mbox = card->mbox;
2657         int retry = MAX_CMD_RETRY;
2658         int err;
2659
2660         do
2661         {
2662                 memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2663                 mbox->data[0] = mode;
2664                 if (card->hw.fwid == SFID_X25_508){
2665                         mbox->data[1] = card->hw.irq;
2666                         mbox->data[2] = 2;
2667                         mbox->cmd.length = 3;
2668                 }else {
2669                         mbox->cmd.length  = 1;
2670                 }
2671                 mbox->cmd.command = X25_SET_INTERRUPT_MODE;
2672                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2673         } while (err && retry-- && x25_error(card, err, X25_SET_INTERRUPT_MODE, 0));
2674
2675         return err;
2676 }
2677
2678 /*====================================================================
2679  *      Read X.25 channel configuration.
2680  *===================================================================*/
2681
2682 static int x25_get_chan_conf (sdla_t* card, x25_channel_t* chan)
2683 {
2684         TX25Mbox* mbox = card->mbox;
2685         int retry = MAX_CMD_RETRY;
2686         int lcn = chan->common.lcn;
2687         int err;
2688
2689         do{
2690                 memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2691                 mbox->cmd.lcn     = lcn;
2692                 mbox->cmd.command = X25_READ_CHANNEL_CONFIG;
2693                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2694         } while (err && retry-- && x25_error(card, err, X25_READ_CHANNEL_CONFIG, lcn));
2695
2696         if (!err)
2697         {
2698                 TX25Status* status = card->flags;
2699
2700                 /* calculate an offset into the array of status bytes */
2701                 if (card->u.x.hi_svc <= X25_MAX_CHAN){
2702
2703                         chan->ch_idx = lcn - 1;
2704
2705                 }else{
2706                         int offset;
2707
2708                         /* FIX: Apr 14 2000 : Nenad Corbic
2709                          * The data field was being compared to 0x1F using
2710                          * '&&' instead of '&'.
2711                          * This caused X25API to fail for LCNs greater than 255.
2712                          */
2713                         switch (mbox->data[0] & 0x1F)
2714                         {
2715                                 case 0x01:
2716                                         offset = status->pvc_map; break;
2717                                 case 0x03:
2718                                         offset = status->icc_map; break;
2719                                 case 0x07:
2720                                         offset = status->twc_map; break;
2721                                 case 0x0B:
2722                                         offset = status->ogc_map; break;
2723                                 default:
2724                                         offset = 0;
2725                         }
2726                         chan->ch_idx = lcn - 1 - offset;
2727                 }
2728
2729                 /* get actual transmit packet size on this channel */
2730                 switch(mbox->data[1] & 0x38)
2731                 {
2732                         case 0x00:
2733                                 chan->tx_pkt_size = 16;
2734                                 break;
2735                         case 0x08:
2736                                 chan->tx_pkt_size = 32;
2737                                 break;
2738                         case 0x10:
2739                                 chan->tx_pkt_size = 64;
2740                                 break;
2741                         case 0x18:
2742                                 chan->tx_pkt_size = 128;
2743                                 break;
2744                         case 0x20:
2745                                 chan->tx_pkt_size = 256;
2746                                 break;
2747                         case 0x28:
2748                                 chan->tx_pkt_size = 512;
2749                                 break;
2750                         case 0x30:
2751                                 chan->tx_pkt_size = 1024;
2752                                 break;
2753                 }
2754                 if (card->u.x.logging)
2755                         printk(KERN_INFO "%s: X.25 packet size on LCN %d is %d.\n",
2756                                 card->devname, lcn, chan->tx_pkt_size);
2757         }
2758         return err;
2759 }
2760
2761 /*====================================================================
2762  *      Place X.25 call.
2763  *====================================================================*/
2764
2765 static int x25_place_call (sdla_t* card, x25_channel_t* chan)
2766 {
2767         TX25Mbox* mbox = card->mbox;
2768         int retry = MAX_CMD_RETRY;
2769         int err;
2770         char str[64];
2771
2772
2773         if (chan->protocol == htons(ETH_P_IP)){
2774                 sprintf(str, "-d%s -uCC", chan->addr);
2775
2776         }else if (chan->protocol == htons(ETH_P_IPX)){
2777                 sprintf(str, "-d%s -u800000008137", chan->addr);
2778
2779         }
2780
2781         do
2782         {
2783                 memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2784                 strcpy(mbox->data, str);
2785                 mbox->cmd.length  = strlen(str);
2786                 mbox->cmd.command = X25_PLACE_CALL;
2787                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2788         } while (err && retry-- && x25_error(card, err, X25_PLACE_CALL, 0));
2789
2790         if (!err){
2791                 bind_lcn_to_dev (card, chan->dev, mbox->cmd.lcn);
2792         }
2793         return err;
2794 }
2795
2796 /*====================================================================
2797  *      Accept X.25 call.
2798  *====================================================================*/
2799
2800 static int x25_accept_call (sdla_t* card, int lcn, int qdm)
2801 {
2802         TX25Mbox* mbox = card->mbox;
2803         int retry = MAX_CMD_RETRY;
2804         int err;
2805
2806         do
2807         {
2808                 memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2809                 mbox->cmd.lcn     = lcn;
2810                 mbox->cmd.qdm     = qdm;
2811                 mbox->cmd.command = X25_ACCEPT_CALL;
2812                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2813         } while (err && retry-- && x25_error(card, err, X25_ACCEPT_CALL, lcn));
2814
2815         return err;
2816 }
2817
2818 /*====================================================================
2819  *      Clear X.25 call.
2820  *====================================================================*/
2821
2822 static int x25_clear_call (sdla_t* card, int lcn, int cause, int diagn)
2823 {
2824         TX25Mbox* mbox = card->mbox;
2825         int retry = MAX_CMD_RETRY;
2826         int err;
2827
2828         do
2829         {
2830                 memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2831                 mbox->cmd.lcn     = lcn;
2832                 mbox->cmd.cause   = cause;
2833                 mbox->cmd.diagn   = diagn;
2834                 mbox->cmd.command = X25_CLEAR_CALL;
2835                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2836         } while (err && retry-- && x25_error(card, err, X25_CLEAR_CALL, lcn));
2837
2838         return err;
2839 }
2840
2841 /*====================================================================
2842  *      Send X.25 data packet.
2843  *====================================================================*/
2844
2845 static int x25_send (sdla_t* card, int lcn, int qdm, int len, void* buf)
2846 {
2847         TX25Mbox* mbox = card->mbox;
2848         int retry = MAX_CMD_RETRY;
2849         int err;
2850         unsigned char cmd;
2851
2852         if (card->u.x.LAPB_hdlc)
2853                 cmd = X25_HDLC_WRITE;
2854         else
2855                 cmd = X25_WRITE;
2856
2857         do
2858         {
2859                 memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2860                 memcpy(mbox->data, buf, len);
2861                 mbox->cmd.length  = len;
2862                 mbox->cmd.lcn     = lcn;
2863
2864                 if (card->u.x.LAPB_hdlc){
2865                         mbox->cmd.pf = qdm;
2866                 }else{
2867                         mbox->cmd.qdm = qdm;
2868                 }
2869
2870                 mbox->cmd.command = cmd;
2871                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2872         } while (err && retry-- && x25_error(card, err, cmd , lcn));
2873
2874
2875         /* If buffers are busy the return code for LAPB HDLC is
2876          * 1. The above functions are looking for return code
2877          * of X25RES_NOT_READY if busy. */
2878
2879         if (card->u.x.LAPB_hdlc && err == 1){
2880                 err = X25RES_NOT_READY;
2881         }
2882
2883         return err;
2884 }
2885
2886 /*====================================================================
2887  *      Fetch X.25 asynchronous events.
2888  *===================================================================*/
2889
2890 static int x25_fetch_events (sdla_t* card)
2891 {
2892         TX25Status* status = card->flags;
2893         TX25Mbox* mbox = card->mbox;
2894         int err = 0;
2895
2896         if (status->gflags & 0x20)
2897         {
2898                 memset(&mbox->cmd, 0, sizeof(TX25Cmd));
2899                 mbox->cmd.command = X25_IS_DATA_AVAILABLE;
2900                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2901                 if (err) x25_error(card, err, X25_IS_DATA_AVAILABLE, 0);
2902         }
2903         return err;
2904 }
2905
2906 /*====================================================================
2907  *      X.25 asynchronous event/error handler.
2908  *              This routine is called each time interface command returns
2909  *              non-zero return code to handle X.25 asynchronous events and
2910  *              common errors. Return non-zero to repeat command or zero to
2911  *              cancel it.
2912  *
2913  *      Notes:
2914  *      1. This function may be called recursively, as handling some of the
2915  *      asynchronous events (e.g. call request) requires execution of the
2916  *      interface command(s) that, in turn, may also return asynchronous
2917  *      events.  To avoid re-entrancy problems we copy mailbox to dynamically
2918  *      allocated memory before processing events.
2919  *====================================================================*/
2920
2921 static int x25_error (sdla_t* card, int err, int cmd, int lcn)
2922 {
2923         int retry = 1;
2924         unsigned dlen = ((TX25Mbox*)card->mbox)->cmd.length;
2925         TX25Mbox* mb;
2926
2927         mb = kmalloc(sizeof(TX25Mbox) + dlen, GFP_ATOMIC);
2928         if (mb == NULL)
2929         {
2930                 printk(KERN_ERR "%s: x25_error() out of memory!\n",
2931                         card->devname);
2932                 return 0;
2933         }
2934         memcpy(mb, card->mbox, sizeof(TX25Mbox) + dlen);
2935         switch (err){
2936
2937         case X25RES_ASYNC_PACKET:       /* X.25 asynchronous packet was received */
2938
2939                 mb->data[dlen] = '\0';
2940
2941                 switch (mb->cmd.pktType & 0x7F){
2942
2943                 case ASE_CALL_RQST:             /* incoming call */
2944                         retry = incoming_call(card, cmd, lcn, mb);
2945                         break;
2946
2947                 case ASE_CALL_ACCEPTED:         /* connected */
2948                         retry = call_accepted(card, cmd, lcn, mb);
2949                         break;
2950
2951                 case ASE_CLEAR_RQST:            /* call clear request */
2952                         retry = call_cleared(card, cmd, lcn, mb);
2953                         break;
2954
2955                 case ASE_RESET_RQST:            /* reset request */
2956                         printk(KERN_INFO "%s: X.25 reset request on LCN %d! "
2957                                 "Cause:0x%02X Diagn:0x%02X\n",
2958                                 card->devname, mb->cmd.lcn, mb->cmd.cause,
2959                                 mb->cmd.diagn);
2960                         api_oob_event (card,mb);
2961                         break;
2962
2963                 case ASE_RESTART_RQST:          /* restart request */
2964                         retry = restart_event(card, cmd, lcn, mb);
2965                         break;
2966
2967                 case ASE_CLEAR_CONFRM:
2968                         if (clear_confirm_event (card,mb))
2969                                 break;
2970
2971                         /* I use the goto statement here so if
2972                          * somebody inserts code between the
2973                          * case and default, we will not have
2974                          * ghost problems */
2975
2976                         goto dflt_1;
2977
2978                 default:
2979 dflt_1:
2980                         printk(KERN_INFO "%s: X.25 event 0x%02X on LCN %d! "
2981                                 "Cause:0x%02X Diagn:0x%02X\n",
2982                                 card->devname, mb->cmd.pktType,
2983                                 mb->cmd.lcn, mb->cmd.cause, mb->cmd.diagn);
2984                 }
2985                 break;
2986
2987         case X25RES_PROTO_VIOLATION:    /* X.25 protocol violation indication */
2988
2989                 /* Bug Fix: Mar 14 2000
2990                  * The Protocol violation error conditions were
2991                  * not handled previously */
2992
2993                 switch (mb->cmd.pktType & 0x7F){
2994
2995                 case PVE_CLEAR_RQST:    /* Clear request */
2996                         retry = call_cleared(card, cmd, lcn, mb);
2997                         break;
2998
2999                 case PVE_RESET_RQST:    /* Reset request */
3000                         printk(KERN_INFO "%s: X.25 reset request on LCN %d! "
3001                                 "Cause:0x%02X Diagn:0x%02X\n",
3002                                 card->devname, mb->cmd.lcn, mb->cmd.cause,
3003                                 mb->cmd.diagn);
3004                         api_oob_event (card,mb);
3005                         break;
3006
3007                 case PVE_RESTART_RQST:  /* Restart request */
3008                         retry = restart_event(card, cmd, lcn, mb);
3009                         break;
3010
3011                 default :
3012                         printk(KERN_INFO
3013                                 "%s: X.25 protocol violation on LCN %d! "
3014                                 "Packet:0x%02X Cause:0x%02X Diagn:0x%02X\n",
3015                                 card->devname, mb->cmd.lcn,
3016                                 mb->cmd.pktType & 0x7F, mb->cmd.cause, mb->cmd.diagn);
3017                         api_oob_event(card,mb);
3018                 }
3019                 break;
3020
3021         case 0x42:      /* X.25 timeout */
3022                 retry = timeout_event(card, cmd, lcn, mb);
3023                 break;
3024
3025         case 0x43:      /* X.25 retry limit exceeded */
3026                 printk(KERN_INFO
3027                         "%s: exceeded X.25 retry limit on LCN %d! "
3028                         "Packet:0x%02X Diagn:0x%02X\n", card->devname,
3029                         mb->cmd.lcn, mb->cmd.pktType, mb->cmd.diagn)
3030                 ;
3031                 break;
3032
3033         case 0x08:      /* modem failure */
3034 #ifndef MODEM_NOT_LOG
3035                 printk(KERN_INFO "%s: modem failure!\n", card->devname);
3036 #endif /* MODEM_NOT_LOG */
3037                 api_oob_event(card,mb);
3038                 break;
3039
3040         case 0x09:      /* N2 retry limit */
3041                 printk(KERN_INFO "%s: exceeded HDLC retry limit!\n",
3042                         card->devname);
3043                 api_oob_event(card,mb);
3044                 break;
3045
3046         case 0x06:      /* unnumbered frame was received while in ABM */
3047                 printk(KERN_INFO "%s: received Unnumbered frame 0x%02X!\n",
3048                         card->devname, mb->data[0]);
3049                 api_oob_event(card,mb);
3050                 break;
3051
3052         case CMD_TIMEOUT:
3053                 printk(KERN_ERR "%s: command 0x%02X timed out!\n",
3054                         card->devname, cmd)
3055                 ;
3056                 retry = 0;      /* abort command */
3057                 break;
3058
3059         case X25RES_NOT_READY:
3060                 retry = 1;
3061                 break;
3062
3063         case 0x01:
3064                 if (card->u.x.LAPB_hdlc)
3065                         break;
3066
3067                 if (mb->cmd.command == 0x16)
3068                         break;
3069                 /* I use the goto statement here so if
3070                  * somebody inserts code between the
3071                  * case and default, we will not have
3072                  * ghost problems */
3073                 goto dflt_2;
3074
3075         default:
3076 dflt_2:
3077                 printk(KERN_INFO "%s: command 0x%02X returned 0x%02X! Lcn %i\n",
3078                         card->devname, cmd, err, mb->cmd.lcn)
3079                 ;
3080                 retry = 0;      /* abort command */
3081         }
3082         kfree(mb);
3083         return retry;
3084 }
3085
3086 /*====================================================================
3087  *      X.25 Asynchronous Event Handlers
3088  *      These functions are called by the x25_error() and should return 0, if
3089  *      the command resulting in the asynchronous event must be aborted.
3090  *====================================================================*/
3091
3092
3093
3094 /*====================================================================
3095  *Handle X.25 incoming call request.
3096  *      RFC 1356 establishes the following rules:
3097  *      1. The first octet in the Call User Data (CUD) field of the call
3098  *         request packet contains NLPID identifying protocol encapsulation
3099  *      2. Calls MUST NOT be accepted unless router supports requested
3100  *         protocol encapsulation.
3101  *      3. A diagnostic code 249 defined by ISO/IEC 8208 may be used
3102  *         when clearing a call because protocol encapsulation is not
3103  *         supported.
3104  *      4. If an incoming call is received while a call request is
3105  *         pending (i.e. call collision has occurred), the incoming call
3106  *         shall be rejected and call request shall be retried.
3107  *====================================================================*/
3108
3109 static int incoming_call (sdla_t* card, int cmd, int lcn, TX25Mbox* mb)
3110 {
3111         struct wan_device* wandev = &card->wandev;
3112         int new_lcn = mb->cmd.lcn;
3113         struct net_device* dev = get_dev_by_lcn(wandev, new_lcn);
3114         x25_channel_t* chan = NULL;
3115         int accept = 0;         /* set to '1' if o.k. to accept call */
3116         unsigned int user_data;
3117         x25_call_info_t* info;
3118
3119         /* Make sure there is no call collision */
3120         if (dev != NULL)
3121         {
3122                 printk(KERN_INFO
3123                         "%s: X.25 incoming call collision on LCN %d!\n",
3124                         card->devname, new_lcn);
3125
3126                 x25_clear_call(card, new_lcn, 0, 0);
3127                 return 1;
3128         }
3129
3130         /* Make sure D bit is not set in call request */
3131 //FIXME: THIS IS NOT TURE !!!! TAKE IT OUT
3132 //      if (mb->cmd.qdm & 0x02)
3133 //      {
3134 //              printk(KERN_INFO
3135 //                      "%s: X.25 incoming call on LCN %d with D-bit set!\n",
3136 //                      card->devname, new_lcn);
3137 //
3138 //              x25_clear_call(card, new_lcn, 0, 0);
3139 //              return 1;
3140 //      }
3141
3142         /* Parse call request data */
3143         info = kmalloc(sizeof(x25_call_info_t), GFP_ATOMIC);
3144         if (info == NULL)
3145         {
3146                 printk(KERN_ERR
3147                         "%s: not enough memory to parse X.25 incoming call "
3148                         "on LCN %d!\n", card->devname, new_lcn);
3149                 x25_clear_call(card, new_lcn, 0, 0);
3150                 return 1;
3151         }
3152
3153         parse_call_info(mb->data, info);
3154
3155         if (card->u.x.logging)
3156                 printk(KERN_INFO "\n%s: X.25 incoming call on LCN %d!\n",
3157                         card->devname, new_lcn);
3158
3159         /* Conver the first two ASCII characters into an
3160          * interger. Used to check the incoming protocol
3161          */
3162         user_data = hex_to_uint(info->user,2);
3163
3164         /* Find available channel */
3165         for (dev = wandev->dev; dev; dev = *((struct net_device **)dev->priv)) {
3166                 chan = dev->priv;
3167
3168                 if (chan->common.usedby == API)
3169                         continue;
3170
3171                 if (!chan->common.svc || (chan->common.state != WAN_DISCONNECTED))
3172                         continue;
3173
3174                 if (user_data == NLPID_IP && chan->protocol != htons(ETH_P_IP)){
3175                         printk(KERN_INFO "IP packet but configured for IPX : %x, %x\n",
3176                                        htons(chan->protocol), info->user[0]);
3177                         continue;
3178                 }
3179
3180                 if (user_data == NLPID_SNAP && chan->protocol != htons(ETH_P_IPX)){
3181                         printk(KERN_INFO "IPX packet but configured for IP: %x\n",
3182                                        htons(chan->protocol));
3183                         continue;
3184                 }
3185                 if (strcmp(info->src, chan->addr) == 0)
3186                         break;
3187
3188                 /* If just an '@' is specified, accept all incoming calls */
3189                 if (strcmp(chan->addr, "") == 0)
3190                         break;
3191         }
3192
3193         if (dev == NULL){
3194
3195                 /* If the call is not for any WANPIPE interfaces
3196                  * check to see if there is an API listening queue
3197                  * waiting for data. If there is send the packet
3198                  * up the stack.
3199                  */
3200                 if (card->sk != NULL && card->func != NULL){
3201                         if (api_incoming_call(card,mb,new_lcn)){
3202                                 x25_clear_call(card, new_lcn, 0, 0);
3203                         }
3204                         accept = 0;
3205                 }else{
3206                         printk(KERN_INFO "%s: no channels available!\n",
3207                                 card->devname);
3208
3209                         x25_clear_call(card, new_lcn, 0, 0);
3210                 }
3211
3212         }else if (info->nuser == 0){
3213
3214                 printk(KERN_INFO
3215                         "%s: no user data in incoming call on LCN %d!\n",
3216                         card->devname, new_lcn)
3217                 ;
3218                 x25_clear_call(card, new_lcn, 0, 0);
3219
3220         }else switch (info->user[0]){
3221
3222                 case 0:         /* multiplexed */
3223                         chan->protocol = htons(0);
3224                         accept = 1;
3225                         break;
3226
3227                 case NLPID_IP:  /* IP datagrams */
3228                         accept = 1;
3229                         break;
3230
3231                 case NLPID_SNAP: /* IPX datagrams */
3232                         accept = 1;
3233                         break;
3234
3235                 default:
3236                         printk(KERN_INFO
3237                                 "%s: unsupported NLPID 0x%02X in incoming call "
3238                                 "on LCN %d!\n", card->devname, info->user[0], new_lcn);
3239                         x25_clear_call(card, new_lcn, 0, 249);
3240         }
3241
3242         if (accept && (x25_accept_call(card, new_lcn, 0) == CMD_OK)){
3243
3244                 bind_lcn_to_dev (card, chan->dev, new_lcn);
3245
3246                 if (x25_get_chan_conf(card, chan) == CMD_OK)
3247                         set_chan_state(dev, WAN_CONNECTED);
3248                 else
3249                         x25_clear_call(card, new_lcn, 0, 0);
3250         }
3251         kfree(info);
3252         return 1;
3253 }
3254
3255 /*====================================================================
3256  *      Handle accepted call.
3257  *====================================================================*/
3258
3259 static int call_accepted (sdla_t* card, int cmd, int lcn, TX25Mbox* mb)
3260 {
3261         unsigned new_lcn = mb->cmd.lcn;
3262         struct net_device* dev = find_channel(card, new_lcn);
3263         x25_channel_t* chan;
3264
3265         if (dev == NULL){
3266                 printk(KERN_INFO
3267                         "%s: clearing orphaned connection on LCN %d!\n",
3268                         card->devname, new_lcn);
3269                 x25_clear_call(card, new_lcn, 0, 0);
3270                 return 1;
3271         }
3272
3273         if (card->u.x.logging)
3274                 printk(KERN_INFO "%s: X.25 call accepted on Dev %s and LCN %d!\n",
3275                         card->devname, dev->name, new_lcn);
3276
3277         /* Get channel configuration and notify router */
3278         chan = dev->priv;
3279         if (x25_get_chan_conf(card, chan) != CMD_OK)
3280         {
3281                 x25_clear_call(card, new_lcn, 0, 0);
3282                 return 1;
3283         }
3284
3285         set_chan_state(dev, WAN_CONNECTED);
3286
3287         if (chan->common.usedby == API){
3288                 send_delayed_cmd_result(card,dev,mb);
3289                 bind_lcn_to_dev (card, dev, new_lcn);
3290         }
3291
3292         return 1;
3293 }
3294
3295 /*====================================================================
3296  *      Handle cleared call.
3297  *====================================================================*/
3298
3299 static int call_cleared (sdla_t* card, int cmd, int lcn, TX25Mbox* mb)
3300 {
3301         unsigned new_lcn = mb->cmd.lcn;
3302         struct net_device* dev = find_channel(card, new_lcn);
3303         x25_channel_t *chan;
3304         unsigned char old_state;
3305
3306         if (card->u.x.logging){
3307                 printk(KERN_INFO "%s: X.25 clear request on LCN %d! Cause:0x%02X "
3308                 "Diagn:0x%02X\n",
3309                 card->devname, new_lcn, mb->cmd.cause, mb->cmd.diagn);
3310         }
3311
3312         if (dev == NULL){
3313                 printk(KERN_INFO "%s: X.25 clear request : No device for clear\n",
3314                                 card->devname);
3315                 return 1;
3316         }
3317
3318         chan=dev->priv;
3319
3320         old_state = chan->common.state;
3321
3322         set_chan_state(dev, WAN_DISCONNECTED);
3323
3324         if (chan->common.usedby == API){
3325
3326                 switch (old_state){
3327
3328                 case WAN_CONNECTING:
3329                         send_delayed_cmd_result(card,dev,mb);
3330                         break;
3331                 case WAN_CONNECTED:
3332                         send_oob_msg(card,dev,mb);
3333                         break;
3334                 }
3335         }
3336
3337         return ((cmd == X25_WRITE) && (lcn == new_lcn)) ? 0 : 1;
3338 }
3339
3340 /*====================================================================
3341  *      Handle X.25 restart event.
3342  *====================================================================*/
3343
3344 static int restart_event (sdla_t* card, int cmd, int lcn, TX25Mbox* mb)
3345 {
3346         struct wan_device* wandev = &card->wandev;
3347         struct net_device* dev;
3348         x25_channel_t *chan;
3349         unsigned char old_state;
3350
3351         printk(KERN_INFO
3352                 "%s: X.25 restart request! Cause:0x%02X Diagn:0x%02X\n",
3353                 card->devname, mb->cmd.cause, mb->cmd.diagn);
3354
3355         /* down all logical channels */
3356         for (dev = wandev->dev; dev; dev = *((struct net_device **)dev->priv)) {
3357                 chan=dev->priv;
3358                 old_state = chan->common.state;
3359
3360                 set_chan_state(dev, WAN_DISCONNECTED);
3361
3362                 if (chan->common.usedby == API){
3363                         switch (old_state){
3364
3365                         case WAN_CONNECTING:
3366                                 send_delayed_cmd_result(card,dev,mb);
3367                                 break;
3368                         case WAN_CONNECTED:
3369                                 send_oob_msg(card,dev,mb);
3370                                 break;
3371                         }
3372                 }
3373         }
3374         return (cmd == X25_WRITE) ? 0 : 1;
3375 }
3376
3377 /*====================================================================
3378  * Handle timeout event.
3379  *====================================================================*/
3380
3381 static int timeout_event (sdla_t* card, int cmd, int lcn, TX25Mbox* mb)
3382 {
3383         unsigned new_lcn = mb->cmd.lcn;
3384
3385         if (mb->cmd.pktType == 0x05)    /* call request time out */
3386         {
3387                 struct net_device* dev = find_channel(card,new_lcn);
3388
3389                 printk(KERN_INFO "%s: X.25 call timed timeout on LCN %d!\n",
3390                         card->devname, new_lcn);
3391
3392                 if (dev){
3393                         x25_channel_t *chan = dev->priv;
3394                         set_chan_state(dev, WAN_DISCONNECTED);
3395
3396                         if (chan->common.usedby == API){
3397                                 send_delayed_cmd_result(card,dev,card->mbox);
3398                         }
3399                 }
3400         }else{
3401                 printk(KERN_INFO "%s: X.25 packet 0x%02X timeout on LCN %d!\n",
3402                 card->devname, mb->cmd.pktType, new_lcn);
3403         }
3404         return 1;
3405 }
3406
3407 /*
3408  *      Miscellaneous
3409  */
3410
3411 /*====================================================================
3412  *      Establish physical connection.
3413  *      o open HDLC and raise DTR
3414  *
3415  *      Return:         0       connection established
3416  *                      1       connection is in progress
3417  *                      <0      error
3418  *===================================================================*/
3419
3420 static int connect (sdla_t* card)
3421 {
3422         TX25Status* status = card->flags;
3423
3424         if (x25_open_hdlc(card) || x25_setup_hdlc(card))
3425                 return -EIO;
3426
3427         wanpipe_set_state(card, WAN_CONNECTING);
3428
3429         x25_set_intr_mode(card, INTR_ON_TIMER);
3430         status->imask &= ~INTR_ON_TIMER;
3431
3432         return 1;
3433 }
3434
3435 /*
3436  *      Tear down physical connection.
3437  *      o close HDLC link
3438  *      o drop DTR
3439  *
3440  *      Return:         0
3441  *                      <0      error
3442  */
3443
3444 static int disconnect (sdla_t* card)
3445 {
3446         wanpipe_set_state(card, WAN_DISCONNECTED);
3447         x25_set_intr_mode(card, INTR_ON_TIMER); /* disable all interrupt except timer */
3448         x25_close_hdlc(card);                   /* close HDLC link */
3449         x25_set_dtr(card, 0);                   /* drop DTR */
3450         return 0;
3451 }
3452
3453 /*
3454  * Find network device by its channel number.
3455  */
3456
3457 static struct net_device* get_dev_by_lcn(struct wan_device* wandev,
3458                                          unsigned lcn)
3459 {
3460         struct net_device* dev;
3461
3462         for (dev = wandev->dev; dev; dev = *((struct net_device **)dev->priv))
3463                 if (((x25_channel_t*)dev->priv)->common.lcn == lcn)
3464                         break;
3465         return dev;
3466 }
3467
3468 /*
3469  *      Initiate connection on the logical channel.
3470  *      o for PVC we just get channel configuration
3471  *      o for SVCs place an X.25 call
3472  *
3473  *      Return:         0       connected
3474  *                      >0      connection in progress
3475  *                      <0      failure
3476  */
3477
3478 static int chan_connect(struct net_device* dev)
3479 {
3480         x25_channel_t* chan = dev->priv;
3481         sdla_t* card = chan->card;
3482
3483         if (chan->common.svc && chan->common.usedby == WANPIPE){
3484                 if (!chan->addr[0]){
3485                         printk(KERN_INFO "%s: No Destination Address\n",
3486                                         card->devname);
3487                         return -EINVAL; /* no destination address */
3488                 }
3489                 printk(KERN_INFO "%s: placing X.25 call to %s ...\n",
3490                         card->devname, chan->addr);
3491
3492                 if (x25_place_call(card, chan) != CMD_OK)
3493                         return -EIO;
3494
3495                 set_chan_state(dev, WAN_CONNECTING);
3496                 return 1;
3497         }else{
3498                 if (x25_get_chan_conf(card, chan) != CMD_OK)
3499                         return -EIO;
3500
3501                 set_chan_state(dev, WAN_CONNECTED);
3502         }
3503         return 0;
3504 }
3505
3506 /*
3507  *      Disconnect logical channel.
3508  *      o if SVC then clear X.25 call
3509  */
3510
3511 static int chan_disc(struct net_device* dev)
3512 {
3513         x25_channel_t* chan = dev->priv;
3514
3515         if (chan->common.svc){
3516                 x25_clear_call(chan->card, chan->common.lcn, 0, 0);
3517
3518                 /* For API we disconnect on clear
3519                  * confirmation.
3520                  */
3521                 if (chan->common.usedby == API)
3522                         return 0;
3523         }
3524
3525         set_chan_state(dev, WAN_DISCONNECTED);
3526
3527         return 0;
3528 }
3529
3530 /*
3531  *      Set logical channel state.
3532  */
3533
3534 static void set_chan_state(struct net_device* dev, int state)
3535 {
3536         x25_channel_t* chan = dev->priv;
3537         sdla_t* card = chan->card;
3538         unsigned long flags;
3539
3540         save_flags(flags);
3541         cli();
3542         if (chan->common.state != state)
3543         {
3544                 switch (state)
3545                 {
3546                         case WAN_CONNECTED:
3547                                 if (card->u.x.logging){
3548                                         printk (KERN_INFO
3549                                                 "%s: interface %s connected, lcn %i !\n",
3550                                                 card->devname, dev->name,chan->common.lcn);
3551                                 }
3552                                 *(unsigned short*)dev->dev_addr = htons(chan->common.lcn);
3553                                 chan->i_timeout_sofar = jiffies;
3554
3555                                 /* LAPB is PVC Based */
3556                                 if (card->u.x.LAPB_hdlc)
3557                                         chan->common.svc=0;
3558                                 break;
3559
3560                         case WAN_CONNECTING:
3561                                 if (card->u.x.logging){
3562                                         printk (KERN_INFO
3563                                                 "%s: interface %s connecting, lcn %i ...\n",
3564                                                 card->devname, dev->name, chan->common.lcn);
3565                                 }
3566                                 break;
3567
3568                         case WAN_DISCONNECTED:
3569                                 if (card->u.x.logging){
3570                                         printk (KERN_INFO
3571                                                 "%s: interface %s disconnected, lcn %i !\n",
3572                                                 card->devname, dev->name,chan->common.lcn);
3573                                 }
3574                                 atomic_set(&chan->common.disconnect,0);
3575
3576                                 if (chan->common.svc) {
3577                                         *(unsigned short*)dev->dev_addr = 0;
3578                                         card->u.x.svc_to_dev_map[(chan->common.lcn%X25_MAX_CHAN)]=NULL;
3579                                         chan->common.lcn = 0;
3580                                 }
3581
3582                                 if (chan->transmit_length){
3583                                         chan->transmit_length=0;
3584                                         atomic_set(&chan->common.driver_busy,0);
3585                                         chan->tx_offset=0;
3586                                         if (netif_queue_stopped(dev)){
3587                                                 netif_wake_queue(dev);
3588                                         }
3589                                 }
3590                                 atomic_set(&chan->common.command,0);
3591                                 break;
3592
3593                         case WAN_DISCONNECTING:
3594                                 if (card->u.x.logging){
3595                                         printk (KERN_INFO
3596                                         "\n%s: interface %s disconnecting, lcn %i ...\n",
3597                                         card->devname, dev->name,chan->common.lcn);
3598                                 }
3599                                 atomic_set(&chan->common.disconnect,0);
3600                                 break;
3601                 }
3602                 chan->common.state = state;
3603         }
3604         chan->state_tick = jiffies;
3605         restore_flags(flags);
3606 }
3607
3608 /*
3609  *      Send packet on a logical channel.
3610  *              When this function is called, tx_skb field of the channel data
3611  *              space points to the transmit socket buffer.  When transmission
3612  *              is complete, release socket buffer and reset 'tbusy' flag.
3613  *
3614  *      Return:         0       - transmission complete
3615  *                      1       - busy
3616  *
3617  *      Notes:
3618  *      1. If packet length is greater than MTU for this channel, we'll fragment
3619  *      the packet into 'complete sequence' using M-bit.
3620  *      2. When transmission is complete, an event notification should be issued
3621  *      to the router.
3622  */
3623
3624 static int chan_send(struct net_device* dev, void* buff, unsigned data_len,
3625                      unsigned char tx_intr)
3626 {
3627         x25_channel_t* chan = dev->priv;
3628         sdla_t* card = chan->card;
3629         TX25Status* status = card->flags;
3630         unsigned len=0, qdm=0, res=0, orig_len = 0;
3631         void *data;
3632
3633         /* Check to see if channel is ready */
3634         if ((!(status->cflags[chan->ch_idx] & 0x40) && !card->u.x.LAPB_hdlc)  ||
3635              !(*card->u.x.hdlc_buf_status & 0x40)){
3636
3637                 if (!tx_intr){
3638                         setup_for_delayed_transmit (dev, buff, data_len);
3639                         return 0;
3640                 }else{
3641                         /* By returning 0 to tx_intr the packet will be dropped */
3642                         ++card->wandev.stats.tx_dropped;
3643                         ++chan->ifstats.tx_dropped;
3644                         printk(KERN_INFO "%s: ERROR, Tx intr could not send, dropping %s:\n",
3645                                 card->devname,dev->name);
3646                         ++chan->if_send_stat.if_send_bfr_not_passed_to_adptr;
3647                         return 0;
3648                 }
3649         }
3650
3651         if (chan->common.usedby == API){
3652                 /* Remove the API Header */
3653                 x25api_hdr_t *api_data = (x25api_hdr_t *)buff;
3654
3655                 /* Set the qdm bits from the packet header
3656                  * User has the option to set the qdm bits
3657                  */
3658                 qdm = api_data->qdm;
3659
3660                 orig_len = len = data_len - sizeof(x25api_hdr_t);
3661                 data = (unsigned char*)buff + sizeof(x25api_hdr_t);
3662         }else{
3663                 data = buff;
3664                 orig_len = len = data_len;
3665         }
3666
3667         if (tx_intr){
3668                 /* We are in tx_intr, minus the tx_offset from
3669                  * the total length. The tx_offset part of the
3670                  * data has already been sent. Also, move the
3671                  * data pointer to proper offset location.
3672                  */
3673                 len -= chan->tx_offset;
3674                 data = (unsigned char*)data + chan->tx_offset;
3675         }
3676
3677         /* Check if the packet length is greater than MTU
3678          * If YES: Cut the len to MTU and set the M bit
3679          */
3680         if (len > chan->tx_pkt_size && !card->u.x.LAPB_hdlc){
3681                 len = chan->tx_pkt_size;
3682                 qdm |= M_BIT;
3683         }
3684
3685
3686         /* Pass only first three bits of the qdm byte to the send
3687          * routine. In case user sets any other bit which might
3688          * cause errors.
3689          */
3690
3691         switch(x25_send(card, chan->common.lcn, (qdm&0x07), len, data)){
3692                 case 0x00:      /* success */
3693                         chan->i_timeout_sofar = jiffies;
3694
3695                         dev->trans_start=jiffies;
3696
3697                         if ((qdm & M_BIT) && !card->u.x.LAPB_hdlc){
3698                                 if (!tx_intr){
3699                                         /* The M bit was set, which means that part of the
3700                                          * packet has been sent. Copy the packet into a buffer
3701                                          * and set the offset to len, so on next tx_inter
3702                                          * the packet will be sent using the below offset.
3703                                          */
3704                                         chan->tx_offset += len;
3705
3706                                         ++chan->ifstats.tx_packets;
3707                                         chan->ifstats.tx_bytes += len;
3708
3709                                         if (chan->tx_offset < orig_len){
3710                                                 setup_for_delayed_transmit (dev, buff, data_len);
3711                                         }
3712                                         res=0;
3713                                 }else{
3714                                         /* We are already in tx_inter, thus data is already
3715                                          * in the buffer. Update the offset and wait for
3716                                          * next tx_intr. We add on to the offset, since data can
3717                                          * be X number of times larger than max data size.
3718                                          */
3719                                         ++chan->ifstats.tx_packets;
3720                                         chan->ifstats.tx_bytes += len;
3721
3722                                         ++chan->if_send_stat.if_send_bfr_passed_to_adptr;
3723                                         chan->tx_offset += len;
3724
3725                                         /* The user can set the qdm bit as well.
3726                                          * If the entire packet was sent and qdm is still
3727                                          * set, than it's the user who has set the M bit. In that,
3728                                          * case indicate that the packet was send by returning
3729                                          * 0 and wait for a new packet. Otherwise, wait for next
3730                                          * tx interrupt to send the rest of the packet */
3731
3732                                         if (chan->tx_offset < orig_len){
3733                                                 res=1;
3734                                         }else{
3735                                                 res=0;
3736                                         }
3737                                 }
3738                         }else{
3739                                 ++chan->ifstats.tx_packets;
3740                                 chan->ifstats.tx_bytes += len;
3741                                 ++chan->if_send_stat.if_send_bfr_passed_to_adptr;
3742                                 res=0;
3743                         }
3744                         break;
3745
3746                 case 0x33:      /* Tx busy */
3747                         if (tx_intr){
3748                                 printk(KERN_INFO "%s: Tx_intr: Big Error dropping packet %s\n",
3749                                                 card->devname,dev->name);
3750                                 ++chan->ifstats.tx_dropped;
3751                                 ++card->wandev.stats.tx_dropped;
3752                                 ++chan->if_send_stat.if_send_bfr_not_passed_to_adptr;
3753                                 res=0;
3754                         }else{
3755                                 DBG_PRINTK(KERN_INFO
3756                                         "%s: Send: Big Error should have tx: storring %s\n",
3757                                                 card->devname,dev->name);
3758                                 setup_for_delayed_transmit (dev, buff, data_len);
3759                                 res=1;
3760                         }
3761                         break;
3762
3763                 default:        /* failure */
3764                         ++chan->ifstats.tx_errors;
3765                         if (tx_intr){
3766                                 printk(KERN_INFO "%s: Tx_intr: Failure to send, dropping %s\n",
3767                                         card->devname,dev->name);
3768                                 ++chan->ifstats.tx_dropped;
3769                                 ++card->wandev.stats.tx_dropped;
3770                                 ++chan->if_send_stat.if_send_bfr_not_passed_to_adptr;
3771                                 res=0;
3772                         }else{
3773                                 DBG_PRINTK(KERN_INFO "%s: Send: Failure to send !!!, storing %s\n",
3774                                         card->devname,dev->name);
3775                                 setup_for_delayed_transmit (dev, buff, data_len);
3776                                 res=1;
3777                         }
3778                         break;
3779         }
3780         return res;
3781 }
3782
3783
3784 /*
3785  *      Parse X.25 call request data and fill x25_call_info_t structure.
3786  */
3787
3788 static void parse_call_info (unsigned char* str, x25_call_info_t* info)
3789 {
3790         memset(info, 0, sizeof(x25_call_info_t));
3791         for (; *str; ++str)
3792         {
3793                 int i;
3794                 unsigned char ch;
3795
3796                 if (*str == '-') switch (str[1]) {
3797
3798                         /* Take minus 2 off the maximum size so that
3799                          * last byte is 0. This way we can use string
3800                          * manipulaton functions on call information.
3801                          */
3802
3803                         case 'd':       /* destination address */
3804                                 for (i = 0; i < (MAX_X25_ADDR_SIZE-2); ++i){
3805                                         ch = str[2+i];
3806                                         if (isspace(ch)) break;
3807                                         info->dest[i] = ch;
3808                                 }
3809                                 break;
3810
3811                         case 's':       /* source address */
3812                                 for (i = 0; i < (MAX_X25_ADDR_SIZE-2); ++i){
3813                                         ch = str[2+i];
3814                                         if (isspace(ch)) break;
3815                                         info->src[i] = ch;
3816                                 }
3817                                 break;
3818
3819                         case 'u':       /* user data */
3820                                 for (i = 0; i < (MAX_X25_DATA_SIZE-2); ++i){
3821                                         ch = str[2+i];
3822                                         if (isspace(ch)) break;
3823                                         info->user[i] = ch;
3824                                 }
3825                                 info->nuser = i;
3826                                 break;
3827
3828                         case 'f':       /* facilities */
3829                                 for (i = 0; i < (MAX_X25_FACL_SIZE-2); ++i){
3830                                         ch = str[2+i];
3831                                         if (isspace(ch)) break;
3832                                         info->facil[i] = ch;
3833                                 }
3834                                 info->nfacil = i;
3835                                 break;
3836                 }
3837         }
3838 }
3839
3840 /*
3841  *      Convert line speed in bps to a number used by S502 code.
3842  */
3843
3844 static unsigned char bps_to_speed_code (unsigned long bps)
3845 {
3846         unsigned char   number;
3847
3848         if (bps <= 1200)        number = 0x01;
3849         else if (bps <= 2400)   number = 0x02;
3850         else if (bps <= 4800)   number = 0x03;
3851         else if (bps <= 9600)   number = 0x04;
3852         else if (bps <= 19200)  number = 0x05;
3853         else if (bps <= 38400)  number = 0x06;
3854         else if (bps <= 45000)  number = 0x07;
3855         else if (bps <= 56000)  number = 0x08;
3856         else if (bps <= 64000)  number = 0x09;
3857         else if (bps <= 74000)  number = 0x0A;
3858         else if (bps <= 112000) number = 0x0B;
3859         else if (bps <= 128000) number = 0x0C;
3860         else number = 0x0D;
3861
3862         return number;
3863 }
3864
3865 /*
3866  *      Convert decimal string to unsigned integer.
3867  *      If len != 0 then only 'len' characters of the string are converted.
3868  */
3869
3870 static unsigned int dec_to_uint (unsigned char* str, int len)
3871 {
3872         unsigned val;
3873
3874         if (!len)
3875                 len = strlen(str);
3876
3877         for (val = 0; len && is_digit(*str); ++str, --len)
3878                 val = (val * 10) + (*str - (unsigned)'0');
3879
3880         return val;
3881 }
3882
3883 /*
3884  *      Convert hex string to unsigned integer.
3885  *      If len != 0 then only 'len' characters of the string are conferted.
3886  */
3887
3888 static unsigned int hex_to_uint (unsigned char* str, int len)
3889 {
3890         unsigned val, ch;
3891
3892         if (!len)
3893                 len = strlen(str);
3894
3895         for (val = 0; len; ++str, --len)
3896         {
3897                 ch = *str;
3898                 if (is_digit(ch))
3899                         val = (val << 4) + (ch - (unsigned)'0');
3900                 else if (is_hex_digit(ch))
3901                         val = (val << 4) + ((ch & 0xDF) - (unsigned)'A' + 10);
3902                 else break;
3903         }
3904         return val;
3905 }
3906
3907
3908 static int handle_IPXWAN(unsigned char *sendpacket, char *devname, unsigned char enable_IPX, unsigned long network_number, unsigned short proto)
3909 {
3910         int i;
3911
3912         if( proto == ETH_P_IPX) {
3913                 /* It's an IPX packet */
3914                 if(!enable_IPX) {
3915                         /* Return 1 so we don't pass it up the stack. */
3916                         return 1;
3917                 }
3918         } else {
3919                 /* It's not IPX so pass it up the stack.*/
3920                 return 0;
3921         }
3922
3923         if( sendpacket[16] == 0x90 &&
3924             sendpacket[17] == 0x04)
3925         {
3926                 /* It's IPXWAN  */
3927
3928                 if( sendpacket[2] == 0x02 &&
3929                     sendpacket[34] == 0x00)
3930                 {
3931                         /* It's a timer request packet */
3932                         printk(KERN_INFO "%s: Received IPXWAN Timer Request packet\n",devname);
3933
3934                         /* Go through the routing options and answer no to every
3935                          * option except Unnumbered RIP/SAP
3936                          */
3937                         for(i = 41; sendpacket[i] == 0x00; i += 5)
3938                         {
3939                                 /* 0x02 is the option for Unnumbered RIP/SAP */
3940                                 if( sendpacket[i + 4] != 0x02)
3941                                 {
3942                                         sendpacket[i + 1] = 0;
3943                                 }
3944                         }
3945
3946                         /* Skip over the extended Node ID option */
3947                         if( sendpacket[i] == 0x04 )
3948                         {
3949                                 i += 8;
3950                         }
3951
3952                         /* We also want to turn off all header compression opt.                          */
3953                         for(; sendpacket[i] == 0x80 ;)
3954                         {
3955                                 sendpacket[i + 1] = 0;
3956                                 i += (sendpacket[i + 2] << 8) + (sendpacket[i + 3]) + 4;
3957                         }
3958
3959                         /* Set the packet type to timer response */
3960                         sendpacket[34] = 0x01;
3961
3962                         printk(KERN_INFO "%s: Sending IPXWAN Timer Response\n",devname);
3963                 }
3964                 else if( sendpacket[34] == 0x02 )
3965                 {
3966                         /* This is an information request packet */
3967                         printk(KERN_INFO "%s: Received IPXWAN Information Request packet\n",devname);
3968
3969                         /* Set the packet type to information response */
3970                         sendpacket[34] = 0x03;
3971
3972                         /* Set the router name */
3973                         sendpacket[51] = 'X';
3974                         sendpacket[52] = 'T';
3975                         sendpacket[53] = 'P';
3976                         sendpacket[54] = 'I';
3977                         sendpacket[55] = 'P';
3978                         sendpacket[56] = 'E';
3979                         sendpacket[57] = '-';
3980                         sendpacket[58] = CVHexToAscii(network_number >> 28);
3981                         sendpacket[59] = CVHexToAscii((network_number & 0x0F000000)>> 24);
3982                         sendpacket[60] = CVHexToAscii((network_number & 0x00F00000)>> 20);
3983                         sendpacket[61] = CVHexToAscii((network_number & 0x000F0000)>> 16);
3984                         sendpacket[62] = CVHexToAscii((network_number & 0x0000F000)>> 12);
3985                         sendpacket[63] = CVHexToAscii((network_number & 0x00000F00)>> 8);
3986                         sendpacket[64] = CVHexToAscii((network_number & 0x000000F0)>> 4);
3987                         sendpacket[65] = CVHexToAscii(network_number & 0x0000000F);
3988                         for(i = 66; i < 99; i+= 1)
3989                         {
3990                                 sendpacket[i] = 0;
3991                         }
3992
3993                         printk(KERN_INFO "%s: Sending IPXWAN Information Response packet\n",devname);
3994                 }
3995                 else
3996                 {
3997                         printk(KERN_INFO "%s: Unknown IPXWAN packet!\n",devname);
3998                         return 0;
3999                 }
4000
4001                 /* Set the WNodeID to our network address */
4002                 sendpacket[35] = (unsigned char)(network_number >> 24);
4003                 sendpacket[36] = (unsigned char)((network_number & 0x00FF0000) >> 16);
4004                 sendpacket[37] = (unsigned char)((network_number & 0x0000FF00) >> 8);
4005                 sendpacket[38] = (unsigned char)(network_number & 0x000000FF);
4006
4007                 return 1;
4008         } else {
4009                 /*If we get here it's an IPX-data packet, so it'll get passed up the stack.
4010                  */
4011                 /* switch the network numbers */
4012                 switch_net_numbers(sendpacket, network_number, 1);
4013                 return 0;
4014         }
4015 }
4016
4017 /*
4018  *      If incoming is 0 (outgoing)- if the net numbers is ours make it 0
4019  *      if incoming is 1 - if the net number is 0 make it ours
4020  */
4021
4022 static void switch_net_numbers(unsigned char *sendpacket, unsigned long network_number, unsigned char incoming)
4023 {
4024         unsigned long pnetwork_number;
4025
4026         pnetwork_number = (unsigned long)((sendpacket[6] << 24) +
4027                           (sendpacket[7] << 16) + (sendpacket[8] << 8) +
4028                           sendpacket[9]);
4029
4030
4031         if (!incoming) {
4032                 /*If the destination network number is ours, make it 0 */
4033                 if( pnetwork_number == network_number) {
4034                         sendpacket[6] = sendpacket[7] = sendpacket[8] =
4035                                          sendpacket[9] = 0x00;
4036                 }
4037         } else {
4038                 /* If the incoming network is 0, make it ours */
4039                 if( pnetwork_number == 0) {
4040                         sendpacket[6] = (unsigned char)(network_number >> 24);
4041                         sendpacket[7] = (unsigned char)((network_number &
4042                                          0x00FF0000) >> 16);
4043                         sendpacket[8] = (unsigned char)((network_number &
4044                                          0x0000FF00) >> 8);
4045                         sendpacket[9] = (unsigned char)(network_number &
4046                                          0x000000FF);
4047                 }
4048         }
4049
4050
4051         pnetwork_number = (unsigned long)((sendpacket[18] << 24) +
4052                           (sendpacket[19] << 16) + (sendpacket[20] << 8) +
4053                           sendpacket[21]);
4054
4055
4056         if( !incoming ) {
4057                 /* If the source network is ours, make it 0 */
4058                 if( pnetwork_number == network_number) {
4059                         sendpacket[18] = sendpacket[19] = sendpacket[20] =
4060                                  sendpacket[21] = 0x00;
4061                 }
4062         } else {
4063                 /* If the source network is 0, make it ours */
4064                 if( pnetwork_number == 0 ) {
4065                         sendpacket[18] = (unsigned char)(network_number >> 24);
4066                         sendpacket[19] = (unsigned char)((network_number &
4067                                          0x00FF0000) >> 16);
4068                         sendpacket[20] = (unsigned char)((network_number &
4069                                          0x0000FF00) >> 8);
4070                         sendpacket[21] = (unsigned char)(network_number &
4071                                          0x000000FF);
4072                 }
4073         }
4074 } /* switch_net_numbers */
4075
4076
4077
4078
4079 /********************* X25API SPECIFIC FUNCTIONS ****************/
4080
4081
4082 /*===============================================================
4083  *  find_channel
4084  *
4085  *      Manages the lcn to device map. It increases performance
4086  *      because it eliminates the need to search through the link
4087  *      list for a device which is bounded to a specific lcn.
4088  *
4089  *===============================================================*/
4090
4091
4092 struct net_device *find_channel(sdla_t *card, unsigned lcn)
4093 {
4094         if (card->u.x.LAPB_hdlc){
4095
4096                 return card->wandev.dev;
4097
4098         }else{
4099                 /* We don't know whether the incoming lcn
4100                  * is a PVC or an SVC channel. But we do know that
4101                  * the lcn cannot be for both the PVC and the SVC
4102                  * channel.
4103
4104                  * If the lcn number is greater or equal to 255,
4105                  * take the modulo 255 of that number. We only have
4106                  * 255 locations, thus higher numbers must be mapped
4107                  * to a number between 0 and 245.
4108
4109                  * We must separate pvc's and svc's since two don't
4110                  * have to be contiguous.  Meaning pvc's can start
4111                  * from 1 to 10 and svc's can start from 256 to 266.
4112                  * But 256%255 is 1, i.e. CONFLICT.
4113                  */
4114
4115
4116                 /* Highest LCN number must be less or equal to 4096 */
4117                 if ((lcn <= MAX_LCN_NUM) && (lcn > 0)){
4118
4119                         if (lcn < X25_MAX_CHAN){
4120                                 if (card->u.x.svc_to_dev_map[lcn])
4121                                         return card->u.x.svc_to_dev_map[lcn];
4122
4123                                 if (card->u.x.pvc_to_dev_map[lcn])
4124                                         return card->u.x.pvc_to_dev_map[lcn];
4125
4126                         }else{
4127                                 int new_lcn = lcn%X25_MAX_CHAN;
4128                                 if (card->u.x.svc_to_dev_map[new_lcn])
4129                                         return card->u.x.svc_to_dev_map[new_lcn];
4130
4131                                 if (card->u.x.pvc_to_dev_map[new_lcn])
4132                                         return card->u.x.pvc_to_dev_map[new_lcn];
4133                         }
4134                 }
4135                 return NULL;
4136         }
4137 }
4138
4139 void bind_lcn_to_dev(sdla_t *card, struct net_device *dev, unsigned lcn)
4140 {
4141         x25_channel_t *chan = dev->priv;
4142
4143         /* Modulo the lcn number by X25_MAX_CHAN (255)
4144          * because the lcn number can be greater than 255
4145          *
4146          * We need to split svc and pvc since they don't have
4147          * to be contigous.
4148          */
4149
4150         if (chan->common.svc){
4151                 card->u.x.svc_to_dev_map[(lcn % X25_MAX_CHAN)] = dev;
4152         }else{
4153                 card->u.x.pvc_to_dev_map[(lcn % X25_MAX_CHAN)] = dev;
4154         }
4155         chan->common.lcn = lcn;
4156 }
4157
4158
4159
4160 /*===============================================================
4161  * x25api_bh
4162  *
4163  *
4164  *==============================================================*/
4165
4166 static void x25api_bh(struct net_device* dev)
4167 {
4168         x25_channel_t* chan = dev->priv;
4169         sdla_t* card = chan->card;
4170         struct sk_buff *skb;
4171
4172         if (atomic_read(&chan->bh_buff_used) == 0){
4173                 printk(KERN_INFO "%s: BH Buffer Empty in BH\n",
4174                                 card->devname);
4175                 clear_bit(0, &chan->tq_working);
4176                 return;
4177         }
4178
4179         while (atomic_read(&chan->bh_buff_used)){
4180
4181                 /* If the sock is in the process of unlinking the
4182                  * driver from the socket, we must get out.
4183                  * This never happends but is a sanity check. */
4184                 if (test_bit(0,&chan->common.common_critical)){
4185                         clear_bit(0, &chan->tq_working);
4186                         return;
4187                 }
4188
4189                 /* If LAPB HDLC, do not drop packets if socket is
4190                  * not connected.  Let the buffer fill up and
4191                  * turn off rx interrupt */
4192                 if (card->u.x.LAPB_hdlc){
4193                         if (chan->common.sk == NULL || chan->common.func == NULL){
4194                                 clear_bit(0, &chan->tq_working);
4195                                 return;
4196                         }
4197                 }
4198
4199                 skb  = ((bh_data_t *)&chan->bh_head[chan->bh_read])->skb;
4200
4201                 if (skb == NULL){
4202                         printk(KERN_INFO "%s: BH Skb empty for read %i\n",
4203                                         card->devname,chan->bh_read);
4204                 }else{
4205
4206                         if (chan->common.sk == NULL || chan->common.func == NULL){
4207                                 printk(KERN_INFO "%s: BH: Socket disconnected, dropping\n",
4208                                                 card->devname);
4209                                 dev_kfree_skb_any(skb);
4210                                 x25api_bh_cleanup(dev);
4211                                 ++chan->ifstats.rx_dropped;
4212                                 ++chan->rx_intr_stat.rx_intr_bfr_not_passed_to_stack;
4213                                 continue;
4214                         }
4215
4216
4217                         if (chan->common.func(skb,dev,chan->common.sk) != 0){
4218                                 /* Sock full cannot send, queue us for another
4219                                  * try
4220                                  */
4221                                 printk(KERN_INFO "%s: BH: !!! Packet failed to send !!!!! \n",
4222                                                 card->devname);
4223                                 atomic_set(&chan->common.receive_block,1);
4224                                 return;
4225                         }else{
4226                                 x25api_bh_cleanup(dev);
4227                                 ++chan->rx_intr_stat.rx_intr_bfr_passed_to_stack;
4228                         }
4229                 }
4230         }
4231         clear_bit(0, &chan->tq_working);
4232
4233         return;
4234 }
4235
4236 /*===============================================================
4237  * x25api_bh_cleanup
4238  *
4239  *
4240  *==============================================================*/
4241
4242 static int x25api_bh_cleanup(struct net_device *dev)
4243 {
4244         x25_channel_t* chan = dev->priv;
4245         sdla_t *card = chan->card;
4246         TX25Status* status = card->flags;
4247
4248
4249         ((bh_data_t *)&chan->bh_head[chan->bh_read])->skb = NULL;
4250
4251         if (chan->bh_read == MAX_BH_BUFF){
4252                 chan->bh_read=0;
4253         }else{
4254                 ++chan->bh_read;
4255         }
4256
4257         /* If the Receive interrupt was off, it means
4258          * that we filled up our circular buffer. Check
4259          * that we have space in the buffer. If so
4260          * turn the RX interrupt back on.
4261          */
4262         if (!(status->imask & INTR_ON_RX_FRAME)){
4263                 if (atomic_read(&chan->bh_buff_used) < (MAX_BH_BUFF+1)){
4264                         printk(KERN_INFO "%s: BH: Turning on the interrupt\n",
4265                                         card->devname);
4266                         status->imask |= INTR_ON_RX_FRAME;
4267                 }
4268         }
4269
4270         atomic_dec(&chan->bh_buff_used);
4271         return 0;
4272 }
4273
4274
4275 /*===============================================================
4276  * bh_enqueue
4277  *
4278  *
4279  *==============================================================*/
4280
4281 static int bh_enqueue(struct net_device *dev, struct sk_buff *skb)
4282 {
4283         x25_channel_t* chan = dev->priv;
4284         sdla_t *card = chan->card;
4285         TX25Status* status = card->flags;
4286
4287         if (atomic_read(&chan->bh_buff_used) == (MAX_BH_BUFF+1)){
4288                 printk(KERN_INFO "%s: Bottom half buffer FULL\n",
4289                                 card->devname);
4290                 return 1;
4291         }
4292
4293         ((bh_data_t *)&chan->bh_head[chan->bh_write])->skb = skb;
4294
4295         if (chan->bh_write == MAX_BH_BUFF){
4296                 chan->bh_write=0;
4297         }else{
4298                 ++chan->bh_write;
4299         }
4300
4301         atomic_inc(&chan->bh_buff_used);
4302
4303         if (atomic_read(&chan->bh_buff_used) == (MAX_BH_BUFF+1)){
4304                 printk(KERN_INFO "%s: Buffer is now full, Turning off RX Intr\n",
4305                                 card->devname);
4306                 status->imask &= ~INTR_ON_RX_FRAME;
4307         }
4308
4309         return 0;
4310 }
4311
4312
4313 /*===============================================================
4314  * timer_intr_cmd_exec
4315  *
4316  *      Called by timer interrupt to execute a command
4317  *===============================================================*/
4318
4319 static int timer_intr_cmd_exec (sdla_t* card)
4320 {
4321         struct net_device *dev;
4322         unsigned char more_to_exec=0;
4323         volatile x25_channel_t *chan=NULL;
4324         int i=0,bad_cmd=0,err=0;
4325
4326         if (card->u.x.cmd_dev == NULL){
4327                 card->u.x.cmd_dev = card->wandev.dev;
4328         }
4329
4330         dev = card->u.x.cmd_dev;
4331
4332         for (;;){
4333
4334                 chan = dev->priv;
4335
4336                 if (atomic_read(&chan->common.command)){
4337
4338                         bad_cmd = check_bad_command(card,dev);
4339
4340                         if ((!chan->common.mbox || atomic_read(&chan->common.disconnect)) &&
4341                              !bad_cmd){
4342
4343                                 /* Socket has died or exited, We must bring the
4344                                  * channel down before anybody else tries to
4345                                  * use it */
4346                                 err = channel_disconnect(card,dev);
4347                         }else{
4348                                 err = execute_delayed_cmd(card, dev,
4349                                                          (mbox_cmd_t*)chan->common.mbox,
4350                                                           bad_cmd);
4351                         }
4352
4353                         switch (err){
4354
4355                         case RETURN_RESULT:
4356
4357                                 /* Return the result to the socket without
4358                                  * delay. NO_WAIT Command */
4359                                 atomic_set(&chan->common.command,0);
4360                                 if (atomic_read(&card->u.x.command_busy))
4361                                         atomic_set(&card->u.x.command_busy,0);
4362
4363                                 send_delayed_cmd_result(card,dev,card->mbox);
4364
4365                                 more_to_exec=0;
4366                                 break;
4367                         case DELAY_RESULT:
4368
4369                                 /* Wait for the remote to respond, before
4370                                  * sending the result up to the socket.
4371                                  * WAIT command */
4372                                 if (atomic_read(&card->u.x.command_busy))
4373                                         atomic_set(&card->u.x.command_busy,0);
4374
4375                                 atomic_set(&chan->common.command,0);
4376                                 more_to_exec=0;
4377                                 break;
4378                         default:
4379
4380                                 /* If command could not be executed for
4381                                  * some reason (i.e return code 0x33 busy)
4382                                  * set the more_to_exec bit which will
4383                                  * indicate that this command must be exectued
4384                                  * again during next timer interrupt
4385                                  */
4386                                 more_to_exec=1;
4387                                 if (atomic_read(&card->u.x.command_busy) == 0)
4388                                         atomic_set(&card->u.x.command_busy,1);
4389                                 break;
4390                         }
4391
4392                         bad_cmd=0;
4393
4394                         /* If flags is set, there are no hdlc buffers,
4395                          * thus, wait for the next pass and try the
4396                          * same command again. Otherwise, start searching
4397                          * from next device on the next pass.
4398                          */
4399                         if (!more_to_exec){
4400                                 dev = move_dev_to_next(card,dev);
4401                         }
4402                         break;
4403                 }else{
4404                         /* This device has nothing to execute,
4405                          * go to next.
4406                          */
4407                         if (atomic_read(&card->u.x.command_busy))
4408                                         atomic_set(&card->u.x.command_busy,0);
4409                         dev = move_dev_to_next(card,dev);
4410                 }
4411
4412                 if (++i == card->u.x.no_dev){
4413                         if (!more_to_exec){
4414                                 DBG_PRINTK(KERN_INFO "%s: Nothing to execute in Timer\n",
4415                                         card->devname);
4416                                 if (atomic_read(&card->u.x.command_busy)){
4417                                         atomic_set(&card->u.x.command_busy,0);
4418                                 }
4419                         }
4420                         break;
4421                 }
4422
4423         } //End of FOR
4424
4425         card->u.x.cmd_dev = dev;
4426
4427         if (more_to_exec){
4428                 /* If more commands are pending, do not turn off timer
4429                  * interrupt */
4430                 return 1;
4431         }else{
4432                 /* No more commands, turn off timer interrupt */
4433                 return 0;
4434         }
4435 }
4436
4437 /*===============================================================
4438  * execute_delayed_cmd
4439  *
4440  *      Execute an API command which was passed down from the
4441  *      sock.  Sock is very limited in which commands it can
4442  *      execute.  Wait and No Wait commands are supported.
4443  *      Place Call, Clear Call and Reset wait commands, where
4444  *      Accept Call is a no_wait command.
4445  *
4446  *===============================================================*/
4447
4448 static int execute_delayed_cmd(sdla_t* card, struct net_device *dev,
4449                                mbox_cmd_t *usr_cmd, char bad_cmd)
4450 {
4451         TX25Mbox* mbox = card->mbox;
4452         int err;
4453         x25_channel_t *chan = dev->priv;
4454         int delay=RETURN_RESULT;
4455
4456         if (!(*card->u.x.hdlc_buf_status & 0x40) && !bad_cmd){
4457                 return TRY_CMD_AGAIN;
4458         }
4459
4460         /* This way a command is guaranteed to be executed for
4461          * a specific lcn, the network interface is bound to. */
4462         usr_cmd->cmd.lcn = chan->common.lcn;
4463
4464
4465         /* If channel is pvc, instead of place call
4466          * run x25_channel configuration. If running LAPB HDLC
4467          * enable communications.
4468          */
4469         if ((!chan->common.svc) && (usr_cmd->cmd.command == X25_PLACE_CALL)){
4470
4471                 if (card->u.x.LAPB_hdlc){
4472                         DBG_PRINTK(KERN_INFO "LAPB: Connecting\n");
4473                         connect(card);
4474                         set_chan_state(dev,WAN_CONNECTING);
4475                         return DELAY_RESULT;
4476                 }else{
4477                         DBG_PRINTK(KERN_INFO "%s: PVC is CONNECTING\n",card->devname);
4478                         if (x25_get_chan_conf(card, chan) == CMD_OK){
4479                                 set_chan_state(dev, WAN_CONNECTED);
4480                         }else{
4481                                 set_chan_state(dev, WAN_DISCONNECTED);
4482                         }
4483                         return RETURN_RESULT;
4484                 }
4485         }
4486
4487         /* Copy the socket mbox command onto the board */
4488
4489         memcpy(&mbox->cmd, &usr_cmd->cmd, sizeof(TX25Cmd));
4490         if (usr_cmd->cmd.length){
4491                 memcpy(mbox->data, usr_cmd->data, usr_cmd->cmd.length);
4492         }
4493
4494         /* Check if command is bad. We need to copy the cmd into
4495          * the buffer regardless since we return the, mbox to
4496          * the user */
4497         if (bad_cmd){
4498                 mbox->cmd.result=0x01;
4499                 return RETURN_RESULT;
4500         }
4501
4502         err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4503
4504         if (err != CMD_OK && err != X25RES_NOT_READY)
4505                 x25_error(card, err, usr_cmd->cmd.command, usr_cmd->cmd.lcn);
4506
4507         if (mbox->cmd.result == X25RES_NOT_READY){
4508                 return TRY_CMD_AGAIN;
4509         }
4510
4511         switch (mbox->cmd.command){
4512
4513         case X25_PLACE_CALL:
4514
4515                 switch (mbox->cmd.result){
4516
4517                 case CMD_OK:
4518
4519                         /* Check if Place call is a wait command or a
4520                          * no wait command */
4521                         if (atomic_read(&chan->common.command) & 0x80)
4522                                 delay=RETURN_RESULT;
4523                         else
4524                                 delay=DELAY_RESULT;
4525
4526
4527                         DBG_PRINTK(KERN_INFO "\n%s: PLACE CALL Binding dev %s to lcn %i\n",
4528                                         card->devname,dev->name, mbox->cmd.lcn);
4529
4530                         bind_lcn_to_dev (card, dev, mbox->cmd.lcn);
4531                         set_chan_state(dev, WAN_CONNECTING);
4532                         break;
4533
4534
4535                 default:
4536                         delay=RETURN_RESULT;
4537                         set_chan_state(dev, WAN_DISCONNECTED);
4538                         break;
4539                 }
4540                 break;
4541
4542         case X25_ACCEPT_CALL:
4543
4544                 switch (mbox->cmd.result){
4545
4546                 case CMD_OK:
4547
4548                         DBG_PRINTK(KERN_INFO "\n%s: ACCEPT Binding dev %s to lcn %i\n",
4549                                 card->devname,dev->name,mbox->cmd.lcn);
4550
4551                         bind_lcn_to_dev (card, dev, mbox->cmd.lcn);
4552
4553                         if (x25_get_chan_conf(card, chan) == CMD_OK){
4554
4555                                 set_chan_state(dev, WAN_CONNECTED);
4556                                 delay=RETURN_RESULT;
4557
4558                         }else{
4559                                 if (x25_clear_call(card, usr_cmd->cmd.lcn, 0, 0) == CMD_OK){
4560                                         /* if clear is successful, wait for clear confirm
4561                                          */
4562                                         delay=DELAY_RESULT;
4563                                 }else{
4564                                         /* Do not change the state here. If we fail
4565                                          * the accept the return code is send up
4566                                          *the stack, which will ether retry
4567                                          * or clear the call
4568                                          */
4569                                         DBG_PRINTK(KERN_INFO
4570                                                 "%s: ACCEPT: STATE MAY BE CURRUPTED 2 !!!!!\n",
4571                                                 card->devname);
4572                                         delay=RETURN_RESULT;
4573                                 }
4574                         }
4575                         break;
4576
4577
4578                 case X25RES_ASYNC_PACKET:
4579                         delay=TRY_CMD_AGAIN;
4580                         break;
4581
4582                 default:
4583                         DBG_PRINTK(KERN_INFO "%s: ACCEPT FAILED\n",card->devname);
4584                         if (x25_clear_call(card, usr_cmd->cmd.lcn, 0, 0) == CMD_OK){
4585                                 delay=DELAY_RESULT;
4586                         }else{
4587                                 /* Do not change the state here. If we fail the accept. The
4588                                  * return code is send up the stack, which will ether retry
4589                                  * or clear the call */
4590                                 DBG_PRINTK(KERN_INFO
4591                                         "%s: ACCEPT: STATE MAY BE CORRUPTED 1 !!!!!\n",
4592                                                 card->devname);
4593                                 delay=RETURN_RESULT;
4594                         }
4595                 }
4596                 break;
4597
4598         case X25_CLEAR_CALL:
4599
4600                 switch (mbox->cmd.result){
4601
4602                 case CMD_OK:
4603                         DBG_PRINTK(KERN_INFO
4604                                         "CALL CLEAR OK: Dev %s Mbox Lcn %i  Chan Lcn %i\n",
4605                                         dev->name,mbox->cmd.lcn,chan->common.lcn);
4606                         set_chan_state(dev, WAN_DISCONNECTING);
4607                         delay = DELAY_RESULT;
4608                         break;
4609
4610                 case X25RES_CHANNEL_IN_USE:
4611                 case X25RES_ASYNC_PACKET:
4612                         delay = TRY_CMD_AGAIN;
4613                         break;
4614
4615                 case X25RES_LINK_NOT_IN_ABM:
4616                 case X25RES_INVAL_LCN:
4617                 case X25RES_INVAL_STATE:
4618                         set_chan_state(dev, WAN_DISCONNECTED);
4619                         delay = RETURN_RESULT;
4620                         break;
4621
4622                 default:
4623                         /* If command did not execute because of user
4624                          * fault, do not change the state. This will
4625                          * signal the socket that clear command failed.
4626                          * User can retry or close the socket.
4627                          * When socket gets killed, it will set the
4628                          * chan->disconnect which will signal
4629                          * driver to clear the call */
4630                         printk(KERN_INFO "%s: Clear Command Failed, Rc %x\n",
4631                                 card->devname,mbox->cmd.command);
4632                         delay = RETURN_RESULT;
4633                 }
4634                 break;
4635         }
4636
4637         return delay;
4638 }
4639
4640 /*===============================================================
4641  * api_incoming_call
4642  *
4643  *      Pass an incoming call request up the listening
4644  *      sock.  If the API sock is not listening reject the
4645  *      call.
4646  *
4647  *===============================================================*/
4648
4649 static int api_incoming_call (sdla_t* card, TX25Mbox *mbox, int lcn)
4650 {
4651         struct sk_buff *skb;
4652         int len = sizeof(TX25Cmd)+mbox->cmd.length;
4653
4654         if (alloc_and_init_skb_buf(card, &skb, len)){
4655                 printk(KERN_INFO "%s: API incoming call, no memory\n",card->devname);
4656                 return 1;
4657         }
4658
4659         memcpy(skb_put(skb,len),&mbox->cmd,len);
4660
4661         skb->mac.raw = skb->data;
4662         skb->protocol = htons(X25_PROT);
4663         skb->pkt_type = WAN_PACKET_ASYNC;
4664
4665         if (card->func(skb,card->sk) < 0){
4666                 printk(KERN_INFO "%s: MAJOR ERROR: Failed to send up place call \n",card->devname);
4667                 dev_kfree_skb_any(skb);
4668                 return 1;
4669         }
4670
4671         return 0;
4672 }
4673
4674 /*===============================================================
4675  * send_delayed_cmd_result
4676  *
4677  *      Wait commands like PLEACE CALL or CLEAR CALL must wait
4678  *      until the result arrives. This function passes
4679  *      the result to a waiting sock.
4680  *
4681  *===============================================================*/
4682 static void send_delayed_cmd_result(sdla_t *card, struct net_device *dev,
4683                                     TX25Mbox* mbox)
4684 {
4685         x25_channel_t *chan = dev->priv;
4686         mbox_cmd_t *usr_cmd = (mbox_cmd_t *)chan->common.mbox;
4687         struct sk_buff *skb;
4688         int len=sizeof(unsigned char);
4689
4690         atomic_set(&chan->common.command,0);
4691
4692         /* If the sock is in the process of unlinking the
4693          * driver from the socket, we must get out.
4694          * This never happends but is a sanity check. */
4695         if (test_bit(0,&chan->common.common_critical)){
4696                 return;
4697         }
4698
4699         if (!usr_cmd || !chan->common.sk || !chan->common.func){
4700                 DBG_PRINTK(KERN_INFO "Delay result: Sock not bounded sk: %u, func: %u, mbox: %u\n",
4701                         (unsigned int)chan->common.sk,
4702                         (unsigned int)chan->common.func,
4703                         (unsigned int)usr_cmd);
4704                 return;
4705         }
4706
4707         memcpy(&usr_cmd->cmd, &mbox->cmd, sizeof(TX25Cmd));
4708         if (mbox->cmd.length > 0){
4709                 memcpy(usr_cmd->data, mbox->data, mbox->cmd.length);
4710         }
4711
4712         if (alloc_and_init_skb_buf(card,&skb,len)){
4713                 printk(KERN_INFO "Delay result: No sock buffers\n");
4714                 return;
4715         }
4716
4717         memcpy(skb_put(skb,len),&mbox->cmd.command,len);
4718
4719         skb->mac.raw = skb->data;
4720         skb->pkt_type = WAN_PACKET_CMD;
4721
4722         chan->common.func(skb,dev,chan->common.sk);
4723 }
4724
4725 /*===============================================================
4726  * clear_confirm_event
4727  *
4728  *      Pass the clear confirmation event up the sock. The
4729  *      API will disconnect only after the clear confirmation
4730  *      has been received.
4731  *
4732  *      Depending on the state, clear confirmation could
4733  *      be an OOB event, or a result of an API command.
4734  *===============================================================*/
4735
4736 static int clear_confirm_event (sdla_t *card, TX25Mbox* mb)
4737 {
4738         struct net_device *dev;
4739         x25_channel_t *chan;
4740         unsigned char old_state;
4741
4742         dev = find_channel(card,mb->cmd.lcn);
4743         if (!dev){
4744                 DBG_PRINTK(KERN_INFO "%s: *** GOT CLEAR BUT NO DEV %i\n",
4745                                 card->devname,mb->cmd.lcn);
4746                 return 0;
4747         }
4748
4749         chan=dev->priv;
4750         DBG_PRINTK(KERN_INFO "%s: GOT CLEAR CONFIRM %s:  Mbox lcn %i  Chan lcn %i\n",
4751                         card->devname, dev->name, mb->cmd.lcn, chan->common.lcn);
4752
4753         /* If not API fall through to default.
4754          * If API, send the result to a waiting
4755          * socket.
4756          */
4757
4758         old_state = chan->common.state;
4759         set_chan_state(dev, WAN_DISCONNECTED);
4760
4761         if (chan->common.usedby == API){
4762                 switch (old_state) {
4763
4764                 case WAN_DISCONNECTING:
4765                 case WAN_CONNECTING:
4766                         send_delayed_cmd_result(card,dev,mb);
4767                         break;
4768                 case WAN_CONNECTED:
4769                         send_oob_msg(card,dev,mb);
4770                         break;
4771                 }
4772                 return 1;
4773         }
4774
4775         return 0;
4776 }
4777
4778 /*===============================================================
4779  * send_oob_msg
4780  *
4781  *    Construct an NEM Message and pass it up the connected
4782  *    sock. If the sock is not bounded discard the NEM.
4783  *
4784  *===============================================================*/
4785
4786 static void send_oob_msg(sdla_t *card, struct net_device *dev, TX25Mbox *mbox)
4787 {
4788         x25_channel_t *chan = dev->priv;
4789         mbox_cmd_t *usr_cmd = (mbox_cmd_t *)chan->common.mbox;
4790         struct sk_buff *skb;
4791         int len=sizeof(x25api_hdr_t)+mbox->cmd.length;
4792         x25api_t *api_hdr;
4793
4794         /* If the sock is in the process of unlinking the
4795          * driver from the socket, we must get out.
4796          * This never happends but is a sanity check. */
4797         if (test_bit(0,&chan->common.common_critical)){
4798                 return;
4799         }
4800
4801         if (!usr_cmd || !chan->common.sk || !chan->common.func){
4802                 DBG_PRINTK(KERN_INFO "OOB MSG: Sock not bounded\n");
4803                 return;
4804         }
4805
4806         memcpy(&usr_cmd->cmd, &mbox->cmd, sizeof(TX25Cmd));
4807         if (mbox->cmd.length > 0){
4808                 memcpy(usr_cmd->data, mbox->data, mbox->cmd.length);
4809         }
4810
4811         if (alloc_and_init_skb_buf(card,&skb,len)){
4812                 printk(KERN_INFO "%s: OOB MSG: No sock buffers\n",card->devname);
4813                 return;
4814         }
4815
4816         api_hdr = (x25api_t*)skb_put(skb,len);
4817         api_hdr->hdr.pktType = mbox->cmd.pktType & 0x7F;
4818         api_hdr->hdr.qdm     = mbox->cmd.qdm;
4819         api_hdr->hdr.cause   = mbox->cmd.cause;
4820         api_hdr->hdr.diagn   = mbox->cmd.diagn;
4821         api_hdr->hdr.length  = mbox->cmd.length;
4822         api_hdr->hdr.result  = mbox->cmd.result;
4823         api_hdr->hdr.lcn     = mbox->cmd.lcn;
4824
4825         if (mbox->cmd.length > 0){
4826                 memcpy(api_hdr->data,mbox->data,mbox->cmd.length);
4827         }
4828
4829         skb->mac.raw = skb->data;
4830         skb->pkt_type = WAN_PACKET_ERR;
4831
4832         if (chan->common.func(skb,dev,chan->common.sk) < 0){
4833                 if (bh_enqueue(dev,skb)){
4834                         printk(KERN_INFO "%s: Dropping OOB MSG\n",card->devname);
4835                         dev_kfree_skb_any(skb);
4836                 }
4837         }
4838
4839         DBG_PRINTK(KERN_INFO "%s: OOB MSG OK, %s, lcn %i\n",
4840                         card->devname, dev->name, mbox->cmd.lcn);
4841 }
4842
4843 /*===============================================================
4844  *  alloc_and_init_skb_buf
4845  *
4846  *      Allocate and initialize an skb buffer.
4847  *
4848  *===============================================================*/
4849
4850 static int alloc_and_init_skb_buf (sdla_t *card, struct sk_buff **skb, int len)
4851 {
4852         struct sk_buff *new_skb = *skb;
4853
4854         new_skb = dev_alloc_skb(len + X25_HRDHDR_SZ);
4855         if (new_skb == NULL){
4856                 printk(KERN_INFO "%s: no socket buffers available!\n",
4857                         card->devname);
4858                 return 1;
4859         }
4860
4861         if (skb_tailroom(new_skb) < len){
4862                 /* No room for the packet. Call off the whole thing! */
4863                 dev_kfree_skb_any(new_skb);
4864                 printk(KERN_INFO "%s: Listen: unexpectedly long packet sequence\n"
4865                         ,card->devname);
4866                 *skb = NULL;
4867                 return 1;
4868         }
4869
4870         *skb = new_skb;
4871         return 0;
4872
4873 }
4874
4875 /*===============================================================
4876  *  api_oob_event
4877  *
4878  *      Send an OOB event up to the sock
4879  *
4880  *===============================================================*/
4881
4882 static void api_oob_event (sdla_t *card,TX25Mbox *mbox)
4883 {
4884         struct net_device *dev = find_channel(card, mbox->cmd.lcn);
4885         x25_channel_t *chan;
4886
4887         if (!dev)
4888                 return;
4889
4890         chan=dev->priv;
4891
4892         if (chan->common.usedby == API)
4893                 send_oob_msg(card,dev,mbox);
4894
4895 }
4896
4897
4898
4899
4900 static int channel_disconnect(sdla_t* card, struct net_device *dev)
4901 {
4902
4903         int err;
4904         x25_channel_t *chan = dev->priv;
4905
4906         DBG_PRINTK(KERN_INFO "%s: TIMER: %s, Device down disconnecting\n",
4907                                 card->devname,dev->name);
4908
4909         if (chan->common.svc){
4910                 err = x25_clear_call(card,chan->common.lcn,0,0);
4911         }else{
4912                 /* If channel is PVC or LAPB HDLC, there is no call
4913                  * to be cleared, thus drop down to the default
4914                  * area
4915                  */
4916                 err = 1;
4917         }
4918
4919         switch (err){
4920
4921                 case X25RES_CHANNEL_IN_USE:
4922                 case X25RES_NOT_READY:
4923                         err = TRY_CMD_AGAIN;
4924                         break;
4925                 case CMD_OK:
4926                         DBG_PRINTK(KERN_INFO "CALL CLEAR OK: Dev %s Chan Lcn %i\n",
4927                                                 dev->name,chan->common.lcn);
4928
4929                         set_chan_state(dev,WAN_DISCONNECTING);
4930                         atomic_set(&chan->common.command,0);
4931                         err = DELAY_RESULT;
4932                         break;
4933                 default:
4934                         /* If LAPB HDLC protocol, bring the whole link down
4935                          * once the application terminates
4936                          */
4937
4938                         set_chan_state(dev,WAN_DISCONNECTED);
4939
4940                         if (card->u.x.LAPB_hdlc){
4941                                 DBG_PRINTK(KERN_INFO "LAPB: Disconnecting Link\n");
4942                                 hdlc_link_down (card);
4943                         }
4944                         atomic_set(&chan->common.command,0);
4945                         err = RETURN_RESULT;
4946                         break;
4947         }
4948
4949         return err;
4950 }
4951
4952 static void hdlc_link_down (sdla_t *card)
4953 {
4954         TX25Mbox* mbox = card->mbox;
4955         int retry = 5;
4956         int err=0;
4957
4958         do {
4959                 memset(mbox,0,sizeof(TX25Mbox));
4960                 mbox->cmd.command = X25_HDLC_LINK_DISC;
4961                 mbox->cmd.length = 1;
4962                 mbox->data[0]=0;
4963                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4964
4965         } while (err && retry-- && x25_error(card, err, X25_HDLC_LINK_DISC, 0));
4966
4967         if (err)
4968                 printk(KERN_INFO "%s: Hdlc Link Down Failed %x\n",card->devname,err);
4969
4970         disconnect (card);
4971
4972 }
4973
4974 static int check_bad_command(sdla_t* card, struct net_device *dev)
4975 {
4976         x25_channel_t *chan = dev->priv;
4977         int bad_cmd = 0;
4978
4979         switch (atomic_read(&chan->common.command)&0x7F){
4980
4981                 case X25_PLACE_CALL:
4982                         if (chan->common.state != WAN_DISCONNECTED)
4983                                 bad_cmd=1;
4984                         break;
4985                 case X25_CLEAR_CALL:
4986                         if (chan->common.state == WAN_DISCONNECTED)
4987                                 bad_cmd=1;
4988                         break;
4989                 case X25_ACCEPT_CALL:
4990                         if (chan->common.state != WAN_CONNECTING)
4991                                 bad_cmd=1;
4992                         break;
4993                 case X25_RESET:
4994                         if (chan->common.state != WAN_CONNECTED)
4995                                 bad_cmd=1;
4996                         break;
4997                 default:
4998                         bad_cmd=1;
4999                         break;
5000         }
5001
5002         if (bad_cmd){
5003                 printk(KERN_INFO "%s: Invalid State, BAD Command %x, dev %s, lcn %i, st %i\n",
5004                         card->devname,atomic_read(&chan->common.command),dev->name,
5005                         chan->common.lcn, chan->common.state);
5006         }
5007
5008         return bad_cmd;
5009 }
5010
5011
5012
5013 /*************************** XPIPEMON FUNCTIONS **************************/
5014
5015 /*==============================================================================
5016  * Process UDP call of type XPIPE
5017  */
5018
5019 static int process_udp_mgmt_pkt(sdla_t *card)
5020 {
5021         int            c_retry = MAX_CMD_RETRY;
5022         unsigned int   len;
5023         struct sk_buff *new_skb;
5024         TX25Mbox       *mbox = card->mbox;
5025         int            err;
5026         int            udp_mgmt_req_valid = 1;
5027         struct net_device *dev;
5028         x25_channel_t  *chan;
5029         unsigned short lcn;
5030         struct timeval tv;
5031
5032
5033         x25_udp_pkt_t *x25_udp_pkt;
5034         x25_udp_pkt = (x25_udp_pkt_t *)card->u.x.udp_pkt_data;
5035
5036         dev = card->u.x.udp_dev;
5037         chan = dev->priv;
5038         lcn = chan->common.lcn;
5039
5040         switch(x25_udp_pkt->cblock.command) {
5041
5042                 /* XPIPE_ENABLE_TRACE */
5043                 case XPIPE_ENABLE_TRACING:
5044
5045                 /* XPIPE_GET_TRACE_INFO */
5046                 case XPIPE_GET_TRACE_INFO:
5047
5048                 /* SET FT1 MODE */
5049                 case XPIPE_SET_FT1_MODE:
5050
5051                         if(card->u.x.udp_pkt_src == UDP_PKT_FRM_NETWORK) {
5052                                 ++chan->pipe_mgmt_stat.UDP_PIPE_mgmt_direction_err;
5053                                 udp_mgmt_req_valid = 0;
5054                                 break;
5055                         }
5056
5057                 /* XPIPE_FT1_READ_STATUS */
5058                 case XPIPE_FT1_READ_STATUS:
5059
5060                 /* FT1 MONITOR STATUS */
5061                 case XPIPE_FT1_STATUS_CTRL:
5062                         if(card->hw.fwid !=  SFID_X25_508) {
5063                                 ++chan->pipe_mgmt_stat.UDP_PIPE_mgmt_adptr_type_err;
5064                                 udp_mgmt_req_valid = 0;
5065                                 break;
5066                         }
5067                 default:
5068                         break;
5069         }
5070
5071         if(!udp_mgmt_req_valid) {
5072                 /* set length to 0 */
5073                 x25_udp_pkt->cblock.length = 0;
5074                 /* set return code */
5075                 x25_udp_pkt->cblock.result = (card->hw.fwid != SFID_X25_508) ? 0x1F : 0xCD;
5076
5077         } else {
5078
5079                 switch (x25_udp_pkt->cblock.command) {
5080
5081
5082                 case XPIPE_FLUSH_DRIVER_STATS:
5083                         init_x25_channel_struct(chan);
5084                         init_global_statistics(card);
5085                         mbox->cmd.length = 0;
5086                         break;
5087
5088
5089                 case XPIPE_DRIVER_STAT_IFSEND:
5090                         memcpy(x25_udp_pkt->data, &chan->if_send_stat, sizeof(if_send_stat_t));
5091                         mbox->cmd.length = sizeof(if_send_stat_t);
5092                         x25_udp_pkt->cblock.length =  mbox->cmd.length;
5093                         break;
5094
5095                 case XPIPE_DRIVER_STAT_INTR:
5096                         memcpy(&x25_udp_pkt->data[0], &card->statistics, sizeof(global_stats_t));
5097                         memcpy(&x25_udp_pkt->data[sizeof(global_stats_t)],
5098                                 &chan->rx_intr_stat, sizeof(rx_intr_stat_t));
5099
5100                         mbox->cmd.length = sizeof(global_stats_t) +
5101                                         sizeof(rx_intr_stat_t);
5102                         x25_udp_pkt->cblock.length =  mbox->cmd.length;
5103                         break;
5104
5105                 case XPIPE_DRIVER_STAT_GEN:
5106                         memcpy(x25_udp_pkt->data,
5107                                 &chan->pipe_mgmt_stat.UDP_PIPE_mgmt_kmalloc_err,
5108                                 sizeof(pipe_mgmt_stat_t));
5109
5110                         memcpy(&x25_udp_pkt->data[sizeof(pipe_mgmt_stat_t)],
5111                                &card->statistics, sizeof(global_stats_t));
5112
5113                         x25_udp_pkt->cblock.result = 0;
5114                         x25_udp_pkt->cblock.length = sizeof(global_stats_t)+
5115                                                      sizeof(rx_intr_stat_t);
5116                         mbox->cmd.length = x25_udp_pkt->cblock.length;
5117                         break;
5118
5119                 case XPIPE_ROUTER_UP_TIME:
5120                         do_gettimeofday(&tv);
5121                         chan->router_up_time = tv.tv_sec - chan->router_start_time;
5122                         *(unsigned long *)&x25_udp_pkt->data = chan->router_up_time;
5123                         x25_udp_pkt->cblock.length = mbox->cmd.length = 4;
5124                         x25_udp_pkt->cblock.result = 0;
5125                         break;
5126
5127                 default :
5128
5129                         do {
5130                                 memcpy(&mbox->cmd, &x25_udp_pkt->cblock.command, sizeof(TX25Cmd));
5131                                 if(mbox->cmd.length){
5132                                         memcpy(&mbox->data,
5133                                                (char *)x25_udp_pkt->data,
5134                                                mbox->cmd.length);
5135                                 }
5136
5137                                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
5138                         } while (err && c_retry-- && x25_error(card, err, mbox->cmd.command, 0));
5139
5140
5141                         if ( err == CMD_OK ||
5142                             (err == 1 &&
5143                              (mbox->cmd.command == 0x06 ||
5144                               mbox->cmd.command == 0x16)  ) ){
5145
5146                                 ++chan->pipe_mgmt_stat.UDP_PIPE_mgmt_adptr_cmnd_OK;
5147                         } else {
5148                                 ++chan->pipe_mgmt_stat.UDP_PIPE_mgmt_adptr_cmnd_timeout;
5149                         }
5150
5151                           /* copy the result back to our buffer */
5152                         memcpy(&x25_udp_pkt->cblock.command, &mbox->cmd, sizeof(TX25Cmd));
5153
5154                         if(mbox->cmd.length) {
5155                                memcpy(&x25_udp_pkt->data, &mbox->data, mbox->cmd.length);
5156                         }
5157                         break;
5158
5159                 } //switch
5160
5161         }
5162
5163         /* Fill UDP TTL */
5164
5165         x25_udp_pkt->ip_pkt.ttl = card->wandev.ttl;
5166         len = reply_udp(card->u.x.udp_pkt_data, mbox->cmd.length);
5167
5168
5169         if(card->u.x.udp_pkt_src == UDP_PKT_FRM_NETWORK) {
5170
5171                 err = x25_send(card, lcn, 0, len, card->u.x.udp_pkt_data);
5172                 if (!err)
5173                         ++chan->pipe_mgmt_stat.UDP_PIPE_mgmt_adptr_send_passed;
5174                 else
5175                         ++chan->pipe_mgmt_stat.UDP_PIPE_mgmt_adptr_send_failed;
5176
5177         } else {
5178
5179                 /* Allocate socket buffer */
5180                 if((new_skb = dev_alloc_skb(len)) != NULL) {
5181                         void *buf;
5182
5183                         /* copy data into new_skb */
5184                         buf = skb_put(new_skb, len);
5185                         memcpy(buf, card->u.x.udp_pkt_data, len);
5186
5187                         /* Decapsulate packet and pass it up the protocol
5188                            stack */
5189                         new_skb->dev = dev;
5190
5191                         if (chan->common.usedby == API)
5192                                 new_skb->protocol = htons(X25_PROT);
5193                         else
5194                                 new_skb->protocol = htons(ETH_P_IP);
5195
5196                         new_skb->mac.raw = new_skb->data;
5197
5198                         netif_rx(new_skb);
5199                         ++chan->pipe_mgmt_stat.UDP_PIPE_mgmt_passed_to_stack;
5200
5201                 } else {
5202                         ++chan->pipe_mgmt_stat.UDP_PIPE_mgmt_no_socket;
5203                         printk(KERN_INFO
5204                         "%s: UDP mgmt cmnd, no socket buffers available!\n",
5205                         card->devname);
5206                 }
5207         }
5208
5209         card->u.x.udp_pkt_lgth = 0;
5210
5211         return 1;
5212 }
5213
5214
5215 /*==============================================================================
5216  * Determine what type of UDP call it is. DRVSTATS or XPIPE8ND ?
5217  */
5218 static int udp_pkt_type( struct sk_buff *skb, sdla_t* card )
5219 {
5220         x25_udp_pkt_t *x25_udp_pkt = (x25_udp_pkt_t *)skb->data;
5221
5222         if((x25_udp_pkt->ip_pkt.protocol == UDPMGMT_UDP_PROTOCOL) &&
5223                 (x25_udp_pkt->ip_pkt.ver_inet_hdr_length == 0x45) &&
5224                 (x25_udp_pkt->udp_pkt.udp_dst_port == ntohs(card->wandev.udp_port)) &&
5225                 (x25_udp_pkt->wp_mgmt.request_reply == UDPMGMT_REQUEST)) {
5226
5227                         if(!strncmp(x25_udp_pkt->wp_mgmt.signature,
5228                                 UDPMGMT_XPIPE_SIGNATURE, 8)){
5229                                 return UDP_XPIPE_TYPE;
5230                         }else{
5231                                 printk(KERN_INFO "%s: UDP Packet, Failed Signature !\n",
5232                                         card->devname);
5233                         }
5234         }
5235
5236         return UDP_INVALID_TYPE;
5237 }
5238
5239
5240 /*============================================================================
5241  * Reply to UDP Management system.
5242  * Return nothing.
5243  */
5244 static int reply_udp( unsigned char *data, unsigned int mbox_len )
5245 {
5246         unsigned short len, udp_length, temp, ip_length;
5247         unsigned long ip_temp;
5248         int even_bound = 0;
5249
5250
5251         x25_udp_pkt_t *x25_udp_pkt = (x25_udp_pkt_t *)data;
5252
5253         /* Set length of packet */
5254         len = sizeof(ip_pkt_t)+
5255               sizeof(udp_pkt_t)+
5256               sizeof(wp_mgmt_t)+
5257               sizeof(cblock_t)+
5258               mbox_len;
5259
5260
5261         /* fill in UDP reply */
5262         x25_udp_pkt->wp_mgmt.request_reply = UDPMGMT_REPLY;
5263
5264         /* fill in UDP length */
5265         udp_length = sizeof(udp_pkt_t)+
5266                      sizeof(wp_mgmt_t)+
5267                      sizeof(cblock_t)+
5268                      mbox_len;
5269
5270
5271         /* put it on an even boundary */
5272         if ( udp_length & 0x0001 ) {
5273                 udp_length += 1;
5274                 len += 1;
5275                 even_bound = 1;
5276         }
5277
5278         temp = (udp_length<<8)|(udp_length>>8);
5279         x25_udp_pkt->udp_pkt.udp_length = temp;
5280
5281         /* swap UDP ports */
5282         temp = x25_udp_pkt->udp_pkt.udp_src_port;
5283         x25_udp_pkt->udp_pkt.udp_src_port =
5284                         x25_udp_pkt->udp_pkt.udp_dst_port;
5285         x25_udp_pkt->udp_pkt.udp_dst_port = temp;
5286
5287
5288
5289         /* add UDP pseudo header */
5290         temp = 0x1100;
5291         *((unsigned short *)
5292                 (x25_udp_pkt->data+mbox_len+even_bound)) = temp;
5293         temp = (udp_length<<8)|(udp_length>>8);
5294         *((unsigned short *)
5295                 (x25_udp_pkt->data+mbox_len+even_bound+2)) = temp;
5296
5297         /* calculate UDP checksum */
5298         x25_udp_pkt->udp_pkt.udp_checksum = 0;
5299
5300         x25_udp_pkt->udp_pkt.udp_checksum =
5301                 calc_checksum(&data[UDP_OFFSET], udp_length+UDP_OFFSET);
5302
5303         /* fill in IP length */
5304         ip_length = len;
5305         temp = (ip_length<<8)|(ip_length>>8);
5306         x25_udp_pkt->ip_pkt.total_length = temp;
5307
5308         /* swap IP addresses */
5309         ip_temp = x25_udp_pkt->ip_pkt.ip_src_address;
5310         x25_udp_pkt->ip_pkt.ip_src_address =
5311                                 x25_udp_pkt->ip_pkt.ip_dst_address;
5312         x25_udp_pkt->ip_pkt.ip_dst_address = ip_temp;
5313
5314
5315         /* fill in IP checksum */
5316         x25_udp_pkt->ip_pkt.hdr_checksum = 0;
5317         x25_udp_pkt->ip_pkt.hdr_checksum = calc_checksum(data, sizeof(ip_pkt_t));
5318
5319         return len;
5320 } /* reply_udp */
5321
5322 unsigned short calc_checksum (char *data, int len)
5323 {
5324         unsigned short temp;
5325         unsigned long sum=0;
5326         int i;
5327
5328         for( i = 0; i <len; i+=2 ) {
5329                 memcpy(&temp,&data[i],2);
5330                 sum += (unsigned long)temp;
5331         }
5332
5333         while (sum >> 16 ) {
5334                 sum = (sum & 0xffffUL) + (sum >> 16);
5335         }
5336
5337         temp = (unsigned short)sum;
5338         temp = ~temp;
5339
5340         if( temp == 0 )
5341                 temp = 0xffff;
5342
5343         return temp;
5344 }
5345
5346 /*=============================================================================
5347  * Store a UDP management packet for later processing.
5348  */
5349
5350 static int store_udp_mgmt_pkt(int udp_type, char udp_pkt_src, sdla_t* card,
5351                               struct net_device *dev, struct sk_buff *skb,
5352                               int lcn)
5353 {
5354         int udp_pkt_stored = 0;
5355
5356         if(!card->u.x.udp_pkt_lgth && (skb->len <= MAX_LGTH_UDP_MGNT_PKT)){
5357                 card->u.x.udp_pkt_lgth = skb->len;
5358                 card->u.x.udp_type = udp_type;
5359                 card->u.x.udp_pkt_src = udp_pkt_src;
5360                 card->u.x.udp_lcn = lcn;
5361                 card->u.x.udp_dev = dev;
5362                 memcpy(card->u.x.udp_pkt_data, skb->data, skb->len);
5363                 card->u.x.timer_int_enabled |= TMR_INT_ENABLED_UDP_PKT;
5364                 udp_pkt_stored = 1;
5365
5366         }else{
5367                 printk(KERN_INFO "%s: ERROR: UDP packet not stored for LCN %d\n",
5368                                                         card->devname,lcn);
5369         }
5370
5371         if(udp_pkt_src == UDP_PKT_FRM_STACK){
5372                 dev_kfree_skb_any(skb);
5373         }else{
5374                 dev_kfree_skb_any(skb);
5375         }
5376
5377         return(udp_pkt_stored);
5378 }
5379
5380
5381
5382 /*=============================================================================
5383  * Initial the ppp_private_area structure.
5384  */
5385 static void init_x25_channel_struct( x25_channel_t *chan )
5386 {
5387         memset(&chan->if_send_stat.if_send_entry,0,sizeof(if_send_stat_t));
5388         memset(&chan->rx_intr_stat.rx_intr_no_socket,0,sizeof(rx_intr_stat_t));
5389         memset(&chan->pipe_mgmt_stat.UDP_PIPE_mgmt_kmalloc_err,0,sizeof(pipe_mgmt_stat_t));
5390 }
5391
5392 /*============================================================================
5393  * Initialize Global Statistics
5394  */
5395 static void init_global_statistics( sdla_t *card )
5396 {
5397         memset(&card->statistics.isr_entry,0,sizeof(global_stats_t));
5398 }
5399
5400
5401 /*===============================================================
5402  * SMP Support
5403  * ==============================================================*/
5404
5405 static void S508_S514_lock(sdla_t *card, unsigned long *smp_flags)
5406 {
5407         spin_lock_irqsave(&card->wandev.lock, *smp_flags);
5408 }
5409 static void S508_S514_unlock(sdla_t *card, unsigned long *smp_flags)
5410 {
5411         spin_unlock_irqrestore(&card->wandev.lock, *smp_flags);
5412 }
5413
5414 /*===============================================================
5415  * x25_timer_routine
5416  *
5417  *      A more efficient polling routine.  Each half a second
5418  *      queue a polling task. We want to do the polling in a
5419  *      task not timer, because timer runs in interrupt time.
5420  *
5421  *      FIXME Polling should be rethinked.
5422  *==============================================================*/
5423
5424 static void x25_timer_routine(unsigned long data)
5425 {
5426         sdla_t *card = (sdla_t*)data;
5427
5428         if (!card->wandev.dev){
5429                 printk(KERN_INFO "%s: Stopping the X25 Poll Timer: No Dev.\n",
5430                                 card->devname);
5431                 return;
5432         }
5433
5434         if (card->open_cnt != card->u.x.num_of_ch){
5435                 printk(KERN_INFO "%s: Stopping the X25 Poll Timer: Interface down.\n",
5436                                 card->devname);
5437                 return;
5438         }
5439
5440         if (test_bit(PERI_CRIT,&card->wandev.critical)){
5441                 printk(KERN_INFO "%s: Stopping the X25 Poll Timer: Shutting down.\n",
5442                                 card->devname);
5443                 return;
5444         }
5445
5446         if (!test_and_set_bit(POLL_CRIT,&card->wandev.critical)){
5447                 trigger_x25_poll(card);
5448         }
5449
5450         card->u.x.x25_timer.expires=jiffies+(HZ>>1);
5451         add_timer(&card->u.x.x25_timer);
5452         return;
5453 }
5454
5455 void disable_comm_shutdown(sdla_t *card)
5456 {
5457         TX25Mbox* mbox = card->mbox;
5458         int err;
5459
5460         /* Turn of interrutps */
5461         mbox->data[0] = 0;
5462         if (card->hw.fwid == SFID_X25_508){
5463                 mbox->data[1] = card->hw.irq;
5464                 mbox->data[2] = 2;
5465                 mbox->cmd.length = 3;
5466         }else {
5467                 mbox->cmd.length  = 1;
5468         }
5469         mbox->cmd.command = X25_SET_INTERRUPT_MODE;
5470         err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
5471         if (err)
5472                 printk(KERN_INFO "INTERRUPT OFF FAIED %x\n",err);
5473
5474         /* Bring down HDLC */
5475         mbox->cmd.command = X25_HDLC_LINK_CLOSE;
5476         mbox->cmd.length  = 0;
5477         err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
5478         if (err)
5479                 printk(KERN_INFO "LINK CLOSED FAILED %x\n",err);
5480
5481
5482         /* Brind down DTR */
5483         mbox->data[0] = 0;
5484         mbox->data[2] = 0;
5485         mbox->data[1] = 0x01;
5486         mbox->cmd.length  = 3;
5487         mbox->cmd.command = X25_SET_GLOBAL_VARS;
5488         err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
5489         if (err)
5490                 printk(KERN_INFO "DTR DOWN FAILED %x\n",err);
5491
5492 }
5493
5494 MODULE_LICENSE("GPL");
5495
5496 /****** End *****************************************************************/