drivers/net/wan/sdla_fr.c

   1 /*****************************************************************************
   2 * sdla_fr.c     WANPIPE(tm) Multiprotocol WAN Link Driver. Frame relay module.
   3 *
   4 * Author(s):    Nenad Corbic  <ncorbic@sangoma.com>
   5 *               Gideon Hack
   6 *
   7 * Copyright:    (c) 1995-2001 Sangoma Technologies Inc.
   8 *
   9 *               This program is free software; you can redistribute it and/or
  10 *               modify it under the terms of the GNU General Public License
  11 *               as published by the Free Software Foundation; either version
  12 *               2 of the License, or (at your option) any later version.
  13 * ============================================================================
  14 * Nov 23, 2000  Nenad Corbic    o Added support for 2.4.X kernels
  15 * Nov 15, 2000  David Rokavarg
  16 *               Nenad Corbic    o Added frame relay bridging support.
  17 *                                 Original code from Mark Wells and Kristian Hoffmann has
  18 *                                 been integrated into the frame relay driver.
  19 * Nov 13, 2000  Nenad Corbic    o Added true interface type encoding option.
  20 *                                 Tcpdump doesn't support Frame Relay inteface
  21 *                                 types, to fix this true type option will set
  22 *                                 the interface type to RAW IP mode.
  23 * Nov 07, 2000  Nenad Corbic    o Added security features for UDP debugging:
  24 *                                 Deny all and specify allowed requests.
  25 * Nov 06, 2000  Nenad Corbic    o Wanpipe interfaces conform to raw packet interfaces.
  26 *                                 Moved the if_header into the if_send() routine.
  27 *                                 The if_header() was breaking the libpcap
  28 *                                 support. i.e. support for tcpdump, ethereal ...
  29 * Oct 12. 2000  Nenad Corbic    o Added error message in fr_configure
  30 * Jul 31, 2000  Nenad Corbic    o Fixed the Router UP Time.
  31 * Apr 28, 2000  Nenad Corbic    o Added the option to shutdown an interface
  32 *                                 when the channel gets disconnected.
  33 * Apr 28, 2000  Nenad Corbic    o Added M.Grants patch: disallow duplicate
  34 *                                 interface setups.
  35 * Apr 25, 2000  Nenad Corbic    o Added M.Grants patch: dynamically add/remove
  36 *                                 new dlcis/interfaces.
  37 * Mar 23, 2000  Nenad Corbic    o Improved task queue, bh handling.
  38 * Mar 16, 2000  Nenad Corbic    o Added Inverse ARP support
  39 * Mar 13, 2000  Nenad Corbic    o Added new socket API support.
  40 * Mar 06, 2000  Nenad Corbic    o Bug Fix: corrupted mbox recovery.
  41 * Feb 24, 2000  Nenad Corbic    o Fixed up FT1 UDP debugging problem.
  42 * Dev 15, 1999  Nenad Corbic    o Fixed up header files for 2.0.X kernels
  43 *
  44 * Nov 08, 1999  Nenad Corbic    o Combined all debug UDP calls into one function
  45 *                               o Removed the ARP support. This has to be done
  46 *                                 in the next version.
  47 *                               o Only a Node can implement NO signalling.
  48 *                                 Initialize DLCI during if_open() if NO
  49 *                                 signalling.
  50 *                               o Took out IPX support, implement in next
  51 *                                 version
  52 * Sep 29, 1999  Nenad Corbic    o Added SMP support and changed the update
  53 *                                 function to use timer interrupt.
  54 *                               o Fixed the CIR bug:  Set the value of BC
  55 *                                 to CIR when the CIR is enabled.
  56 *                               o Updated comments, statistics and tracing.
  57 * Jun 02, 1999  Gideon Hack     o Updated for S514 support.
  58 * Sep 18, 1998  Jaspreet Singh  o Updated for 2.2.X kernels.
  59 * Jul 31, 1998  Jaspreet Singh  o Removed wpf_poll routine.  The channel/DLCI
  60 *                                 status is received through an event interrupt.
  61 * Jul 08, 1998  David Fong      o Added inverse ARP support.
  62 * Mar 26, 1997  Jaspreet Singh  o Returning return codes for failed UDP cmds.
  63 * Jan 28, 1997  Jaspreet Singh  o Improved handling of inactive DLCIs.
  64 * Dec 30, 1997  Jaspreet Singh  o Replaced dev_tint() with mark_bh(NET_BH)
  65 * Dec 16, 1997  Jaspreet Singh  o Implemented Multiple IPX support.
  66 * Nov 26, 1997  Jaspreet Singh  o Improved load sharing with multiple boards
  67 *                               o Added Cli() to protect enabling of interrupts
  68 *                                 while polling is called.
  69 * Nov 24, 1997  Jaspreet Singh  o Added counters to avoid enabling of interrupts
  70 *                                 when they have been disabled by another
  71 *                                 interface or routine (eg. wpf_poll).
  72 * Nov 06, 1997  Jaspreet Singh  o Added INTR_TEST_MODE to avoid polling
  73 *                                 routine disable interrupts during interrupt
  74 *                                 testing.
  75 * Oct 20, 1997  Jaspreet Singh  o Added hooks in for Router UP time.
  76 * Oct 16, 1997  Jaspreet Singh  o The critical flag is used to maintain flow
  77 *                                 control by avoiding RACE conditions.  The
  78 *                                 cli() and restore_flags() are taken out.
  79 *                                 The fr_channel structure is appended for
  80 *                                 Driver Statistics.
  81 * Oct 15, 1997  Farhan Thawar    o updated if_send() and receive for IPX
  82 * Aug 29, 1997  Farhan Thawar    o Removed most of the cli() and sti()
  83 *                                o Abstracted the UDP management stuff
  84 *                                o Now use tbusy and critical more intelligently
  85 * Jul 21, 1997  Jaspreet Singh   o Can configure T391, T392, N391, N392 & N393
  86 *                                  through router.conf.
  87 *                                o Protected calls to sdla_peek() by adDing
  88 *                                  save_flags(), cli() and restore_flags().
  89 *                                o Added error message for Inactive DLCIs in
  90 *                                  fr_event() and update_chan_state().
  91 *                                o Fixed freeing up of buffers using kfree()
  92 *                                  when packets are received.
  93 * Jul 07, 1997  Jaspreet Singh   o Added configurable TTL for UDP packets
  94 *                                o Added ability to discard multicast and
  95 *                                  broadcast source addressed packets
  96 * Jun 27, 1997  Jaspreet Singh   o Added FT1 monitor capabilities
  97 *                                  New case (0x44) statement in if_send routine
  98 *                                  Added a global variable rCount to keep track
  99 *                                  of FT1 status enabled on the board.
 100 * May 29, 1997  Jaspreet Singh   o Fixed major Flow Control Problem
 101 *                                  With multiple boards a problem was seen where
 102 *                                  the second board always stopped transmitting
 103 *                                  packet after running for a while. The code
 104 *                                  got into a stage where the interrupts were
 105 *                                  disabled and dev->tbusy was set to 1.
 106 *                                  This caused the If_send() routine to get into
 107 *                                  the if clause for it(0,dev->tbusy)
 108 *                                  forever.
 109 *                                  The code got into this stage due to an
 110 *                                  interrupt occurring within the if clause for
 111 *                                  set_bit(0,dev->tbusy).  Since an interrupt
 112 *                                  disables furhter transmit interrupt and
 113 *                                  makes dev->tbusy = 0, this effect was undone
 114 *                                  by making dev->tbusy = 1 in the if clause.
 115 *                                  The Fix checks to see if Transmit interrupts
 116 *                                  are disabled then do not make dev->tbusy = 1
 117 *                                  Introduced a global variable: int_occur and
 118 *                                  added tx_int_enabled in the wan_device
 119 *                                  structure.
 120 * May 21, 1997  Jaspreet Singh   o Fixed UDP Management for multiple
 121 *                                  boards.
 122 *
 123 * Apr 25, 1997  Farhan Thawar    o added UDP Management stuff
 124 *                                o fixed bug in if_send() and tx_intr() to
 125 *                                  sleep and wakeup all devices
 126 * Mar 11, 1997  Farhan Thawar   Version 3.1.1
 127 *                                o fixed (+1) bug in fr508_rx_intr()
 128 *                                o changed if_send() to return 0 if
 129 *                                  wandev.critical() is true
 130 *                                o free socket buffer in if_send() if
 131 *                                  returning 0
 132 *                                o added tx_intr() routine
 133 * Jan 30, 1997  Gene Kozin      Version 3.1.0
 134 *                                o implemented exec() entry point
 135 *                                o fixed a bug causing driver configured as
 136 *                                  a FR switch to be stuck in WAN_
 137 *                                  mode
 138 * Jan 02, 1997  Gene Kozin      Initial version.
 139 *****************************************************************************/
 140
 141 #include <linux/module.h>
 142 #include <linux/kernel.h>       /* printk(), and other useful stuff */
 143 #include <linux/stddef.h>       /* offsetof(), etc. */
 144 #include <linux/errno.h>        /* return codes */
 145 #include <linux/string.h>       /* inline memset(), etc. */
 146 #include <linux/slab.h> /* kmalloc(), kfree() */
 147 #include <linux/wanrouter.h>    /* WAN router definitions */
 148 #include <linux/wanpipe.h>      /* WANPIPE common user API definitions */
 149 #include <linux/workqueue.h>
 150 #include <linux/if_arp.h>       /* ARPHRD_* defines */
 151 #include <asm/byteorder.h>      /* htons(), etc. */
 152 #include <asm/io.h>             /* for inb(), outb(), etc. */
 153 #include <linux/time.h>         /* for do_gettimeofday */
 154 #include <linux/in.h>           /* sockaddr_in */
 155 #include <linux/jiffies.h>      /* time_after() macro */
 156 #include <asm/errno.h>
 157
 158 #include <linux/ip.h>
 159 #include <linux/if.h>
 160
 161 #include <linux/if_wanpipe_common.h>    /* Wanpipe Socket */
 162 #include <linux/if_wanpipe.h>
 163
 164 #include <linux/sdla_fr.h>              /* frame relay firmware API definitions */
 165
 166 #include <asm/uaccess.h>
 167 #include <linux/inetdevice.h>
 168 #include <linux/netdevice.h>
 169
 170 #include <net/route.h>                  /* Dynamic Route Creation */
 171 #include <linux/etherdevice.h>          /* eth_type_trans() used for bridging */
 172 #include <linux/random.h>
 173
 174 /****** Defines & Macros ****************************************************/
 175
 176 #define MAX_CMD_RETRY   10              /* max number of firmware retries */
 177
 178 #define FR_HEADER_LEN   8               /* max encapsulation header size */
 179 #define FR_CHANNEL_MTU  1500            /* unfragmented logical channel MTU */
 180
 181 /* Q.922 frame types */
 182 #define Q922_UI         0x03            /* Unnumbered Info frame */
 183 #define Q922_XID        0xAF
 184
 185 /* DLCI configured or not */
 186 #define DLCI_NOT_CONFIGURED     0x00
 187 #define DLCI_CONFIG_PENDING     0x01
 188 #define DLCI_CONFIGURED         0x02
 189
 190 /* CIR enabled or not */
 191 #define CIR_ENABLED     0x00
 192 #define CIR_DISABLED    0x01
 193
 194 #define FRAME_RELAY_API 1
 195 #define MAX_BH_BUFF     10
 196
 197 /* For handle_IPXWAN() */
 198 #define CVHexToAscii(b) (((unsigned char)(b) > (unsigned char)9) ? ((unsigned char)'A' + ((unsigned char)(b) - (unsigned char)10)) : ((unsigned char)'0' + (unsigned char)(b)))
 199
 200 /****** Data Structures *****************************************************/
 201
 202 /* This is an extention of the 'struct device' we create for each network
 203  * interface to keep the rest of channel-specific data.
 204  */
 205 typedef struct fr_channel
 206 {
 207         wanpipe_common_t common;
 208         char name[WAN_IFNAME_SZ+1];     /* interface name, ASCIIZ */
 209         unsigned dlci_configured  ;     /* check whether configured or not */
 210         unsigned cir_status;            /* check whether CIR enabled or not */
 211         unsigned dlci;                  /* logical channel number */
 212         unsigned cir;                   /* committed information rate */
 213         unsigned bc;                    /* committed burst size */
 214         unsigned be;                    /* excess burst size */
 215         unsigned mc;                    /* multicast support on or off */
 216         unsigned tx_int_status;         /* Transmit Interrupt Status */
 217         unsigned short pkt_length;      /* Packet Length */
 218         unsigned long router_start_time;/* Router start time in seconds */
 219         unsigned long tick_counter;     /* counter for transmit time out */
 220         char dev_pending_devtint;       /* interface pending dev_tint() */
 221         void *dlci_int_interface;       /* pointer to the DLCI Interface */
 222         unsigned long IB_addr;          /* physical address of Interface Byte */
 223         unsigned long state_tick;       /* time of the last state change */
 224         unsigned char enable_IPX;       /* Enable/Disable the use of IPX */
 225         unsigned long network_number;   /* Internal Network Number for IPX*/
 226         sdla_t *card;                   /* -> owner */
 227         unsigned route_flag;            /* Add/Rem dest addr in route tables */
 228         unsigned inarp;                 /* Inverse Arp Request status */
 229         long inarp_ready;               /* Ready to send requests */
 230         int inarp_interval;             /* Time between InArp Requests */
 231         unsigned long inarp_tick;       /* InArp jiffies tick counter */
 232         long interface_down;            /* Bring interface down on disconnect */
 233         struct net_device_stats ifstats;        /* interface statistics */
 234         if_send_stat_t drvstats_if_send;
 235         rx_intr_stat_t drvstats_rx_intr;
 236         pipe_mgmt_stat_t drvstats_gen;
 237         unsigned long router_up_time;
 238
 239         unsigned short transmit_length;
 240         struct sk_buff *delay_skb;
 241
 242         bh_data_t *bh_head;               /* Circular buffer for chdlc_bh */
 243         unsigned long  tq_working;
 244         volatile int  bh_write;
 245         volatile int  bh_read;
 246         atomic_t  bh_buff_used;
 247
 248         /* Polling task queue. Each interface
 249          * has its own task queue, which is used
 250          * to defer events from the interrupt */
 251         struct work_struct fr_poll_work;
 252         struct timer_list fr_arp_timer;
 253
 254         u32 ip_local;
 255         u32 ip_remote;
 256         long config_dlci;
 257         long unconfig_dlci;
 258
 259         /* Whether this interface should be setup as a gateway.
 260          * Used by dynamic route setup code */
 261         u8  gateway;
 262
 263         /* True interface type */
 264         u8 true_if_encoding;
 265         u8 fr_header[FR_HEADER_LEN];
 266         char fr_header_len;
 267
 268 } fr_channel_t;
 269
 270 /* Route Flag options */
 271 #define NO_ROUTE        0x00
 272 #define ADD_ROUTE       0x01
 273 #define ROUTE_ADDED     0x02
 274 #define REMOVE_ROUTE    0x03
 275 #define ARP_REQ         0x04
 276
 277 /* inarp options */
 278 #define INARP_NONE              0x00
 279 #define INARP_REQUEST           0x01
 280 #define INARP_CONFIGURED        0x02
 281
 282 /* reasons for enabling the timer interrupt on the adapter */
 283 #define TMR_INT_ENABLED_UDP     0x01
 284 #define TMR_INT_ENABLED_UPDATE  0x02
 285 #define TMR_INT_ENABLED_ARP     0x04
 286 #define TMR_INT_ENABLED_UPDATE_STATE    0x08
 287 #define TMR_INT_ENABLED_CONFIG  0x10
 288 #define TMR_INT_ENABLED_UNCONFIG        0x20
 289
 290
 291 typedef struct dlci_status
 292 {
 293         unsigned short dlci     PACKED;
 294         unsigned char state     PACKED;
 295 } dlci_status_t;
 296
 297 typedef struct dlci_IB_mapping
 298 {
 299         unsigned short dlci             PACKED;
 300         unsigned long  addr_value       PACKED;
 301 } dlci_IB_mapping_t;
 302
 303 /* This structure is used for DLCI list Tx interrupt mode.  It is used to
 304    enable interrupt bit and set the packet length for transmission
 305  */
 306 typedef struct fr_dlci_interface
 307 {
 308         unsigned char gen_interrupt     PACKED;
 309         unsigned short packet_length    PACKED;
 310         unsigned char reserved          PACKED;
 311 } fr_dlci_interface_t;
 312
 313 /* variable for keeping track of enabling/disabling FT1 monitor status */
 314 static int rCount = 0;
 315
 316 extern void disable_irq(unsigned int);
 317 extern void enable_irq(unsigned int);
 318
 319 /* variable for keeping track of number of interrupts generated during
 320  * interrupt test routine
 321  */
 322 static int Intr_test_counter;
 323
 324 /****** Function Prototypes *************************************************/
 325
 326 /* WAN link driver entry points. These are called by the WAN router module. */
 327 static int update(struct wan_device *wandev);
 328 static int new_if(struct wan_device *wandev, struct net_device *dev,
 329                   wanif_conf_t *conf);
 330 static int del_if(struct wan_device *wandev, struct net_device *dev);
 331 static void disable_comm (sdla_t *card);
 332
 333 /* WANPIPE-specific entry points */
 334 static int wpf_exec(struct sdla *card, void *u_cmd, void *u_data);
 335
 336 /* Network device interface */
 337 static int if_init(struct net_device *dev);
 338 static int if_open(struct net_device *dev);
 339 static int if_close(struct net_device *dev);
 340
 341 static void if_tx_timeout(struct net_device *dev);
 342
 343 static int if_rebuild_hdr (struct sk_buff *skb);
 344
 345 static int if_send(struct sk_buff *skb, struct net_device *dev);
 346 static int chk_bcast_mcast_addr(sdla_t *card, struct net_device* dev,
 347                                 struct sk_buff *skb);
 348 static struct net_device_stats *if_stats(struct net_device *dev);
 349
 350 /* Interrupt handlers */
 351 static void fr_isr(sdla_t *card);
 352 static void rx_intr(sdla_t *card);
 353 static void tx_intr(sdla_t *card);
 354 static void timer_intr(sdla_t *card);
 355 static void spur_intr(sdla_t *card);
 356
 357 /* Frame relay firmware interface functions */
 358 static int fr_read_version(sdla_t *card, char *str);
 359 static int fr_configure(sdla_t *card, fr_conf_t *conf);
 360 static int fr_dlci_configure(sdla_t *card, fr_dlc_conf_t *conf, unsigned dlci);
 361 static int fr_init_dlci (sdla_t *card, fr_channel_t *chan);
 362 static int fr_set_intr_mode (sdla_t *card, unsigned mode, unsigned mtu, unsigned short timeout);
 363 static int fr_comm_enable(sdla_t *card);
 364 static void fr_comm_disable(sdla_t *card);
 365 static int fr_get_err_stats(sdla_t *card);
 366 static int fr_get_stats(sdla_t *card);
 367 static int fr_add_dlci(sdla_t *card, int dlci);
 368 static int fr_activate_dlci(sdla_t *card, int dlci);
 369 static int fr_delete_dlci (sdla_t* card, int dlci);
 370 static int fr_issue_isf(sdla_t *card, int isf);
 371 static int fr_send(sdla_t *card, int dlci, unsigned char attr, int len,
 372         void *buf);
 373 static int fr_send_data_header(sdla_t *card, int dlci, unsigned char attr, int len,
 374         void *buf,unsigned char hdr_len);
 375 static unsigned int fr_send_hdr(sdla_t *card, int dlci, unsigned int offset);
 376
 377 static int check_dlci_config (sdla_t *card, fr_channel_t *chan);
 378 static void initialize_rx_tx_buffers (sdla_t *card);
 379
 380
 381 /* Firmware asynchronous event handlers */
 382 static int fr_event(sdla_t *card, int event, fr_mbox_t *mbox);
 383 static int fr_modem_failure(sdla_t *card, fr_mbox_t *mbox);
 384 static int fr_dlci_change(sdla_t *card, fr_mbox_t *mbox);
 385
 386 /* Miscellaneous functions */
 387 static int update_chan_state(struct net_device *dev);
 388 static void set_chan_state(struct net_device *dev, int state);
 389 static struct net_device *find_channel(sdla_t *card, unsigned dlci);
 390 static int is_tx_ready(sdla_t *card, fr_channel_t *chan);
 391 static unsigned int dec_to_uint(unsigned char *str, int len);
 392 static int reply_udp( unsigned char *data, unsigned int mbox_len );
 393
 394 static int intr_test( sdla_t* card );
 395 static void init_chan_statistics( fr_channel_t* chan );
 396 static void init_global_statistics( sdla_t* card );
 397 static void read_DLCI_IB_mapping( sdla_t* card, fr_channel_t* chan );
 398 static int setup_for_delayed_transmit(struct net_device* dev,
 399                                       struct sk_buff *skb);
 400
 401 struct net_device *move_dev_to_next(sdla_t *card, struct net_device *dev);
 402 static int check_tx_status(sdla_t *card, struct net_device *dev);
 403
 404 /* Frame Relay Socket API */
 405 static void trigger_fr_bh (fr_channel_t *);
 406 static void fr_bh(struct net_device *dev);
 407 static int fr_bh_cleanup(struct net_device *dev);
 408 static int bh_enqueue(struct net_device *dev, struct sk_buff *skb);
 409
 410 static void trigger_fr_poll(struct net_device *dev);
 411 static void fr_poll(struct net_device *dev);
 412 //static void add_gateway(struct net_device *dev);
 413
 414 static void trigger_unconfig_fr(struct net_device *dev);
 415 static void unconfig_fr (sdla_t *);
 416
 417 static void trigger_config_fr (sdla_t *);
 418 static void config_fr (sdla_t *);
 419
 420
 421 /* Inverse ARP and Dynamic routing functions */
 422 int process_ARP(arphdr_1490_t *ArpPacket, sdla_t *card, struct net_device *dev);
 423 int is_arp(void *buf);
 424 int send_inarp_request(sdla_t *card, struct net_device *dev);
 425
 426 static void trigger_fr_arp(struct net_device *dev);
 427 static void fr_arp (unsigned long data);
 428
 429
 430 /* Udp management functions */
 431 static int process_udp_mgmt_pkt(sdla_t *card);
 432 static int udp_pkt_type( struct sk_buff *skb, sdla_t *card );
 433 static int store_udp_mgmt_pkt(int udp_type, char udp_pkt_src, sdla_t* card,
 434                                 struct sk_buff *skb, int dlci);
 435
 436 /* IPX functions */
 437 static void switch_net_numbers(unsigned char *sendpacket,
 438         unsigned long network_number, unsigned char incoming);
 439
 440 static int handle_IPXWAN(unsigned char *sendpacket, char *devname,
 441         unsigned char enable_IPX, unsigned long network_number);
 442
 443 /* Lock Functions: SMP supported */
 444 void    s508_s514_unlock(sdla_t *card, unsigned long *smp_flags);
 445 void    s508_s514_lock(sdla_t *card, unsigned long *smp_flags);
 446
 447 unsigned short calc_checksum (char *, int);
 448 static int setup_fr_header(struct sk_buff** skb,
 449                            struct net_device* dev, char op_mode);
 450
 451
 452 /****** Public Functions ****************************************************/
 453
 454 /*============================================================================
 455  * Frame relay protocol initialization routine.
 456  *
 457  * This routine is called by the main WANPIPE module during setup.  At this
 458  * point adapter is completely initialized and firmware is running.
 459  *  o read firmware version (to make sure it's alive)
 460  *  o configure adapter
 461  *  o initialize protocol-specific fields of the adapter data space.
 462  *
 463  * Return:      0       o.k.
 464  *              < 0     failure.
 465  */
 466 int wpf_init(sdla_t *card, wandev_conf_t *conf)
 467 {
 468
 469         int err;
 470         fr508_flags_t* flags;
 471
 472         union
 473         {
 474                 char str[80];
 475                 fr_conf_t cfg;
 476         } u;
 477
 478         fr_buf_info_t* buf_info;
 479         int i;
 480
 481
 482         printk(KERN_INFO "\n");
 483
 484         /* Verify configuration ID */
 485         if (conf->config_id != WANCONFIG_FR) {
 486
 487                 printk(KERN_INFO "%s: invalid configuration ID %u!\n",
 488                         card->devname, conf->config_id);
 489                 return -EINVAL;
 490
 491         }
 492
 493         /* Initialize protocol-specific fields of adapter data space */
 494         switch (card->hw.fwid) {
 495
 496                 case SFID_FR508:
 497                         card->mbox  = (void*)(card->hw.dpmbase +
 498                                         FR508_MBOX_OFFS);
 499                         card->flags = (void*)(card->hw.dpmbase +
 500                                         FR508_FLAG_OFFS);
 501                         if(card->hw.type == SDLA_S514) {
 502                                 card->mbox += FR_MB_VECTOR;
 503                                 card->flags += FR_MB_VECTOR;
 504                         }
 505                         card->isr = &fr_isr;
 506                         break;
 507
 508                 default:
 509                         return -EINVAL;
 510         }
 511
 512         flags = card->flags;
 513
 514         /* Read firmware version.  Note that when adapter initializes, it
 515          * clears the mailbox, so it may appear that the first command was
 516          * executed successfully when in fact it was merely erased. To work
 517          * around this, we execute the first command twice.
 518          */
 519
 520         if (fr_read_version(card, NULL) || fr_read_version(card, u.str))
 521                 return -EIO;
 522
 523         printk(KERN_INFO "%s: running frame relay firmware v%s\n",
 524                 card->devname, u.str);
 525
 526         /* Adjust configuration */
 527         conf->mtu += FR_HEADER_LEN;
 528         conf->mtu = (conf->mtu >= MIN_LGTH_FR_DATA_CFG) ?
 529                         min_t(unsigned int, conf->mtu, FR_MAX_NO_DATA_BYTES_IN_FRAME) :
 530                         FR_CHANNEL_MTU + FR_HEADER_LEN;
 531
 532         conf->bps = min_t(unsigned int, conf->bps, 2048000);
 533
 534         /* Initialze the configuration structure sent to the board to zero */
 535         memset(&u.cfg, 0, sizeof(u.cfg));
 536
 537         memset(card->u.f.dlci_to_dev_map, 0, sizeof(card->u.f.dlci_to_dev_map));
 538
 539         /* Configure adapter firmware */
 540
 541         u.cfg.mtu       = conf->mtu;
 542         u.cfg.kbps      = conf->bps / 1000;
 543
 544         u.cfg.cir_fwd = u.cfg.cir_bwd = 16;
 545         u.cfg.bc_fwd  = u.cfg.bc_bwd = 16;
 546
 547         u.cfg.options   = 0x0000;
 548         printk(KERN_INFO "%s: Global CIR enabled by Default\n", card->devname);
 549
 550         switch (conf->u.fr.signalling) {
 551
 552                 case WANOPT_FR_ANSI:
 553                         u.cfg.options = 0x0000;
 554                         break;
 555
 556                 case WANOPT_FR_Q933:
 557                         u.cfg.options |= 0x0200;
 558                         break;
 559
 560                 case WANOPT_FR_LMI:
 561                         u.cfg.options |= 0x0400;
 562                         break;
 563
 564                 case WANOPT_NO:
 565                         u.cfg.options |= 0x0800;
 566                         break;
 567                 default:
 568                         printk(KERN_INFO "%s: Illegal Signalling option\n",
 569                                         card->wandev.name);
 570                         return -EINVAL;
 571         }
 572
 573
 574         card->wandev.signalling = conf->u.fr.signalling;
 575
 576         if (conf->station == WANOPT_CPE) {
 577
 578
 579                 if (conf->u.fr.signalling == WANOPT_NO){
 580                         printk(KERN_INFO
 581                                 "%s: ERROR - For NO signalling, station must be set to Node!",
 582                                          card->devname);
 583                         return -EINVAL;
 584                 }
 585
 586                 u.cfg.station = 0;
 587                 u.cfg.options |= 0x8000;        /* auto config DLCI */
 588                 card->u.f.dlci_num  = 0;
 589
 590         } else {
 591
 592                 u.cfg.station = 1;      /* switch emulation mode */
 593
 594                 /* For switch emulation we have to create a list of dlci(s)
 595                  * that will be sent to be global SET_DLCI_CONFIGURATION
 596                  * command in fr_configure() routine.
 597                  */
 598
 599                 card->u.f.dlci_num  = min_t(unsigned int, max_t(unsigned int, conf->u.fr.dlci_num, 1), 100);
 600
 601                 for ( i = 0; i < card->u.f.dlci_num; i++) {
 602
 603                         card->u.f.node_dlci[i] = (unsigned short)
 604                                 conf->u.fr.dlci[i] ? conf->u.fr.dlci[i] : 16;
 605
 606                 }
 607         }
 608
 609         if (conf->clocking == WANOPT_INTERNAL)
 610                 u.cfg.port |= 0x0001;
 611
 612         if (conf->interface == WANOPT_RS232)
 613                 u.cfg.port |= 0x0002;
 614
 615         if (conf->u.fr.t391)
 616                 u.cfg.t391 = min_t(unsigned int, conf->u.fr.t391, 30);
 617         else
 618                 u.cfg.t391 = 5;
 619
 620         if (conf->u.fr.t392)
 621                 u.cfg.t392 = min_t(unsigned int, conf->u.fr.t392, 30);
 622         else
 623                 u.cfg.t392 = 15;
 624
 625         if (conf->u.fr.n391)
 626                 u.cfg.n391 = min_t(unsigned int, conf->u.fr.n391, 255);
 627         else
 628                 u.cfg.n391 = 2;
 629
 630         if (conf->u.fr.n392)
 631                 u.cfg.n392 = min_t(unsigned int, conf->u.fr.n392, 10);
 632         else
 633                 u.cfg.n392 = 3;
 634
 635         if (conf->u.fr.n393)
 636                 u.cfg.n393 = min_t(unsigned int, conf->u.fr.n393, 10);
 637         else
 638                 u.cfg.n393 = 4;
 639
 640         if (fr_configure(card, &u.cfg))
 641                 return -EIO;
 642
 643         if (card->hw.type == SDLA_S514) {
 644
 645                 buf_info = (void*)(card->hw.dpmbase + FR_MB_VECTOR +
 646                         FR508_RXBC_OFFS);
 647
 648                 card->rxmb = (void*)(buf_info->rse_next + card->hw.dpmbase);
 649
 650                 card->u.f.rxmb_base =
 651                         (void*)(buf_info->rse_base + card->hw.dpmbase);
 652
 653                 card->u.f.rxmb_last =
 654                         (void*)(buf_info->rse_base +
 655                         (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) +
 656                         card->hw.dpmbase);
 657         }else{
 658                 buf_info = (void*)(card->hw.dpmbase + FR508_RXBC_OFFS);
 659
 660                 card->rxmb = (void*)(buf_info->rse_next -
 661                         FR_MB_VECTOR + card->hw.dpmbase);
 662
 663                 card->u.f.rxmb_base =
 664                         (void*)(buf_info->rse_base -
 665                         FR_MB_VECTOR + card->hw.dpmbase);
 666
 667                 card->u.f.rxmb_last =
 668                         (void*)(buf_info->rse_base +
 669                         (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) -
 670                         FR_MB_VECTOR + card->hw.dpmbase);
 671         }
 672
 673         card->u.f.rx_base = buf_info->buf_base;
 674         card->u.f.rx_top  = buf_info->buf_top;
 675
 676         card->u.f.tx_interrupts_pending = 0;
 677
 678         card->wandev.mtu        = conf->mtu;
 679         card->wandev.bps        = conf->bps;
 680         card->wandev.interface  = conf->interface;
 681         card->wandev.clocking   = conf->clocking;
 682         card->wandev.station    = conf->station;
 683         card->poll              = NULL;
 684         card->exec              = &wpf_exec;
 685         card->wandev.update     = &update;
 686         card->wandev.new_if     = &new_if;
 687         card->wandev.del_if     = &del_if;
 688         card->wandev.state      = WAN_DISCONNECTED;
 689         card->wandev.ttl        = conf->ttl;
 690         card->wandev.udp_port   = conf->udp_port;
 691         card->disable_comm      = &disable_comm;
 692         card->u.f.arp_dev       = NULL;
 693
 694         /* Intialize global statistics for a card */
 695         init_global_statistics( card );
 696
 697         card->TracingEnabled          = 0;
 698
 699         /* Interrupt Test */
 700         Intr_test_counter = 0;
 701         card->intr_mode = INTR_TEST_MODE;
 702         err = intr_test( card );
 703
 704         printk(KERN_INFO "%s: End of Interrupt Test rc=0x%x  count=%i\n",
 705                         card->devname,err,Intr_test_counter);
 706
 707         if (err || (Intr_test_counter < MAX_INTR_TEST_COUNTER)) {
 708                 printk(KERN_ERR "%s: Interrupt Test Failed, Counter: %i\n",
 709                         card->devname, Intr_test_counter);
 710                 printk(KERN_ERR "Please choose another interrupt\n");
 711                 err = -EIO;
 712                 return err;
 713         }
 714
 715         printk(KERN_INFO "%s: Interrupt Test Passed, Counter: %i\n",
 716                         card->devname, Intr_test_counter);
 717
 718
 719         /* Apr 28 2000. Nenad Corbic
 720          * Enable commnunications here, not in if_open or new_if, since
 721          * interfaces come down when the link is disconnected.
 722          */
 723
 724         /* If you enable comms and then set ints, you get a Tx int as you
 725          * perform the SET_INT_TRIGGERS command. So, we only set int
 726          * triggers and then adjust the interrupt mask (to disable Tx ints)
 727          * before enabling comms.
 728          */
 729         if (fr_set_intr_mode(card, (FR_INTR_RXRDY | FR_INTR_TXRDY |
 730                 FR_INTR_DLC | FR_INTR_TIMER | FR_INTR_TX_MULT_DLCIs) ,
 731                 card->wandev.mtu, 0)) {
 732                 return -EIO;
 733         }
 734
 735         flags->imask &= ~(FR_INTR_TXRDY | FR_INTR_TIMER);
 736
 737         if (fr_comm_enable(card)) {
 738                 return -EIO;
 739         }
 740         wanpipe_set_state(card, WAN_CONNECTED);
 741         spin_lock_init(&card->u.f.if_send_lock);
 742
 743         printk(KERN_INFO "\n");
 744
 745         return 0;
 746 }
 747
 748 /******* WAN Device Driver Entry Points *************************************/
 749
 750 /*============================================================================
 751  * Update device status & statistics.
 752  */
 753 static int update(struct wan_device* wandev)
 754 {
 755         volatile sdla_t* card;
 756         unsigned long timeout;
 757         fr508_flags_t* flags;
 758
 759         /* sanity checks */
 760         if ((wandev == NULL) || (wandev->private == NULL))
 761                 return -EFAULT;
 762
 763         if (wandev->state == WAN_UNCONFIGURED)
 764                 return -ENODEV;
 765
 766         card = wandev->private;
 767         flags = card->flags;
 768
 769
 770         card->u.f.update_comms_stats = 1;
 771         card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UPDATE;
 772         flags->imask |= FR_INTR_TIMER;
 773         timeout = jiffies;
 774         for(;;) {
 775                 if(card->u.f.update_comms_stats == 0)
 776                         break;
 777                 if (time_after(jiffies, timeout + 1 * HZ)){
 778                         card->u.f.update_comms_stats = 0;
 779                         return -EAGAIN;
 780                 }
 781         }
 782
 783         return 0;
 784 }
 785
 786 /*============================================================================
 787  * Create new logical channel.
 788  * This routine is called by the router when ROUTER_IFNEW IOCTL is being
 789  * handled.
 790  * o parse media- and hardware-specific configuration
 791  * o make sure that a new channel can be created
 792  * o allocate resources, if necessary
 793  * o prepare network device structure for registaration.
 794  *
 795  * Return:      0       o.k.
 796  *              < 0     failure (channel will not be created)
 797  */
 798 static int new_if(struct wan_device* wandev, struct net_device* dev,
 799                   wanif_conf_t* conf)
 800 {
 801         sdla_t* card = wandev->private;
 802         fr_channel_t* chan;
 803         int dlci = 0;
 804         int err = 0;
 805
 806
 807         if ((conf->name[0] == '\0') || (strlen(conf->name) > WAN_IFNAME_SZ)) {
 808
 809                 printk(KERN_INFO "%s: Invalid interface name!\n",
 810                         card->devname);
 811                 return -EINVAL;
 812         }
 813
 814         /* allocate and initialize private data */
 815         chan = kmalloc(sizeof(fr_channel_t), GFP_KERNEL);
 816
 817         if (chan == NULL)
 818                 return -ENOMEM;
 819
 820         memset(chan, 0, sizeof(fr_channel_t));
 821         strcpy(chan->name, conf->name);
 822         chan->card = card;
 823
 824         /* verify media address */
 825         if (is_digit(conf->addr[0])) {
 826
 827                 dlci = dec_to_uint(conf->addr, 0);
 828
 829                 if (dlci && (dlci <= HIGHEST_VALID_DLCI)) {
 830
 831                         chan->dlci = dlci;
 832
 833                 } else {
 834
 835                         printk(KERN_ERR
 836                                 "%s: Invalid DLCI %u on interface %s!\n",
 837                                 wandev->name, dlci, chan->name);
 838                         err = -EINVAL;
 839                 }
 840
 841         } else {
 842                 printk(KERN_ERR
 843                         "%s: Invalid media address on interface %s!\n",
 844                         wandev->name, chan->name);
 845                 err = -EINVAL;
 846         }
 847
 848         if ((chan->true_if_encoding = conf->true_if_encoding) == WANOPT_YES){
 849                 printk(KERN_INFO
 850                         "%s: Enabling, true interface type encoding.\n",
 851                         card->devname);
 852         }
 853
 854
 855
 856     /* Setup wanpipe as a router (WANPIPE) even if it is
 857          * a bridged DLCI, or as an API
 858          */
 859         if (strcmp(conf->usedby, "WANPIPE")  == 0  ||
 860             strcmp(conf->usedby, "BRIDGE")   == 0  ||
 861             strcmp(conf->usedby, "BRIDGE_N") == 0){
 862
 863                 if(strcmp(conf->usedby, "WANPIPE") == 0){
 864                         chan->common.usedby = WANPIPE;
 865
 866                         printk(KERN_INFO "%s: Running in WANPIPE mode.\n",
 867                                         card->devname);
 868
 869                 }else if(strcmp(conf->usedby, "BRIDGE") == 0){
 870
 871                         chan->common.usedby = BRIDGE;
 872
 873                         printk(KERN_INFO "%s: Running in WANPIPE (BRIDGE) mode.\n",
 874                                         card->devname);
 875                 }else if( strcmp(conf->usedby, "BRIDGE_N") == 0 ){
 876
 877                         chan->common.usedby = BRIDGE_NODE;
 878
 879                         printk(KERN_INFO "%s: Running in WANPIPE (BRIDGE_NODE) mode.\n",
 880                                         card->devname);
 881                 }
 882
 883                 if (!err){
 884                         /* Dynamic interface configuration option.
 885                          * On disconnect, if the options is selected,
 886                          * the interface will be brought down */
 887                         if (conf->if_down == WANOPT_YES){
 888                                 set_bit(DYN_OPT_ON,&chan->interface_down);
 889                                 printk(KERN_INFO
 890                                     "%s: Dynamic interface configuration enabled.\n",
 891                                         card->devname);
 892                         }
 893                 }
 894
 895         } else if(strcmp(conf->usedby, "API") == 0){
 896
 897                 chan->common.usedby = API;
 898                 printk(KERN_INFO "%s: Running in API mode.\n",
 899                         wandev->name);
 900         }
 901
 902         if (err) {
 903
 904                 kfree(chan);
 905                 return err;
 906         }
 907
 908         /* place cir,be,bc and other channel specific information into the
 909          * chan structure
 910          */
 911         if (conf->cir) {
 912
 913                 chan->cir = max_t(unsigned int, 1,
 914                                 min_t(unsigned int, conf->cir, 512));
 915                 chan->cir_status = CIR_ENABLED;
 916
 917
 918                 /* If CIR is enabled, force BC to equal CIR
 919                  * this solves number of potential problems if CIR is
 920                  * set and BC is not
 921                  */
 922                 chan->bc = chan->cir;
 923
 924                 if (conf->be){
 925                         chan->be = max_t(unsigned int,
 926                                        0, min_t(unsigned int, conf->be, 511));
 927                 }else{
 928                         conf->be = 0;
 929                 }
 930
 931                 printk (KERN_INFO "%s: CIR enabled for DLCI %i \n",
 932                                 wandev->name,chan->dlci);
 933                 printk (KERN_INFO "%s:     CIR = %i ; BC = %i ; BE = %i\n",
 934                                 wandev->name,chan->cir,chan->bc,chan->be);
 935
 936
 937         }else{
 938                 chan->cir_status = CIR_DISABLED;
 939                 printk (KERN_INFO "%s: CIR disabled for DLCI %i\n",
 940                                 wandev->name,chan->dlci);
 941         }
 942
 943         chan->mc = conf->mc;
 944
 945         if (conf->inarp == WANOPT_YES){
 946                 printk(KERN_INFO "%s: Inverse ARP Support Enabled\n",card->devname);
 947                 chan->inarp = conf->inarp ? INARP_REQUEST : INARP_NONE;
 948                 chan->inarp_interval = conf->inarp_interval ? conf->inarp_interval : 10;
 949         }else{
 950                 printk(KERN_INFO "%s: Inverse ARP Support Disabled\n",card->devname);
 951                 chan->inarp = INARP_NONE;
 952                 chan->inarp_interval = 10;
 953         }
 954
 955
 956         chan->dlci_configured = DLCI_NOT_CONFIGURED;
 957
 958
 959         /*FIXME: IPX disabled in this WANPIPE version */
 960         if (conf->enable_IPX == WANOPT_YES){
 961                 printk(KERN_INFO "%s: ERROR - This version of WANPIPE doesn't support IPX\n",
 962                                 card->devname);
 963                 kfree(chan);
 964                 return -EINVAL;
 965         }else{
 966                 chan->enable_IPX = WANOPT_NO;
 967         }
 968
 969         if (conf->network_number){
 970                 chan->network_number = conf->network_number;
 971         }else{
 972                 chan->network_number = 0xDEADBEEF;
 973         }
 974
 975         chan->route_flag = NO_ROUTE;
 976
 977         init_chan_statistics(chan);
 978
 979         chan->transmit_length = 0;
 980
 981         /* prepare network device data space for registration */
 982         strcpy(dev->name,chan->name);
 983
 984         dev->init = &if_init;
 985         dev->priv = chan;
 986
 987         /* Initialize FR Polling Task Queue
 988          * We need a poll routine for each network
 989          * interface.
 990          */
 991         INIT_WORK(&chan->fr_poll_work, (void *)fr_poll, dev);
 992
 993         init_timer(&chan->fr_arp_timer);
 994         chan->fr_arp_timer.data=(unsigned long)dev;
 995         chan->fr_arp_timer.function = fr_arp;
 996
 997         wandev->new_if_cnt++;
 998
 999         /* Tells us that if this interface is a
1000          * gateway or not */
1001         if ((chan->gateway = conf->gateway) == WANOPT_YES){
1002                 printk(KERN_INFO "%s: Interface %s is set as a gateway.\n",
1003                         card->devname,dev->name);
1004         }
1005
1006         /* M. Grant Patch Apr 28 2000
1007          * Disallow duplicate dlci configurations. */
1008         if (card->u.f.dlci_to_dev_map[chan->dlci] != NULL) {
1009                 kfree(chan);
1010                 return -EBUSY;
1011         }
1012
1013         /* Configure this dlci at a later date, when
1014          * the interface comes up. i.e. when if_open()
1015          * executes */
1016         set_bit(0,&chan->config_dlci);
1017
1018         printk(KERN_INFO "\n");
1019
1020         return 0;
1021 }
1022
1023 /*============================================================================
1024  * Delete logical channel.
1025  */
1026 static int del_if(struct wan_device* wandev, struct net_device* dev)
1027 {
1028         fr_channel_t* chan = dev->priv;
1029         unsigned long smp_flags=0;
1030
1031         /* This interface is dead, make sure the
1032          * ARP timer is stopped */
1033         del_timer(&chan->fr_arp_timer);
1034
1035         /* If we are a NODE, we must unconfigure this DLCI
1036          * Trigger an unconfigure command that will
1037          * be executed in timer interrupt. We must wait
1038          * for the command to complete. */
1039         trigger_unconfig_fr(dev);
1040
1041         lock_adapter_irq(&wandev->lock, &smp_flags);
1042         wandev->new_if_cnt--;
1043         unlock_adapter_irq(&wandev->lock, &smp_flags);
1044
1045         return 0;
1046 }
1047
1048
1049 /*=====================================================================
1050  * disable_comm
1051  *
1052  * Description:
1053  *      Disable communications.
1054  *      This code runs in shutdown (sdlamain.c)
1055  *      under critical flag. Therefore it is not
1056  *      necessary to set a critical flag here
1057  *
1058  * Usage:
1059  *      Commnunications are disabled only on a card
1060  *      shutdown.
1061  */
1062
1063 static void disable_comm (sdla_t *card)
1064 {
1065         printk(KERN_INFO "%s: Disabling Communications!\n",
1066                         card->devname);
1067         fr_comm_disable(card);
1068 }
1069
1070 /****** WANPIPE-specific entry points ***************************************/
1071
1072 /*============================================================================
1073  * Execute adapter interface command.
1074  */
1075 static int wpf_exec (struct sdla* card, void* u_cmd, void* u_data)
1076 {
1077         fr_mbox_t* mbox = card->mbox;
1078         int retry = MAX_CMD_RETRY;
1079         int err, len;
1080         fr_cmd_t cmd;
1081
1082         if(copy_from_user((void*)&cmd, u_cmd, sizeof(cmd)))
1083                 return -EFAULT;
1084
1085         /* execute command */
1086         do
1087         {
1088                 memcpy(&mbox->cmd, &cmd, sizeof(cmd));
1089
1090                 if (cmd.length){
1091                         if( copy_from_user((void*)&mbox->data, u_data, cmd.length))
1092                                 return -EFAULT;
1093                 }
1094
1095                 if (sdla_exec(mbox))
1096                         err = mbox->cmd.result;
1097
1098                 else return -EIO;
1099
1100         } while (err && retry-- && fr_event(card, err, mbox));
1101
1102         /* return result */
1103         if (copy_to_user(u_cmd, (void*)&mbox->cmd, sizeof(fr_cmd_t)))
1104                 return -EFAULT;
1105
1106         len = mbox->cmd.length;
1107
1108         if (len && u_data && !copy_to_user(u_data, (void*)&mbox->data, len))
1109                 return -EFAULT;
1110         return 0;
1111 }
1112
1113 /****** Network Device Interface ********************************************/
1114
1115 /*============================================================================
1116  * Initialize Linux network interface.
1117  *
1118  * This routine is called only once for each interface, during Linux network
1119  * interface registration.  Returning anything but zero will fail interface
1120  * registration.
1121  */
1122 static int if_init(struct net_device* dev)
1123 {
1124         fr_channel_t* chan = dev->priv;
1125         sdla_t* card = chan->card;
1126         struct wan_device* wandev = &card->wandev;
1127
1128         /* Initialize device driver entry points */
1129         dev->open               = &if_open;
1130         dev->stop               = &if_close;
1131         dev->hard_header        = NULL;
1132         dev->rebuild_header     = &if_rebuild_hdr;
1133         dev->hard_start_xmit    = &if_send;
1134         dev->get_stats          = &if_stats;
1135         dev->tx_timeout         = &if_tx_timeout;
1136         dev->watchdog_timeo     = TX_TIMEOUT;
1137
1138         if (chan->common.usedby == WANPIPE || chan->common.usedby == API){
1139
1140                 /* Initialize media-specific parameters */
1141                 if (chan->true_if_encoding){
1142                         dev->type               = ARPHRD_DLCI;  /* This breaks tcpdump */
1143                 }else{
1144                         dev->type               = ARPHRD_PPP;   /* ARP h/w type */
1145                 }
1146
1147                 dev->flags              |= IFF_POINTOPOINT;
1148                 dev->flags              |= IFF_NOARP;
1149
1150                 /* Enable Multicast addressing */
1151                 if (chan->mc == WANOPT_YES){
1152                         dev->flags      |= IFF_MULTICAST;
1153                 }
1154
1155                 dev->mtu                = wandev->mtu - FR_HEADER_LEN;
1156                 /* For an API, the maximum number of bytes that the stack will pass
1157                    to the driver is (dev->mtu + dev->hard_header_len). So, adjust the
1158                    mtu so that a frame of maximum size can be transmitted by the API.
1159                 */
1160                 if(chan->common.usedby == API) {
1161                         dev->mtu += (sizeof(api_tx_hdr_t) - FR_HEADER_LEN);
1162                 }
1163
1164                 dev->hard_header_len    = FR_HEADER_LEN;/* media header length */
1165                 dev->addr_len           = 2;            /* hardware address length */
1166                 *(unsigned short*)dev->dev_addr = htons(chan->dlci);
1167
1168                 /* Set transmit buffer queue length */
1169                 dev->tx_queue_len = 100;
1170
1171         }else{
1172
1173                 /* Setup the interface for Bridging */
1174                 int hw_addr=0;
1175                 ether_setup(dev);
1176
1177                 /* Use a random number to generate the MAC address */
1178                 memcpy(dev->dev_addr, "\xFE\xFC\x00\x00\x00\x00", 6);
1179                 get_random_bytes(&hw_addr, sizeof(hw_addr));
1180                 *(int *)(dev->dev_addr + 2) += hw_addr;
1181         }
1182
1183         /* Initialize hardware parameters (just for reference) */
1184         dev->irq        = wandev->irq;
1185         dev->dma        = wandev->dma;
1186         dev->base_addr  = wandev->ioport;
1187         dev->mem_start  = wandev->maddr;
1188         dev->mem_end    = wandev->maddr + wandev->msize - 1;
1189         SET_MODULE_OWNER(dev);
1190
1191         return 0;
1192 }
1193
1194 /*============================================================================
1195  * Open network interface.
1196  * o if this is the first open, then enable communications and interrupts.
1197  * o prevent module from unloading by incrementing use count
1198  *
1199  * Return 0 if O.k. or errno.
1200  */
1201 static int if_open(struct net_device* dev)
1202 {
1203         fr_channel_t* chan = dev->priv;
1204         sdla_t* card = chan->card;
1205         int err = 0;
1206         struct timeval tv;
1207
1208         if (netif_running(dev))
1209                 return -EBUSY;
1210
1211         /* Initialize the task queue */
1212         chan->tq_working=0;
1213
1214         INIT_WORK(&chan->common.wanpipe_work, (void *)fr_bh, dev);
1215
1216         /* Allocate and initialize BH circular buffer */
1217         chan->bh_head = kmalloc((sizeof(bh_data_t)*MAX_BH_BUFF),GFP_ATOMIC);
1218         memset(chan->bh_head,0,(sizeof(bh_data_t)*MAX_BH_BUFF));
1219         atomic_set(&chan->bh_buff_used, 0);
1220
1221         netif_start_queue(dev);
1222
1223         wanpipe_open(card);
1224         do_gettimeofday( &tv );
1225         chan->router_start_time = tv.tv_sec;
1226
1227         if (test_bit(0,&chan->config_dlci)){
1228                 trigger_config_fr (card);
1229         }else if (chan->inarp == INARP_REQUEST){
1230                 trigger_fr_arp(dev);
1231         }
1232
1233         return err;
1234 }
1235
1236 /*============================================================================
1237  * Close network interface.
1238  * o if this is the last open, then disable communications and interrupts.
1239  * o reset flags.
1240  */
1241 static int if_close(struct net_device* dev)
1242 {
1243         fr_channel_t* chan = dev->priv;
1244         sdla_t* card = chan->card;
1245
1246         if (chan->inarp == INARP_CONFIGURED) {
1247                 chan->inarp = INARP_REQUEST;
1248         }
1249
1250         netif_stop_queue(dev);
1251         wanpipe_close(card);
1252
1253         return 0;
1254 }
1255
1256 /*============================================================================
1257  * Re-build media header.
1258  *
1259  * Return:      1       physical address resolved.
1260  *              0       physical address not resolved
1261  */
1262 static int if_rebuild_hdr (struct sk_buff* skb)
1263 {
1264         struct net_device *dev = skb->dev;
1265         fr_channel_t* chan = dev->priv;
1266         sdla_t* card = chan->card;
1267
1268         printk(KERN_INFO "%s: rebuild_header() called for interface %s!\n",
1269                 card->devname, dev->name);
1270         return 1;
1271 }
1272
1273 /*============================================================================
1274  * Handle transmit timeout event from netif watchdog
1275  */
1276 static void if_tx_timeout(struct net_device *dev)
1277 {
1278         fr_channel_t* chan = dev->priv;
1279         sdla_t *card = chan->card;
1280
1281         /* If our device stays busy for at least 5 seconds then we will
1282          * kick start the device by making dev->tbusy = 0.  We expect
1283          * that our device never stays busy more than 5 seconds. So this
1284          * is only used as a last resort.
1285          */
1286
1287         chan->drvstats_if_send.if_send_tbusy++;
1288         ++chan->ifstats.collisions;
1289
1290         printk (KERN_INFO "%s: Transmit timed out on %s\n",
1291                         card->devname, dev->name);
1292         chan->drvstats_if_send.if_send_tbusy_timeout++;
1293         netif_wake_queue (dev);
1294
1295 }
1296
1297
1298 /*============================================================================
1299  * Send a packet on a network interface.
1300  * o set tbusy flag (marks start of the transmission) to block a timer-based
1301  *   transmit from overlapping.
1302  * o set critical flag when accessing board.
1303  * o check link state. If link is not up, then drop the packet.
1304  * o check channel status. If it's down then initiate a call.
1305  * o pass a packet to corresponding WAN device.
1306  * o free socket buffer
1307  *
1308  * Return:      0       complete (socket buffer must be freed)
1309  *              non-0   packet may be re-transmitted (tbusy must be set)
1310  *
1311  * Notes:
1312  * 1. This routine is called either by the protocol stack or by the "net
1313  *    bottom half" (with interrupts enabled).
1314  *
1315  * 2. Using netif_start_queue() and netif_stop_queue()
1316  *    will inhibit further transmit requests from the protocol stack
1317  *    and can be used for flow control with protocol layer.
1318  */
1319 static int if_send(struct sk_buff* skb, struct net_device* dev)
1320 {
1321         fr_channel_t* chan = dev->priv;
1322         sdla_t* card = chan->card;
1323         int err;
1324         unsigned char *sendpacket;
1325         fr508_flags_t* adptr_flags = card->flags;
1326         int udp_type;
1327         long delay_tx_queued = 0;
1328         unsigned long smp_flags=0;
1329         unsigned char attr = 0;
1330
1331         chan->drvstats_if_send.if_send_entry++;
1332
1333         netif_stop_queue(dev);
1334
1335         if (skb == NULL) {
1336                 /* if we get here, some higher layer thinks we've missed an
1337                  * tx-done interrupt.
1338                  */
1339                 printk(KERN_INFO "%s: interface %s got kicked!\n",
1340                         card->devname, dev->name);
1341                 chan->drvstats_if_send.if_send_skb_null ++;
1342
1343                 netif_wake_queue(dev);
1344                 return 0;
1345         }
1346
1347         /* If a peripheral task is running just drop packets */
1348         if (test_bit(PERI_CRIT, &card->wandev.critical)){
1349
1350                 printk(KERN_INFO "%s: Critical in if_send(): Peripheral running!\n",
1351                                 card->devname);
1352
1353                 dev_kfree_skb_any(skb);
1354                 netif_start_queue(dev);
1355                 return 0;
1356         }
1357
1358         /* We must set the 'tbusy' flag if we already have a packet queued for
1359            transmission in the transmit interrupt handler. However, we must
1360            ensure that the transmit interrupt does not reset the 'tbusy' flag
1361            just before we set it, as this will result in a "transmit timeout".
1362         */
1363         set_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical);
1364         if(chan->transmit_length) {
1365                 netif_stop_queue(dev);
1366                 chan->tick_counter = jiffies;
1367                 clear_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical);
1368                 return 1;
1369         }
1370         clear_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical);
1371
1372         /* Move the if_header() code to here. By inserting frame
1373          * relay header in if_header() we would break the
1374          * tcpdump and other packet sniffers */
1375         chan->fr_header_len = setup_fr_header(&skb,dev,chan->common.usedby);
1376         if (chan->fr_header_len < 0 ){
1377                 ++chan->ifstats.tx_dropped;
1378                 ++card->wandev.stats.tx_dropped;
1379
1380                 dev_kfree_skb_any(skb);
1381                 netif_start_queue(dev);
1382                 return 0;
1383         }
1384
1385         sendpacket = skb->data;
1386
1387         udp_type = udp_pkt_type(skb, card);
1388
1389         if(udp_type != UDP_INVALID_TYPE) {
1390                 if(store_udp_mgmt_pkt(udp_type, UDP_PKT_FRM_STACK, card, skb,
1391                         chan->dlci)) {
1392                         adptr_flags->imask |= FR_INTR_TIMER;
1393                         if (udp_type == UDP_FPIPE_TYPE){
1394                                 chan->drvstats_if_send.
1395                                         if_send_PIPE_request ++;
1396                         }
1397                 }
1398                 netif_start_queue(dev);
1399                 return 0;
1400         }
1401
1402         //FIXME: can we do better than sendpacket[2]?
1403         if ((chan->common.usedby == WANPIPE) && (sendpacket[2] == 0x45)) {
1404
1405                 /* check to see if the source IP address is a broadcast or */
1406                 /* multicast IP address */
1407                 if(chk_bcast_mcast_addr(card, dev, skb)){
1408                         ++chan->ifstats.tx_dropped;
1409                         ++card->wandev.stats.tx_dropped;
1410                         dev_kfree_skb_any(skb);
1411                         netif_start_queue(dev);
1412                         return 0;
1413                 }
1414         }
1415
1416
1417         /* Lock the S514/S508 card: SMP Supported */
1418         s508_s514_lock(card,&smp_flags);
1419
1420         if (test_and_set_bit(SEND_CRIT, (void*)&card->wandev.critical)) {
1421
1422                 chan->drvstats_if_send.if_send_critical_non_ISR ++;
1423                 chan->ifstats.tx_dropped ++;
1424                 printk(KERN_INFO "%s Critical in IF_SEND: if_send() already running!\n",
1425                                 card->devname);
1426                 goto if_send_start_and_exit;
1427         }
1428
1429         /* API packet check: minimum packet size must be greater than
1430          * 16 byte API header */
1431         if((chan->common.usedby == API) && (skb->len <= sizeof(api_tx_hdr_t))) {
1432                 ++chan->ifstats.tx_dropped;
1433                 ++card->wandev.stats.tx_dropped;
1434
1435
1436                 goto if_send_start_and_exit;
1437
1438         }else{
1439                 /* During API transmission, get rid of the API header */
1440                 if (chan->common.usedby == API) {
1441                         api_tx_hdr_t* api_tx_hdr;
1442                         api_tx_hdr = (api_tx_hdr_t*)&skb->data[0x00];
1443                         attr = api_tx_hdr->attr;
1444                         skb_pull(skb,sizeof(api_tx_hdr_t));
1445                 }
1446         }
1447
1448         if (card->wandev.state != WAN_CONNECTED) {
1449                 chan->drvstats_if_send.if_send_wan_disconnected ++;
1450                 ++chan->ifstats.tx_dropped;
1451                 ++card->wandev.stats.tx_dropped;
1452
1453         } else if (chan->common.state != WAN_CONNECTED) {
1454                 chan->drvstats_if_send.if_send_dlci_disconnected ++;
1455
1456                 /* Update the DLCI state in timer interrupt */
1457                 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UPDATE_STATE;
1458                 adptr_flags->imask |= FR_INTR_TIMER;
1459
1460                 ++chan->ifstats.tx_dropped;
1461                 ++card->wandev.stats.tx_dropped;
1462
1463         } else if (!is_tx_ready(card, chan)) {
1464                 /* No tx buffers available, store for delayed transmit */
1465                 if (!setup_for_delayed_transmit(dev, skb)){
1466                         set_bit(1,&delay_tx_queued);
1467                 }
1468                 chan->drvstats_if_send.if_send_no_bfrs++;
1469
1470         } else if (!skb->protocol) {
1471                 /* No protocols drop packet */
1472                 chan->drvstats_if_send.if_send_protocol_error ++;
1473                 ++card->wandev.stats.tx_errors;
1474
1475         } else if (test_bit(ARP_CRIT,&card->wandev.critical)){
1476                 /* We are trying to send an ARP Packet, block IP data until
1477                  * ARP is sent */
1478                 ++chan->ifstats.tx_dropped;
1479                 ++card->wandev.stats.tx_dropped;
1480
1481         } else {
1482                 //FIXME: IPX is not implemented in this version of Frame Relay ?
1483                 if((chan->common.usedby == WANPIPE) &&
1484                         sendpacket[1] == 0x00 &&
1485                         sendpacket[2] == 0x80 &&
1486                         sendpacket[6] == 0x81 &&
1487                         sendpacket[7] == 0x37) {
1488
1489                         if( chan->enable_IPX ) {
1490                                 switch_net_numbers(sendpacket,
1491                                                 chan->network_number, 0);
1492                         } else {
1493                                 //FIXME: Take this out when IPX is fixed
1494                                 printk(KERN_INFO
1495                                 "%s: WARNING: Unsupported IPX data in send, packet dropped\n",
1496                                         card->devname);
1497                         }
1498
1499                 }else{
1500                         err = fr_send_data_header(card, chan->dlci, attr, skb->len, skb->data, chan->fr_header_len);
1501                         if (err) {
1502                                 switch(err) {
1503                                 case FRRES_CIR_OVERFLOW:
1504                                 case FRRES_BUFFER_OVERFLOW:
1505                                         if (!setup_for_delayed_transmit(dev, skb)){
1506                                                 set_bit(1,&delay_tx_queued);
1507                                         }
1508                                         chan->drvstats_if_send.
1509                                                 if_send_adptr_bfrs_full ++;
1510                                         break;
1511
1512                                 case FRRES_TOO_LONG:
1513                                         if (net_ratelimit()){
1514                                                 printk(KERN_INFO
1515                                                 "%s: Error: Frame too long, transmission failed %i\n",
1516                                                  card->devname, (unsigned int)skb->len);
1517                                         }
1518                                         /* Drop down to default */
1519                                 default:
1520                                         chan->drvstats_if_send.
1521                                                 if_send_dlci_disconnected ++;
1522                                         ++chan->ifstats.tx_dropped;
1523                                         ++card->wandev.stats.tx_dropped;
1524                                         break;
1525                                 }
1526                         } else {
1527                                 chan->drvstats_if_send.
1528                                         if_send_bfr_passed_to_adptr++;
1529                                 ++chan->ifstats.tx_packets;
1530                                 ++card->wandev.stats.tx_packets;
1531
1532                                 chan->ifstats.tx_bytes += skb->len;
1533                                 card->wandev.stats.tx_bytes += skb->len;
1534                                 dev->trans_start = jiffies;
1535                         }
1536                 }
1537         }
1538
1539 if_send_start_and_exit:
1540
1541         netif_start_queue(dev);
1542
1543         /* If we queued the packet for transmission, we must not
1544          * deallocate it. The packet is unlinked from the IP stack
1545          * not copied. Therefore, we must keep the original packet */
1546         if (!test_bit(1,&delay_tx_queued)) {
1547                 dev_kfree_skb_any(skb);
1548         }else{
1549                 adptr_flags->imask |= FR_INTR_TXRDY;
1550                 card->u.f.tx_interrupts_pending ++;
1551         }
1552
1553         clear_bit(SEND_CRIT, (void*)&card->wandev.critical);
1554
1555         s508_s514_unlock(card,&smp_flags);
1556
1557         return 0;
1558 }
1559
1560
1561
1562 /*============================================================================
1563  * Setup so that a frame can be transmitted on the occurrence of a transmit
1564  * interrupt.
1565  */
1566 static int setup_for_delayed_transmit(struct net_device* dev,
1567                                       struct sk_buff *skb)
1568 {
1569         fr_channel_t* chan = dev->priv;
1570         sdla_t* card = chan->card;
1571         fr_dlci_interface_t* dlci_interface;
1572         int len = skb->len;
1573
1574         /* Check that the dlci is properly configured,
1575          * before using tx interrupt */
1576         if (!chan->dlci_int_interface){
1577                 if (net_ratelimit()){
1578                         printk(KERN_INFO
1579                                 "%s: ERROR on DLCI %i: Not configured properly !\n",
1580                                         card->devname, chan->dlci);
1581                         printk(KERN_INFO "%s: Please contact Sangoma Technologies\n",
1582                                         card->devname);
1583                 }
1584                 return 1;
1585         }
1586
1587         dlci_interface = chan->dlci_int_interface;
1588
1589         if(chan->transmit_length) {
1590                 printk(KERN_INFO "%s: Big mess in setup_for_del...\n",
1591                                 card->devname);
1592                 return 1;
1593         }
1594
1595         if(len > FR_MAX_NO_DATA_BYTES_IN_FRAME) {
1596                 //FIXME: increment some statistic */
1597                 return 1;
1598         }
1599
1600         skb_unlink(skb);
1601
1602         chan->transmit_length = len;
1603         chan->delay_skb = skb;
1604
1605         dlci_interface->gen_interrupt |= FR_INTR_TXRDY;
1606         dlci_interface->packet_length = len;
1607
1608         /* Turn on TX interrupt at the end of if_send */
1609         return 0;
1610 }
1611
1612
1613 /*============================================================================
1614  * Check to see if the packet to be transmitted contains a broadcast or
1615  * multicast source IP address.
1616  * Return 0 if not broadcast/multicast address, otherwise return 1.
1617  */
1618
1619 static int chk_bcast_mcast_addr(sdla_t *card, struct net_device* dev,
1620                                 struct sk_buff *skb)
1621 {
1622         u32 src_ip_addr;
1623         u32 broadcast_ip_addr = 0;
1624         struct in_device *in_dev;
1625         fr_channel_t* chan = dev->priv;
1626
1627         /* read the IP source address from the outgoing packet */
1628         src_ip_addr = *(u32 *)(skb->data + 14);
1629
1630         /* read the IP broadcast address for the device */
1631         in_dev = dev->ip_ptr;
1632         if(in_dev != NULL) {
1633                 struct in_ifaddr *ifa= in_dev->ifa_list;
1634                 if(ifa != NULL)
1635                         broadcast_ip_addr = ifa->ifa_broadcast;
1636                 else
1637                         return 0;
1638         }
1639
1640         /* check if the IP Source Address is a Broadcast address */
1641         if((dev->flags & IFF_BROADCAST) && (src_ip_addr == broadcast_ip_addr)) {
1642                 printk(KERN_INFO
1643                         "%s: Broadcast Source Address silently discarded\n",
1644                         card->devname);
1645                 return 1;
1646         }
1647
1648         /* check if the IP Source Address is a Multicast address */
1649         if((chan->mc == WANOPT_NO) && (ntohl(src_ip_addr) >= 0xE0000001) &&
1650                 (ntohl(src_ip_addr) <= 0xFFFFFFFE)) {
1651                 printk(KERN_INFO
1652                         "%s: Multicast Source Address silently discarded\n",
1653                         card->devname);
1654                 return 1;
1655         }
1656
1657         return 0;
1658 }
1659
1660 /*============================================================================
1661  * Reply to UDP Management system.
1662  * Return nothing.
1663  */
1664 static int reply_udp( unsigned char *data, unsigned int mbox_len )
1665 {
1666         unsigned short len, udp_length, temp, ip_length;
1667         unsigned long ip_temp;
1668         int even_bound = 0;
1669
1670
1671         fr_udp_pkt_t *fr_udp_pkt = (fr_udp_pkt_t *)data;
1672
1673         /* Set length of packet */
1674         len = //sizeof(fr_encap_hdr_t)+
1675               sizeof(ip_pkt_t)+
1676               sizeof(udp_pkt_t)+
1677               sizeof(wp_mgmt_t)+
1678               sizeof(cblock_t)+
1679               mbox_len;
1680
1681
1682         /* fill in UDP reply */
1683         fr_udp_pkt->wp_mgmt.request_reply = UDPMGMT_REPLY;
1684
1685         /* fill in UDP length */
1686         udp_length = sizeof(udp_pkt_t)+
1687                      sizeof(wp_mgmt_t)+
1688                      sizeof(cblock_t)+
1689                      mbox_len;
1690
1691
1692         /* put it on an even boundary */
1693         if ( udp_length & 0x0001 ) {
1694                 udp_length += 1;
1695                 len += 1;
1696                 even_bound = 1;
1697         }
1698
1699         temp = (udp_length<<8)|(udp_length>>8);
1700         fr_udp_pkt->udp_pkt.udp_length = temp;
1701
1702         /* swap UDP ports */
1703         temp = fr_udp_pkt->udp_pkt.udp_src_port;
1704         fr_udp_pkt->udp_pkt.udp_src_port =
1705                         fr_udp_pkt->udp_pkt.udp_dst_port;
1706         fr_udp_pkt->udp_pkt.udp_dst_port = temp;
1707
1708
1709
1710         /* add UDP pseudo header */
1711         temp = 0x1100;
1712         *((unsigned short *)
1713                 (fr_udp_pkt->data+mbox_len+even_bound)) = temp;
1714         temp = (udp_length<<8)|(udp_length>>8);
1715         *((unsigned short *)
1716                 (fr_udp_pkt->data+mbox_len+even_bound+2)) = temp;
1717
1718         /* calculate UDP checksum */
1719         fr_udp_pkt->udp_pkt.udp_checksum = 0;
1720
1721         fr_udp_pkt->udp_pkt.udp_checksum =
1722                 calc_checksum(&data[UDP_OFFSET/*+sizeof(fr_encap_hdr_t)*/],
1723                               udp_length+UDP_OFFSET);
1724
1725         /* fill in IP length */
1726         ip_length = udp_length + sizeof(ip_pkt_t);
1727         temp = (ip_length<<8)|(ip_length>>8);
1728         fr_udp_pkt->ip_pkt.total_length = temp;
1729
1730         /* swap IP addresses */
1731         ip_temp = fr_udp_pkt->ip_pkt.ip_src_address;
1732         fr_udp_pkt->ip_pkt.ip_src_address =
1733                                 fr_udp_pkt->ip_pkt.ip_dst_address;
1734         fr_udp_pkt->ip_pkt.ip_dst_address = ip_temp;
1735
1736
1737         /* fill in IP checksum */
1738         fr_udp_pkt->ip_pkt.hdr_checksum = 0;
1739         fr_udp_pkt->ip_pkt.hdr_checksum =
1740                 calc_checksum(&data[/*sizeof(fr_encap_hdr_t)*/0],
1741                               sizeof(ip_pkt_t));
1742
1743         return len;
1744 } /* reply_udp */
1745
1746 unsigned short calc_checksum (char *data, int len)
1747 {
1748         unsigned short temp;
1749         unsigned long sum=0;
1750         int i;
1751
1752         for( i = 0; i <len; i+=2 ) {
1753                 memcpy(&temp,&data[i],2);
1754                 sum += (unsigned long)temp;
1755         }
1756
1757         while (sum >> 16 ) {
1758                 sum = (sum & 0xffffUL) + (sum >> 16);
1759         }
1760
1761         temp = (unsigned short)sum;
1762         temp = ~temp;
1763
1764         if( temp == 0 )
1765                 temp = 0xffff;
1766
1767         return temp;
1768 }
1769
1770 /*
1771    If incoming is 0 (outgoing)- if the net numbers is ours make it 0
1772    if incoming is 1 - if the net number is 0 make it ours
1773
1774 */
1775 static void switch_net_numbers(unsigned char *sendpacket, unsigned long network_number, unsigned char incoming)
1776 {
1777         unsigned long pnetwork_number;
1778
1779         pnetwork_number = (unsigned long)((sendpacket[14] << 24) +
1780                           (sendpacket[15] << 16) + (sendpacket[16] << 8) +
1781                           sendpacket[17]);
1782
1783         if (!incoming) {
1784                 /* If the destination network number is ours, make it 0 */
1785                 if( pnetwork_number == network_number) {
1786                         sendpacket[14] = sendpacket[15] = sendpacket[16] =
1787                                          sendpacket[17] = 0x00;
1788                 }
1789         } else {
1790                 /* If the incoming network is 0, make it ours */
1791                 if( pnetwork_number == 0) {
1792                         sendpacket[14] = (unsigned char)(network_number >> 24);
1793                         sendpacket[15] = (unsigned char)((network_number &
1794                                          0x00FF0000) >> 16);
1795                         sendpacket[16] = (unsigned char)((network_number &
1796                                          0x0000FF00) >> 8);
1797                         sendpacket[17] = (unsigned char)(network_number &
1798                                          0x000000FF);
1799                 }
1800         }
1801
1802
1803         pnetwork_number = (unsigned long)((sendpacket[26] << 24) +
1804                           (sendpacket[27] << 16) + (sendpacket[28] << 8) +
1805                           sendpacket[29]);
1806
1807         if( !incoming ) {
1808                 /* If the source network is ours, make it 0 */
1809                 if( pnetwork_number == network_number) {
1810                         sendpacket[26] = sendpacket[27] = sendpacket[28] =
1811                                          sendpacket[29] = 0x00;
1812                 }
1813         } else {
1814                 /* If the source network is 0, make it ours */
1815                 if( pnetwork_number == 0 ) {
1816                         sendpacket[26] = (unsigned char)(network_number >> 24);
1817                         sendpacket[27] = (unsigned char)((network_number &
1818                                          0x00FF0000) >> 16);
1819                         sendpacket[28] = (unsigned char)((network_number &
1820                                          0x0000FF00) >> 8);
1821                         sendpacket[29] = (unsigned char)(network_number &
1822                                          0x000000FF);
1823                 }
1824         }
1825 } /* switch_net_numbers */
1826
1827 /*============================================================================
1828  * Get ethernet-style interface statistics.
1829  * Return a pointer to struct enet_statistics.
1830  */
1831 static struct net_device_stats *if_stats(struct net_device *dev)
1832 {
1833         fr_channel_t* chan = dev->priv;
1834
1835         if(chan == NULL)
1836                 return NULL;
1837
1838         return &chan->ifstats;
1839 }
1840
1841 /****** Interrupt Handlers **************************************************/
1842
1843 /*============================================================================
1844  * fr_isr:      S508 frame relay interrupt service routine.
1845  *
1846  * Description:
1847  *      Frame relay main interrupt service route. This
1848  *      function check the interrupt type and takes
1849  *      the appropriate action.
1850  */
1851 static void fr_isr (sdla_t* card)
1852 {
1853         fr508_flags_t* flags = card->flags;
1854         char *ptr = &flags->iflag;
1855         int i,err;
1856         fr_mbox_t* mbox = card->mbox;
1857
1858         /* This flag prevents nesting of interrupts.  See sdla_isr() routine
1859          * in sdlamain.c.  */
1860         card->in_isr = 1;
1861
1862         ++card->statistics.isr_entry;
1863
1864
1865         /* All peripheral (configuraiton, re-configuration) events
1866          * take presidence over the ISR.  Thus, retrigger */
1867         if (test_bit(PERI_CRIT, (void*)&card->wandev.critical)) {
1868                 ++card->statistics.isr_already_critical;
1869                 goto fr_isr_exit;
1870         }
1871
1872         if(card->hw.type != SDLA_S514) {
1873                 if (test_bit(SEND_CRIT, (void*)&card->wandev.critical)) {
1874                         printk(KERN_INFO "%s: Critical while in ISR: If Send Running!\n",
1875                                 card->devname);
1876                         ++card->statistics.isr_already_critical;
1877                         goto fr_isr_exit;
1878                 }
1879         }
1880
1881         switch (flags->iflag) {
1882
1883                 case FR_INTR_RXRDY:  /* receive interrupt */
1884                         ++card->statistics.isr_rx;
1885                         rx_intr(card);
1886                         break;
1887
1888
1889                 case FR_INTR_TXRDY:  /* transmit interrupt */
1890                         ++ card->statistics.isr_tx;
1891                         tx_intr(card);
1892                         break;
1893
1894                 case FR_INTR_READY:
1895                         Intr_test_counter++;
1896                         ++card->statistics.isr_intr_test;
1897                         break;
1898
1899                 case FR_INTR_DLC: /* Event interrupt occurred */
1900                         mbox->cmd.command = FR_READ_STATUS;
1901                         mbox->cmd.length = 0;
1902                         err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
1903                         if (err)
1904                                 fr_event(card, err, mbox);
1905                         break;
1906
1907                 case FR_INTR_TIMER:  /* Timer interrupt */
1908                         timer_intr(card);
1909                         break;
1910
1911                 default:
1912                         ++card->statistics.isr_spurious;
1913                         spur_intr(card);
1914                         printk(KERN_INFO "%s: Interrupt Type 0x%02X!\n",
1915                                 card->devname, flags->iflag);
1916
1917                         printk(KERN_INFO "%s: ID Bytes = ",card->devname);
1918                         for(i = 0; i < 8; i ++)
1919                                 printk(KERN_INFO "0x%02X ", *(ptr + 0x28 + i));
1920                         printk(KERN_INFO "\n");
1921
1922                         break;
1923         }
1924
1925 fr_isr_exit:
1926
1927         card->in_isr = 0;
1928         flags->iflag = 0;
1929         return;
1930 }
1931
1932
1933
1934 /*===========================================================
1935  * rx_intr      Receive interrupt handler.
1936  *
1937  * Description
1938  *      Upon receiveing an interrupt:
1939  *      1. Check that the firmware is in sync with
1940  *         the driver.
1941  *      2. Find an appropriate network interface
1942  *         based on the received dlci number.
1943  *      3. Check that the netowrk interface exists
1944  *         and that it's setup properly.
1945  *      4. Copy the data into an skb buffer.
1946  *      5. Check the packet type and take
1947  *         appropriate acton: UPD, API, ARP or Data.
1948  */
1949
1950 static void rx_intr (sdla_t* card)
1951 {
1952         fr_rx_buf_ctl_t* frbuf = card->rxmb;
1953         fr508_flags_t* flags = card->flags;
1954         fr_channel_t* chan;
1955         char *ptr = &flags->iflag;
1956         struct sk_buff* skb;
1957         struct net_device* dev;
1958         void* buf;
1959         unsigned dlci, len, offs, len_incl_hdr;
1960         int i, udp_type;
1961
1962
1963         /* Check that firmware buffers are in sync */
1964         if (frbuf->flag != 0x01) {
1965
1966                 printk(KERN_INFO
1967                         "%s: corrupted Rx buffer @ 0x%X, flag = 0x%02X!\n",
1968                         card->devname, (unsigned)frbuf, frbuf->flag);
1969
1970                 printk(KERN_INFO "%s: ID Bytes = ",card->devname);
1971                 for(i = 0; i < 8; i ++)
1972                         printk(KERN_INFO "0x%02X ", *(ptr + 0x28 + i));
1973                 printk(KERN_INFO "\n");
1974
1975                 ++card->statistics.rx_intr_corrupt_rx_bfr;
1976
1977                 /* Bug Fix: Mar 6 2000
1978                  * If we get a corrupted mailbox, it means that driver
1979                  * is out of sync with the firmware. There is no recovery.
1980                  * If we don't turn off all interrupts for this card
1981                  * the machine will crash.
1982                  */
1983                 printk(KERN_INFO "%s: Critical router failure ...!!!\n", card->devname);
1984                 printk(KERN_INFO "Please contact Sangoma Technologies !\n");
1985                 fr_set_intr_mode(card, 0, 0, 0);
1986                 return;
1987         }
1988
1989         len  = frbuf->length;
1990         dlci = frbuf->dlci;
1991         offs = frbuf->offset;
1992
1993         /* Find the network interface for this packet */
1994         dev = find_channel(card, dlci);
1995
1996
1997         /* Check that the network interface is active and
1998          * properly setup */
1999         if (dev == NULL) {
2000                 if( net_ratelimit()) {
2001                         printk(KERN_INFO "%s: received data on unconfigured DLCI %d!\n",
2002                                                 card->devname, dlci);
2003                 }
2004                 ++card->statistics.rx_intr_on_orphaned_DLCI;
2005                 ++card->wandev.stats.rx_dropped;
2006                 goto rx_done;
2007         }
2008
2009         if ((chan = dev->priv) == NULL){
2010                 if( net_ratelimit()) {
2011                         printk(KERN_INFO "%s: received data on unconfigured DLCI %d!\n",
2012                                                 card->devname, dlci);
2013                 }
2014                 ++card->statistics.rx_intr_on_orphaned_DLCI;
2015                 ++card->wandev.stats.rx_dropped;
2016                 goto rx_done;
2017         }
2018
2019         skb = dev_alloc_skb(len);
2020
2021         if (!netif_running(dev) || (skb == NULL)){
2022
2023                 ++chan->ifstats.rx_dropped;
2024
2025                 if(skb == NULL) {
2026                         if (net_ratelimit()) {
2027                                 printk(KERN_INFO
2028                                         "%s: no socket buffers available!\n",
2029                                                 card->devname);
2030                         }
2031                         chan->drvstats_rx_intr.rx_intr_no_socket ++;
2032                 }
2033
2034                 if (!netif_running(dev)){
2035                         chan->drvstats_rx_intr.
2036                                 rx_intr_dev_not_started ++;
2037                         if (skb){
2038                                 dev_kfree_skb_any(skb);
2039                         }
2040                 }
2041                 goto rx_done;
2042         }
2043
2044         /* Copy data from the board into the socket buffer */
2045         if ((offs + len) > card->u.f.rx_top + 1) {
2046                 unsigned tmp = card->u.f.rx_top - offs + 1;
2047
2048                 buf = skb_put(skb, tmp);
2049                 sdla_peek(&card->hw, offs, buf, tmp);
2050                 offs = card->u.f.rx_base;
2051                 len -= tmp;
2052         }
2053
2054         buf = skb_put(skb, len);
2055         sdla_peek(&card->hw, offs, buf, len);
2056
2057
2058         /* We got the packet from the bard.
2059          * Check the packet type and take appropriate action */
2060
2061         udp_type = udp_pkt_type( skb, card );
2062
2063         if(udp_type != UDP_INVALID_TYPE) {
2064
2065                 /* UDP Debug packet received, store the
2066                  * packet and handle it in timer interrupt */
2067
2068                 skb_pull(skb, 1);
2069                 if (wanrouter_type_trans(skb, dev)){
2070                         if(store_udp_mgmt_pkt(udp_type,UDP_PKT_FRM_NETWORK,card,skb,dlci)){
2071
2072                                 flags->imask |= FR_INTR_TIMER;
2073
2074                                 if (udp_type == UDP_FPIPE_TYPE){
2075                                         ++chan->drvstats_rx_intr.rx_intr_PIPE_request;
2076                                 }
2077                         }
2078                 }
2079
2080         }else if (chan->common.usedby == API) {
2081
2082                 /* We are in API mode.
2083                  * Add an API header to the RAW packet
2084                  * and queue it into a circular buffer.
2085                  * Then kick the fr_bh() bottom half handler */
2086
2087                 api_rx_hdr_t* api_rx_hdr;
2088                 chan->drvstats_rx_intr.rx_intr_bfr_passed_to_stack ++;
2089                 chan->ifstats.rx_packets ++;
2090                 card->wandev.stats.rx_packets ++;
2091
2092                 chan->ifstats.rx_bytes += skb->len;
2093                 card->wandev.stats.rx_bytes += skb->len;
2094
2095                 skb_push(skb, sizeof(api_rx_hdr_t));
2096                 api_rx_hdr = (api_rx_hdr_t*)&skb->data[0x00];
2097                 api_rx_hdr->attr = frbuf->attr;
2098                 api_rx_hdr->time_stamp = frbuf->tmstamp;
2099
2100                 skb->protocol = htons(ETH_P_IP);
2101                 skb->mac.raw  = skb->data;
2102                 skb->dev      = dev;
2103                 skb->pkt_type = WAN_PACKET_DATA;
2104
2105                 bh_enqueue(dev, skb);
2106
2107                 trigger_fr_bh(chan);
2108
2109         }else if (handle_IPXWAN(skb->data,chan->name,chan->enable_IPX, chan->network_number)){
2110
2111                 //FIXME: Frame Relay IPX is not supported, Yet !
2112                 //if (chan->enable_IPX) {
2113                 //      fr_send(card, dlci, 0, skb->len,skb->data);
2114                 //}
2115                 dev_kfree_skb_any(skb);
2116
2117         } else if (is_arp(skb->data)) {
2118
2119                 /* ARP support enabled Mar 16 2000
2120                  * Process incoming ARP reply/request, setup
2121                  * dynamic routes. */
2122
2123                 if (process_ARP((arphdr_1490_t *)skb->data, card, dev)) {
2124                         if (net_ratelimit()){
2125                                 printk (KERN_INFO
2126                                    "%s: Error processing ARP Packet.\n",
2127                                         card->devname);
2128                         }
2129                 }
2130                 dev_kfree_skb_any(skb);
2131
2132         } else if (skb->data[0] != 0x03) {
2133
2134                 if (net_ratelimit()) {
2135                         printk(KERN_INFO "%s: Non IETF packet discarded.\n",
2136                                 card->devname);
2137                 }
2138                 dev_kfree_skb_any(skb);
2139
2140         } else {
2141
2142                 len_incl_hdr = skb->len;
2143                 /* Decapsulate packet and pass it up the
2144                    protocol stack */
2145                 skb->dev = dev;
2146
2147                 if (chan->common.usedby == BRIDGE || chan->common.usedby == BRIDGE_NODE){
2148
2149                         /* Make sure it's an Ethernet frame, otherwise drop it */
2150                         if (!memcmp(skb->data, "\x03\x00\x80\x00\x80\xC2\x00\x07", 8)) {
2151                                 skb_pull(skb, 8);
2152                                 skb->protocol=eth_type_trans(skb,dev);
2153                         }else{
2154                                 ++chan->drvstats_rx_intr.rx_intr_bfr_not_passed_to_stack;
2155                                 ++chan->ifstats.rx_errors;
2156                                 ++card->wandev.stats.rx_errors;
2157                                 goto rx_done;
2158                         }
2159                 }else{
2160
2161                         /* remove hardware header */
2162                         buf = skb_pull(skb, 1);
2163
2164                         if (!wanrouter_type_trans(skb, dev)) {
2165
2166                                 /* can't decapsulate packet */
2167                                 dev_kfree_skb_any(skb);
2168
2169                                 ++chan->drvstats_rx_intr.rx_intr_bfr_not_passed_to_stack;
2170                                 ++chan->ifstats.rx_errors;
2171                                 ++card->wandev.stats.rx_errors;
2172                                 goto rx_done;
2173                         }
2174                         skb->mac.raw = skb->data;
2175                 }
2176
2177
2178                 /* Send a packet up the IP stack */
2179                 skb->dev->last_rx = jiffies;
2180                 netif_rx(skb);
2181                 ++chan->drvstats_rx_intr.rx_intr_bfr_passed_to_stack;
2182                 ++chan->ifstats.rx_packets;
2183                 ++card->wandev.stats.rx_packets;
2184
2185                 chan->ifstats.rx_bytes += len_incl_hdr;
2186                 card->wandev.stats.rx_bytes += len_incl_hdr;
2187         }
2188
2189 rx_done:
2190
2191         /* Release buffer element and calculate a pointer to the next one */
2192         frbuf->flag = 0;
2193         card->rxmb = ++frbuf;
2194         if ((void*)frbuf > card->u.f.rxmb_last)
2195                 card->rxmb = card->u.f.rxmb_base;
2196
2197 }
2198
2199 /*==================================================================
2200  * tx_intr:     Transmit interrupt handler.
2201  *
2202  * Rationale:
2203  *      If the board is busy transmitting, if_send() will
2204  *      buffers a single packet and turn on
2205  *      the tx interrupt. Tx interrupt will be called
2206  *      by the board, once the firmware can send more
2207  *      data. Thus, no polling is required.
2208  *
2209  * Description:
2210  *      Tx interrupt is called for each
2211  *      configured dlci channel. Thus:
2212  *      1. Obtain the netowrk interface based on the
2213  *         dlci number.
2214  *      2. Check that network interface is up and
2215  *         properly setup.
2216  *      3. Check for a buffered packet.
2217  *      4. Transmit the packet.
2218  *      5. If we are in WANPIPE mode, mark the
2219  *         NET_BH handler.
2220  *      6. If we are in API mode, kick
2221  *         the AF_WANPIPE socket for more data.
2222  *
2223  */
2224 static void tx_intr(sdla_t *card)
2225 {
2226         fr508_flags_t* flags = card->flags;
2227         fr_tx_buf_ctl_t* bctl;
2228         struct net_device* dev;
2229         fr_channel_t* chan;
2230
2231         if(card->hw.type == SDLA_S514){
2232                 bctl = (void*)(flags->tse_offs + card->hw.dpmbase);
2233         }else{
2234                 bctl = (void*)(flags->tse_offs - FR_MB_VECTOR +
2235                         card->hw.dpmbase);
2236         }
2237
2238         /* Find the structure and make it unbusy */
2239         dev = find_channel(card, flags->dlci);
2240         if (dev == NULL){
2241                 printk(KERN_INFO "NO DEV IN TX Interrupt\n");
2242                 goto end_of_tx_intr;
2243         }
2244
2245         if ((chan = dev->priv) == NULL){
2246                 printk(KERN_INFO "NO CHAN IN TX Interrupt\n");
2247                 goto end_of_tx_intr;
2248         }
2249
2250         if(!chan->transmit_length || !chan->delay_skb) {
2251                 printk(KERN_INFO "%s: tx int error - transmit length zero\n",
2252                                 card->wandev.name);
2253                 goto end_of_tx_intr;
2254         }
2255
2256         /* If the 'if_send()' procedure is currently checking the 'tbusy'
2257            status, then we cannot transmit. Instead, we configure the microcode
2258            so as to re-issue this transmit interrupt at a later stage.
2259         */
2260         if (test_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical)) {
2261
2262                 fr_dlci_interface_t* dlci_interface = chan->dlci_int_interface;
2263                 bctl->flag = 0xA0;
2264                 dlci_interface->gen_interrupt |= FR_INTR_TXRDY;
2265                 return;
2266
2267         }else{
2268                 bctl->dlci = flags->dlci;
2269                 bctl->length = chan->transmit_length+chan->fr_header_len;
2270                 sdla_poke(&card->hw,
2271                           fr_send_hdr(card,bctl->dlci,bctl->offset),
2272                           chan->delay_skb->data,
2273                           chan->delay_skb->len);
2274                 bctl->flag = 0xC0;
2275
2276                 ++chan->ifstats.tx_packets;
2277                 ++card->wandev.stats.tx_packets;
2278                 chan->ifstats.tx_bytes += chan->transmit_length;
2279                 card->wandev.stats.tx_bytes += chan->transmit_length;
2280
2281                 /* We must free an sk buffer, which we used
2282                  * for delayed transmission; Otherwise, the sock
2283                  * will run out of memory */
2284                 dev_kfree_skb_any(chan->delay_skb);
2285
2286                 chan->delay_skb = NULL;
2287                 chan->transmit_length = 0;
2288
2289                 dev->trans_start = jiffies;
2290
2291                 if (netif_queue_stopped(dev)){
2292                         /* If using API, than wakeup socket BH handler */
2293                         if (chan->common.usedby == API){
2294                                 netif_start_queue(dev);
2295                                 wakeup_sk_bh(dev);
2296                         }else{
2297                                 netif_wake_queue(dev);
2298                         }
2299                 }
2300         }
2301
2302 end_of_tx_intr:
2303
2304         /* if any other interfaces have transmit interrupts pending,
2305          * do not disable the global transmit interrupt */
2306         if(!(-- card->u.f.tx_interrupts_pending))
2307                 flags->imask &= ~FR_INTR_TXRDY;
2308
2309
2310 }
2311
2312
2313 /*============================================================================
2314  * timer_intr:  Timer interrupt handler.
2315  *
2316  * Rationale:
2317  *      All commans must be executed within the timer
2318  *      interrupt since no two commands should execute
2319  *      at the same time.
2320  *
2321  * Description:
2322  *      The timer interrupt is used to:
2323  *      1. Processing udp calls from 'fpipemon'.
2324  *      2. Processing update calls from /proc file system
2325  *      3. Reading board-level statistics for
2326  *         updating the proc file system.
2327  *      4. Sending inverse ARP request packets.
2328  *      5. Configure a dlci/channel.
2329  *      6. Unconfigure a dlci/channel. (Node only)
2330  */
2331
2332 static void timer_intr(sdla_t *card)
2333 {
2334         fr508_flags_t* flags = card->flags;
2335
2336         /* UDP Debuging: fpipemon call */
2337         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UDP) {
2338                 if(card->u.f.udp_type == UDP_FPIPE_TYPE) {
2339                         if(process_udp_mgmt_pkt(card)) {
2340                                 card->u.f.timer_int_enabled &=
2341                                         ~TMR_INT_ENABLED_UDP;
2342                         }
2343                 }
2344         }
2345
2346         /* /proc update call : triggered from update() */
2347         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UPDATE) {
2348                 fr_get_err_stats(card);
2349                 fr_get_stats(card);
2350                 card->u.f.update_comms_stats = 0;
2351                 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE;
2352         }
2353
2354         /* Update the channel state call.  This is call is
2355          * triggered by if_send() function */
2356         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UPDATE_STATE){
2357                 struct net_device *dev;
2358                 if (card->wandev.state == WAN_CONNECTED){
2359                         for (dev = card->wandev.dev; dev;
2360                              dev = *((struct net_device **)dev->priv)){
2361                                 fr_channel_t *chan = dev->priv;
2362                                 if (chan->common.state != WAN_CONNECTED){
2363                                         update_chan_state(dev);
2364                                 }
2365                         }
2366                 }
2367                 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE_STATE;
2368         }
2369
2370         /* configure a dlci/channel */
2371         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_CONFIG){
2372                 config_fr(card);
2373                 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_CONFIG;
2374         }
2375
2376         /* unconfigure a dlci/channel */
2377         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UNCONFIG){
2378                 unconfig_fr(card);
2379                 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UNCONFIG;
2380         }
2381
2382
2383         /* Transmit ARP packets */
2384         if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_ARP){
2385                 int i=0;
2386                 struct net_device *dev;
2387
2388                 if (card->u.f.arp_dev == NULL)
2389                         card->u.f.arp_dev = card->wandev.dev;
2390
2391                 dev = card->u.f.arp_dev;
2392
2393                 for (;;){
2394
2395                         fr_channel_t *chan = dev->priv;
2396
2397                         /* If the interface is brought down cancel sending In-ARPs */
2398                         if (!(dev->flags&IFF_UP)){
2399                                 clear_bit(0,&chan->inarp_ready);
2400                         }
2401
2402                         if (test_bit(0,&chan->inarp_ready)){
2403
2404                                 if (check_tx_status(card,dev)){
2405                                         set_bit(ARP_CRIT,&card->wandev.critical);
2406                                         break;
2407                                 }
2408
2409                                 if (!send_inarp_request(card,dev)){
2410                                         trigger_fr_arp(dev);
2411                                         chan->inarp_tick = jiffies;
2412                                 }
2413
2414                                 clear_bit(0,&chan->inarp_ready);
2415                                 dev = move_dev_to_next(card,dev);
2416                                 break;
2417                         }
2418                         dev = move_dev_to_next(card,dev);
2419
2420                         if (++i == card->wandev.new_if_cnt){
2421                                 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_ARP;
2422                                 break;
2423                         }
2424                 }
2425                 card->u.f.arp_dev = dev;
2426         }
2427
2428         if(!card->u.f.timer_int_enabled)
2429                 flags->imask &= ~FR_INTR_TIMER;
2430 }
2431
2432
2433 /*============================================================================
2434  * spur_intr:   Spurious interrupt handler.
2435  *
2436  * Description:
2437  *      We don't know this interrupt.
2438  *      Print a warning.
2439  */
2440
2441 static void spur_intr (sdla_t* card)
2442 {
2443         if (net_ratelimit()){
2444                 printk(KERN_INFO "%s: spurious interrupt!\n", card->devname);
2445         }
2446 }
2447
2448
2449 //FIXME: Fix the IPX in next version
2450 /*===========================================================================
2451  *  Return 0 for non-IPXWAN packet
2452  *         1 for IPXWAN packet or IPX is not enabled!
2453  *  FIXME: Use a IPX structure here not offsets
2454  */
2455 static int handle_IPXWAN(unsigned char *sendpacket,
2456                          char *devname, unsigned char enable_IPX,
2457                          unsigned long network_number)
2458 {
2459         int i;
2460
2461         if( sendpacket[1] == 0x00 && sendpacket[2] == 0x80 &&
2462             sendpacket[6] == 0x81 && sendpacket[7] == 0x37) {
2463
2464                 /* It's an IPX packet */
2465                 if (!enable_IPX){
2466                         /* Return 1 so we don't pass it up the stack. */
2467                         //FIXME: Take this out when IPX is fixed
2468                         if (net_ratelimit()){
2469                                 printk (KERN_INFO
2470                                 "%s: WARNING: Unsupported IPX packet received and dropped\n",
2471                                         devname);
2472                         }
2473                         return 1;
2474                 }
2475         } else {
2476                 /* It's not IPX so return and pass it up the stack. */
2477                 return 0;
2478         }
2479
2480         if( sendpacket[24] == 0x90 && sendpacket[25] == 0x04){
2481                 /* It's IPXWAN */
2482
2483                 if( sendpacket[10] == 0x02 && sendpacket[42] == 0x00){
2484
2485                         /* It's a timer request packet */
2486                         printk(KERN_INFO "%s: Received IPXWAN Timer Request packet\n",
2487                                         devname);
2488
2489                         /* Go through the routing options and answer no to every
2490                          * option except Unnumbered RIP/SAP
2491                          */
2492                         for(i = 49; sendpacket[i] == 0x00; i += 5){
2493                                 /* 0x02 is the option for Unnumbered RIP/SAP */
2494                                 if( sendpacket[i + 4] != 0x02){
2495                                         sendpacket[i + 1] = 0;
2496                                 }
2497                         }
2498
2499                         /* Skip over the extended Node ID option */
2500                         if( sendpacket[i] == 0x04 ){
2501                                 i += 8;
2502                         }
2503
2504                         /* We also want to turn off all header compression opt.
2505                          */
2506                         for(; sendpacket[i] == 0x80 ;){
2507                                 sendpacket[i + 1] = 0;
2508                                 i += (sendpacket[i + 2] << 8) + (sendpacket[i + 3]) + 4;
2509                         }
2510
2511                         /* Set the packet type to timer response */
2512                         sendpacket[42] = 0x01;
2513
2514                         printk(KERN_INFO "%s: Sending IPXWAN Timer Response\n",
2515                                         devname);
2516
2517                 } else if( sendpacket[42] == 0x02 ){
2518
2519                         /* This is an information request packet */
2520                         printk(KERN_INFO
2521                                 "%s: Received IPXWAN Information Request packet\n",
2522                                                 devname);
2523
2524                         /* Set the packet type to information response */
2525                         sendpacket[42] = 0x03;
2526
2527                         /* Set the router name */
2528                         sendpacket[59] = 'F';
2529                         sendpacket[60] = 'P';
2530                         sendpacket[61] = 'I';
2531                         sendpacket[62] = 'P';
2532                         sendpacket[63] = 'E';
2533                         sendpacket[64] = '-';
2534                         sendpacket[65] = CVHexToAscii(network_number >> 28);
2535                         sendpacket[66] = CVHexToAscii((network_number & 0x0F000000)>> 24);
2536                         sendpacket[67] = CVHexToAscii((network_number & 0x00F00000)>> 20);
2537                         sendpacket[68] = CVHexToAscii((network_number & 0x000F0000)>> 16);
2538                         sendpacket[69] = CVHexToAscii((network_number & 0x0000F000)>> 12);
2539                         sendpacket[70] = CVHexToAscii((network_number & 0x00000F00)>> 8);
2540                         sendpacket[71] = CVHexToAscii((network_number & 0x000000F0)>> 4);
2541                         sendpacket[72] = CVHexToAscii(network_number & 0x0000000F);
2542                         for(i = 73; i < 107; i+= 1)
2543                         {
2544                                 sendpacket[i] = 0;
2545                         }
2546
2547                         printk(KERN_INFO "%s: Sending IPXWAN Information Response packet\n",
2548                                         devname);
2549                 } else {
2550
2551                         printk(KERN_INFO "%s: Unknown IPXWAN packet!\n",devname);
2552                         return 0;
2553                 }
2554
2555                 /* Set the WNodeID to our network address */
2556                 sendpacket[43] = (unsigned char)(network_number >> 24);
2557                 sendpacket[44] = (unsigned char)((network_number & 0x00FF0000) >> 16);
2558                 sendpacket[45] = (unsigned char)((network_number & 0x0000FF00) >> 8);
2559                 sendpacket[46] = (unsigned char)(network_number & 0x000000FF);
2560
2561                 return 1;
2562         }
2563
2564         /* If we get here, it's an IPX-data packet so it'll get passed up the
2565          * stack.
2566          * switch the network numbers
2567          */
2568         switch_net_numbers(sendpacket, network_number ,1);
2569         return 0;
2570 }
2571 /*============================================================================
2572  * process_route
2573  *
2574  * Rationale:
2575  *      If the interface goes down, or we receive an ARP request,
2576  *      we have to change the network interface ip addresses.
2577  *      This cannot be done within the interrupt.
2578  *
2579  * Description:
2580  *
2581  *      This routine is called as a polling routine to dynamically
2582  *      add/delete routes negotiated by inverse ARP.  It is in this
2583  *      "task" because we don't want routes to be added while in
2584  *      interrupt context.
2585  *
2586  * Usage:
2587  *      This function is called by fr_poll() polling funtion.
2588  */
2589
2590 static void process_route(struct net_device *dev)
2591 {
2592         fr_channel_t *chan = dev->priv;
2593         sdla_t *card = chan->card;
2594
2595         struct ifreq if_info;
2596         struct sockaddr_in *if_data;
2597         mm_segment_t fs = get_fs();
2598         u32 ip_tmp;
2599         int err;
2600
2601
2602         switch(chan->route_flag){
2603
2604         case ADD_ROUTE:
2605
2606                 /* Set remote addresses */
2607                 memset(&if_info, 0, sizeof(if_info));
2608                 strcpy(if_info.ifr_name, dev->name);
2609
2610                 set_fs(get_ds());     /* get user space block */
2611
2612                 if_data = (struct sockaddr_in *)&if_info.ifr_dstaddr;
2613                 if_data->sin_addr.s_addr = chan->ip_remote;
2614                 if_data->sin_family = AF_INET;
2615                 err = devinet_ioctl( SIOCSIFDSTADDR, &if_info );
2616
2617                 set_fs(fs);           /* restore old block */
2618
2619                 if (err) {
2620                         printk(KERN_INFO
2621                                 "%s: Route Add failed.  Error: %d\n",
2622                                         card->devname,err);
2623                         printk(KERN_INFO "%s: Address: %u.%u.%u.%u\n",
2624                                 chan->name, NIPQUAD(chan->ip_remote));
2625
2626                 }else {
2627                         printk(KERN_INFO "%s: Route Added Successfully: %u.%u.%u.%u\n",
2628                                 card->devname,NIPQUAD(chan->ip_remote));
2629                         chan->route_flag = ROUTE_ADDED;
2630                 }
2631                 break;
2632
2633         case REMOVE_ROUTE:
2634
2635                 /* Set remote addresses */
2636                 memset(&if_info, 0, sizeof(if_info));
2637                 strcpy(if_info.ifr_name, dev->name);
2638
2639                 ip_tmp = get_ip_address(dev,WAN_POINTOPOINT_IP);
2640
2641                 set_fs(get_ds());     /* get user space block */
2642
2643                 if_data = (struct sockaddr_in *)&if_info.ifr_dstaddr;
2644                 if_data->sin_addr.s_addr = 0;
2645                 if_data->sin_family = AF_INET;
2646                 err = devinet_ioctl( SIOCSIFDSTADDR, &if_info );
2647
2648                 set_fs(fs);
2649
2650                 if (err) {
2651                         printk(KERN_INFO
2652                                 "%s: Deleting of route failed.  Error: %d\n",
2653                                         card->devname,err);
2654                         printk(KERN_INFO "%s: Address: %u.%u.%u.%u\n",
2655                                 dev->name,NIPQUAD(chan->ip_remote) );
2656
2657                 } else {
2658                         printk(KERN_INFO "%s: Route Removed Sucessfuly: %u.%u.%u.%u\n",
2659                                 card->devname,NIPQUAD(ip_tmp));
2660                         chan->route_flag = NO_ROUTE;
2661                 }
2662                 break;
2663
2664         } /* Case Statement */
2665
2666 }
2667
2668
2669
2670 /****** Frame Relay Firmware-Specific Functions *****************************/
2671
2672 /*============================================================================
2673  * Read firmware code version.
2674  * o fill string str with firmware version info.
2675  */
2676 static int fr_read_version (sdla_t* card, char* str)
2677 {
2678         fr_mbox_t* mbox = card->mbox;
2679         int retry = MAX_CMD_RETRY;
2680         int err;
2681
2682         do
2683         {
2684                 mbox->cmd.command = FR_READ_CODE_VERSION;
2685                 mbox->cmd.length = 0;
2686                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2687         } while (err && retry-- && fr_event(card, err, mbox));
2688
2689         if (!err && str) {
2690                 int len = mbox->cmd.length;
2691                 memcpy(str, mbox->data, len);
2692                 str[len] = '\0';
2693         }
2694         return err;
2695 }
2696
2697 /*============================================================================
2698  * Set global configuration.
2699  */
2700 static int fr_configure (sdla_t* card, fr_conf_t *conf)
2701 {
2702         fr_mbox_t* mbox = card->mbox;
2703         int retry = MAX_CMD_RETRY;
2704         int dlci_num = card->u.f.dlci_num;
2705         int err, i;
2706
2707         do
2708         {
2709                 memcpy(mbox->data, conf, sizeof(fr_conf_t));
2710
2711                 if (dlci_num) for (i = 0; i < dlci_num; ++i)
2712                         ((fr_conf_t*)mbox->data)->dlci[i] =
2713                                         card->u.f.node_dlci[i];
2714
2715                 mbox->cmd.command = FR_SET_CONFIG;
2716                 mbox->cmd.length =
2717                         sizeof(fr_conf_t) + dlci_num * sizeof(short);
2718
2719                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2720
2721         } while (err && retry-- && fr_event(card, err, mbox));
2722
2723         /*NC Oct 12 2000 */
2724         if (err != CMD_OK){
2725                 printk(KERN_ERR "%s: Frame Relay Configuration Failed: rc=0x%x\n",
2726                                 card->devname,err);
2727         }
2728
2729         return err;
2730 }
2731
2732 /*============================================================================
2733  * Set DLCI configuration.
2734  */
2735 static int fr_dlci_configure (sdla_t* card, fr_dlc_conf_t *conf, unsigned dlci)
2736 {
2737         fr_mbox_t* mbox = card->mbox;
2738         int retry = MAX_CMD_RETRY;
2739         int err;
2740
2741         do
2742         {
2743                 memcpy(mbox->data, conf, sizeof(fr_dlc_conf_t));
2744                 mbox->cmd.dlci = (unsigned short) dlci;
2745                 mbox->cmd.command = FR_SET_CONFIG;
2746                 mbox->cmd.length = sizeof(fr_dlc_conf_t);
2747                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2748         } while (err && retry--);
2749
2750         return err;
2751 }
2752 /*============================================================================
2753  * Set interrupt mode.
2754  */
2755 static int fr_set_intr_mode (sdla_t* card, unsigned mode, unsigned mtu,
2756         unsigned short timeout)
2757 {
2758         fr_mbox_t* mbox = card->mbox;
2759         fr508_intr_ctl_t* ictl = (void*)mbox->data;
2760         int retry = MAX_CMD_RETRY;
2761         int err;
2762
2763         do
2764         {
2765                 memset(ictl, 0, sizeof(fr508_intr_ctl_t));
2766                 ictl->mode   = mode;
2767                 ictl->tx_len = mtu;
2768                 ictl->irq    = card->hw.irq;
2769
2770                 /* indicate timeout on timer */
2771                 if (mode & 0x20) ictl->timeout = timeout;
2772
2773                 mbox->cmd.length = sizeof(fr508_intr_ctl_t);
2774                 mbox->cmd.command = FR_SET_INTR_MODE;
2775                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2776
2777         } while (err && retry-- && fr_event(card, err, mbox));
2778
2779         return err;
2780 }
2781
2782 /*============================================================================
2783  * Enable communications.
2784  */
2785 static int fr_comm_enable (sdla_t* card)
2786 {
2787         fr_mbox_t* mbox = card->mbox;
2788         int retry = MAX_CMD_RETRY;
2789         int err;
2790
2791         do
2792         {
2793                 mbox->cmd.command = FR_COMM_ENABLE;
2794                 mbox->cmd.length = 0;
2795                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2796         } while (err && retry-- && fr_event(card, err, mbox));
2797
2798         return err;
2799 }
2800
2801 /*============================================================================
2802  * fr_comm_disable
2803  *
2804  * Warning: This functin is called by the shutdown() procedure. It is void
2805  *          since dev->priv are has already been deallocated and no
2806  *          error checking is possible using fr_event() function.
2807  */
2808 static void fr_comm_disable (sdla_t* card)
2809 {
2810         fr_mbox_t* mbox = card->mbox;
2811         int retry = MAX_CMD_RETRY;
2812         int err;
2813
2814         do {
2815         mbox->cmd.command = FR_SET_MODEM_STATUS;
2816         mbox->cmd.length = 1;
2817         mbox->data[0] = 0;
2818         err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2819         } while (err && retry--);
2820
2821         retry = MAX_CMD_RETRY;
2822
2823         do
2824         {
2825                 mbox->cmd.command = FR_COMM_DISABLE;
2826                 mbox->cmd.length = 0;
2827                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2828         } while (err && retry--);
2829
2830         return;
2831 }
2832
2833
2834
2835 /*============================================================================
2836  * Get communications error statistics.
2837  */
2838 static int fr_get_err_stats (sdla_t* card)
2839 {
2840         fr_mbox_t* mbox = card->mbox;
2841         int retry = MAX_CMD_RETRY;
2842         int err;
2843
2844
2845         do
2846         {
2847                 mbox->cmd.command = FR_READ_ERROR_STATS;
2848                 mbox->cmd.length = 0;
2849                 mbox->cmd.dlci = 0;
2850                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2851         } while (err && retry-- && fr_event(card, err, mbox));
2852
2853         if (!err) {
2854                 fr_comm_stat_t* stats = (void*)mbox->data;
2855                 card->wandev.stats.rx_over_errors    = stats->rx_overruns;
2856                 card->wandev.stats.rx_crc_errors     = stats->rx_bad_crc;
2857                 card->wandev.stats.rx_missed_errors  = stats->rx_aborts;
2858                 card->wandev.stats.rx_length_errors  = stats->rx_too_long;
2859                 card->wandev.stats.tx_aborted_errors = stats->tx_aborts;
2860
2861         }
2862
2863         return err;
2864 }
2865
2866 /*============================================================================
2867  * Get statistics.
2868  */
2869 static int fr_get_stats (sdla_t* card)
2870 {
2871         fr_mbox_t* mbox = card->mbox;
2872         int retry = MAX_CMD_RETRY;
2873         int err;
2874
2875
2876         do
2877         {
2878                 mbox->cmd.command = FR_READ_STATISTICS;
2879                 mbox->cmd.length = 0;
2880                 mbox->cmd.dlci = 0;
2881                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2882         } while (err && retry-- && fr_event(card, err, mbox));
2883
2884         if (!err) {
2885                 fr_link_stat_t* stats = (void*)mbox->data;
2886                 card->wandev.stats.rx_frame_errors = stats->rx_bad_format;
2887                 card->wandev.stats.rx_dropped =
2888                         stats->rx_dropped + stats->rx_dropped2;
2889         }
2890
2891         return err;
2892 }
2893
2894 /*============================================================================
2895  * Add DLCI(s) (Access Node only!).
2896  * This routine will perform the ADD_DLCIs command for the specified DLCI.
2897  */
2898 static int fr_add_dlci (sdla_t* card, int dlci)
2899 {
2900         fr_mbox_t* mbox = card->mbox;
2901         int retry = MAX_CMD_RETRY;
2902         int err;
2903
2904         do
2905         {
2906                 unsigned short* dlci_list = (void*)mbox->data;
2907
2908                 mbox->cmd.length  = sizeof(short);
2909                 dlci_list[0] = dlci;
2910                 mbox->cmd.command = FR_ADD_DLCI;
2911                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2912
2913         } while (err && retry-- && fr_event(card, err, mbox));
2914
2915         return err;
2916 }
2917
2918 /*============================================================================
2919  * Activate DLCI(s) (Access Node only!).
2920  * This routine will perform the ACTIVATE_DLCIs command with a DLCI number.
2921  */
2922 static int fr_activate_dlci (sdla_t* card, int dlci)
2923 {
2924         fr_mbox_t* mbox = card->mbox;
2925         int retry = MAX_CMD_RETRY;
2926         int err;
2927
2928         do
2929         {
2930                 unsigned short* dlci_list = (void*)mbox->data;
2931
2932                 mbox->cmd.length  = sizeof(short);
2933                 dlci_list[0] = dlci;
2934                 mbox->cmd.command = FR_ACTIVATE_DLCI;
2935                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2936
2937         } while (err && retry-- && fr_event(card, err, mbox));
2938
2939         return err;
2940 }
2941
2942 /*============================================================================
2943  * Delete DLCI(s) (Access Node only!).
2944  * This routine will perform the DELETE_DLCIs command with a DLCI number.
2945  */
2946 static int fr_delete_dlci (sdla_t* card, int dlci)
2947 {
2948         fr_mbox_t* mbox = card->mbox;
2949         int retry = MAX_CMD_RETRY;
2950         int err;
2951
2952         do
2953         {
2954                 unsigned short* dlci_list = (void*)mbox->data;
2955
2956                 mbox->cmd.length  = sizeof(short);
2957                 dlci_list[0] = dlci;
2958                 mbox->cmd.command = FR_DELETE_DLCI;
2959                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2960
2961         } while (err && retry-- && fr_event(card, err, mbox));
2962
2963         return err;
2964 }
2965
2966
2967
2968 /*============================================================================
2969  * Issue in-channel signalling frame.
2970  */
2971 static int fr_issue_isf (sdla_t* card, int isf)
2972 {
2973         fr_mbox_t* mbox = card->mbox;
2974         int retry = MAX_CMD_RETRY;
2975         int err;
2976
2977         do
2978         {
2979                 mbox->data[0] = isf;
2980                 mbox->cmd.length  = 1;
2981                 mbox->cmd.command = FR_ISSUE_IS_FRAME;
2982                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2983         } while (err && retry-- && fr_event(card, err, mbox));
2984
2985         return err;
2986 }
2987
2988
2989 static unsigned int fr_send_hdr (sdla_t*card, int dlci, unsigned int offset)
2990 {
2991         struct net_device *dev = find_channel(card,dlci);
2992         fr_channel_t *chan;
2993
2994         if (!dev || !(chan=dev->priv))
2995                 return offset;
2996
2997         if (chan->fr_header_len){
2998                 sdla_poke(&card->hw, offset, chan->fr_header, chan->fr_header_len);
2999         }
3000
3001         return offset+chan->fr_header_len;
3002 }
3003
3004 /*============================================================================
3005  * Send a frame on a selected DLCI.
3006  */
3007 static int fr_send_data_header (sdla_t* card, int dlci, unsigned char attr, int len,
3008         void *buf, unsigned char hdr_len)
3009 {
3010         fr_mbox_t* mbox = card->mbox + 0x800;
3011         int retry = MAX_CMD_RETRY;
3012         int err;
3013
3014         do
3015         {
3016                 mbox->cmd.dlci    = dlci;
3017                 mbox->cmd.attr    = attr;
3018                 mbox->cmd.length  = len+hdr_len;
3019                 mbox->cmd.command = FR_WRITE;
3020                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3021         } while (err && retry-- && fr_event(card, err, mbox));
3022
3023         if (!err) {
3024                 fr_tx_buf_ctl_t* frbuf;
3025
3026                 if(card->hw.type == SDLA_S514)
3027                         frbuf = (void*)(*(unsigned long*)mbox->data +
3028                                 card->hw.dpmbase);
3029                 else
3030                         frbuf = (void*)(*(unsigned long*)mbox->data -
3031                                 FR_MB_VECTOR + card->hw.dpmbase);
3032
3033                 sdla_poke(&card->hw, fr_send_hdr(card,dlci,frbuf->offset), buf, len);
3034                 frbuf->flag = 0x01;
3035         }
3036
3037         return err;
3038 }
3039
3040 static int fr_send (sdla_t* card, int dlci, unsigned char attr, int len,
3041         void *buf)
3042 {
3043         fr_mbox_t* mbox = card->mbox + 0x800;
3044         int retry = MAX_CMD_RETRY;
3045         int err;
3046
3047         do
3048         {
3049                 mbox->cmd.dlci    = dlci;
3050                 mbox->cmd.attr    = attr;
3051                 mbox->cmd.length  = len;
3052                 mbox->cmd.command = FR_WRITE;
3053                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3054         } while (err && retry-- && fr_event(card, err, mbox));
3055
3056         if (!err) {
3057                 fr_tx_buf_ctl_t* frbuf;
3058
3059                 if(card->hw.type == SDLA_S514)
3060                         frbuf = (void*)(*(unsigned long*)mbox->data +
3061                                 card->hw.dpmbase);
3062                 else
3063                         frbuf = (void*)(*(unsigned long*)mbox->data -
3064                                 FR_MB_VECTOR + card->hw.dpmbase);
3065
3066                 sdla_poke(&card->hw, frbuf->offset, buf, len);
3067                 frbuf->flag = 0x01;
3068         }
3069
3070         return err;
3071 }
3072
3073
3074 /****** Firmware Asynchronous Event Handlers ********************************/
3075
3076 /*============================================================================
3077  * Main asyncronous event/error handler.
3078  *      This routine is called whenever firmware command returns non-zero
3079  *      return code.
3080  *
3081  * Return zero if previous command has to be cancelled.
3082  */
3083 static int fr_event (sdla_t *card, int event, fr_mbox_t* mbox)
3084 {
3085         fr508_flags_t* flags = card->flags;
3086         char *ptr = &flags->iflag;
3087         int i;
3088
3089         switch (event) {
3090
3091                 case FRRES_MODEM_FAILURE:
3092                         return fr_modem_failure(card, mbox);
3093
3094                 case FRRES_CHANNEL_DOWN: {
3095                         struct net_device *dev;
3096
3097                         /* Remove all routes from associated DLCI's */
3098                         for (dev = card->wandev.dev; dev;
3099                              dev = *((struct net_device **)dev->priv)) {
3100                                 fr_channel_t *chan = dev->priv;
3101                                 if (chan->route_flag == ROUTE_ADDED) {
3102                                         chan->route_flag = REMOVE_ROUTE;
3103                                 }
3104
3105                                 if (chan->inarp == INARP_CONFIGURED) {
3106                                         chan->inarp = INARP_REQUEST;
3107                                 }
3108
3109                                 /* If the link becomes disconnected then,
3110                                  * all channels will be disconnected
3111                                  * as well.
3112                                  */
3113                                 set_chan_state(dev,WAN_DISCONNECTED);
3114                         }
3115
3116                         wanpipe_set_state(card, WAN_DISCONNECTED);
3117                         return 1;
3118                         }
3119
3120                 case FRRES_CHANNEL_UP: {
3121                         struct net_device *dev;
3122
3123                         /* FIXME: Only startup devices that are on the list */
3124
3125                         for (dev = card->wandev.dev; dev;
3126                              dev = *((struct net_device **)dev->priv)) {
3127
3128                                 set_chan_state(dev,WAN_CONNECTED);
3129                         }
3130
3131                         wanpipe_set_state(card, WAN_CONNECTED);
3132                         return 1;
3133                         }
3134
3135                 case FRRES_DLCI_CHANGE:
3136                         return fr_dlci_change(card, mbox);
3137
3138                 case FRRES_DLCI_MISMATCH:
3139                         printk(KERN_INFO "%s: DLCI list mismatch!\n",
3140                                 card->devname);
3141                         return 1;
3142
3143                 case CMD_TIMEOUT:
3144                         printk(KERN_ERR "%s: command 0x%02X timed out!\n",
3145                                 card->devname, mbox->cmd.command);
3146                         printk(KERN_INFO "%s: ID Bytes = ",card->devname);
3147                         for(i = 0; i < 8; i ++)
3148                                 printk(KERN_INFO "0x%02X ", *(ptr + 0x18 + i));
3149                         printk(KERN_INFO "\n");
3150
3151                         break;
3152
3153                 case FRRES_DLCI_INACTIVE:
3154                         break;
3155
3156                 case FRRES_CIR_OVERFLOW:
3157                         break;
3158
3159                 case FRRES_BUFFER_OVERFLOW:
3160                         break;
3161
3162                 default:
3163                         printk(KERN_INFO "%s: command 0x%02X returned 0x%02X!\n"
3164                                 , card->devname, mbox->cmd.command, event);
3165         }
3166
3167         return 0;
3168 }
3169
3170 /*============================================================================
3171  * Handle modem error.
3172  *
3173  * Return zero if previous command has to be cancelled.
3174  */
3175 static int fr_modem_failure (sdla_t *card, fr_mbox_t* mbox)
3176 {
3177         printk(KERN_INFO "%s: physical link down! (modem error 0x%02X)\n",
3178                 card->devname, mbox->data[0]);
3179
3180         switch (mbox->cmd.command){
3181                 case FR_WRITE:
3182
3183                 case FR_READ:
3184                         return 0;
3185         }
3186
3187         return 1;
3188 }
3189
3190 /*============================================================================
3191  * Handle DLCI status change.
3192  *
3193  * Return zero if previous command has to be cancelled.
3194  */
3195 static int fr_dlci_change (sdla_t *card, fr_mbox_t* mbox)
3196 {
3197         dlci_status_t* status = (void*)mbox->data;
3198         int cnt = mbox->cmd.length / sizeof(dlci_status_t);
3199         fr_channel_t *chan;
3200         struct net_device* dev2;
3201
3202
3203         for (; cnt; --cnt, ++status) {
3204
3205                 unsigned short dlci= status->dlci;
3206                 struct net_device* dev = find_channel(card, dlci);
3207
3208                 if (dev == NULL){
3209                         printk(KERN_INFO
3210                                 "%s: CPE contains unconfigured DLCI= %d\n",
3211                                 card->devname, dlci);
3212
3213                       printk(KERN_INFO
3214                                 "%s: unconfigured DLCI %d reported by network\n"
3215                                 , card->devname, dlci);
3216
3217                 }else{
3218                         if (status->state == FR_LINK_INOPER) {
3219                                 printk(KERN_INFO
3220                                         "%s: DLCI %u is inactive!\n",
3221                                         card->devname, dlci);
3222
3223                                 if (dev && netif_running(dev))
3224                                         set_chan_state(dev, WAN_DISCONNECTED);
3225                         }
3226
3227                         if (status->state & FR_DLCI_DELETED) {
3228
3229                                 printk(KERN_INFO
3230                                         "%s: DLCI %u has been deleted!\n",
3231                                         card->devname, dlci);
3232
3233                                 if (dev && netif_running(dev)){
3234
3235                                         fr_channel_t *chan = dev->priv;
3236
3237                                         if (chan->route_flag == ROUTE_ADDED) {
3238                                                 chan->route_flag = REMOVE_ROUTE;
3239                                                 /* The state change will trigger
3240                                                  * the fr polling routine */
3241                                         }
3242
3243                                         if (chan->inarp == INARP_CONFIGURED) {
3244                                                 chan->inarp = INARP_REQUEST;
3245                                         }
3246
3247                                         set_chan_state(dev, WAN_DISCONNECTED);
3248                                 }
3249
3250                         } else if (status->state & FR_DLCI_ACTIVE) {
3251
3252                                 chan = dev->priv;
3253
3254                                 /* This flag is used for configuring specific
3255                                    DLCI(s) when they become active.
3256                                 */
3257                                 chan->dlci_configured = DLCI_CONFIG_PENDING;
3258
3259                                 set_chan_state(dev, WAN_CONNECTED);
3260
3261                         }
3262                 }
3263         }
3264
3265         for (dev2 = card->wandev.dev; dev2;
3266              dev2 = *((struct net_device **)dev2->priv)){
3267
3268                 chan = dev2->priv;
3269
3270                 if (chan->dlci_configured == DLCI_CONFIG_PENDING) {
3271                         if (fr_init_dlci(card, chan)){
3272                                 return 1;
3273                         }
3274                 }
3275
3276         }
3277         return 1;
3278 }
3279
3280
3281 static int fr_init_dlci (sdla_t *card, fr_channel_t *chan)
3282 {
3283         fr_dlc_conf_t cfg;
3284
3285         memset(&cfg, 0, sizeof(cfg));
3286
3287         if ( chan->cir_status == CIR_DISABLED) {
3288
3289                 cfg.cir_fwd = cfg.cir_bwd  = 16;
3290                 cfg.bc_fwd = cfg.bc_bwd = 16;
3291                 cfg.conf_flags = 0x0001;
3292
3293         }else if (chan->cir_status == CIR_ENABLED) {
3294
3295                 cfg.cir_fwd = cfg.cir_bwd = chan->cir;
3296                 cfg.bc_fwd  = cfg.bc_bwd  = chan->bc;
3297                 cfg.be_fwd  = cfg.be_bwd  = chan->be;
3298                 cfg.conf_flags = 0x0000;
3299         }
3300
3301         if (fr_dlci_configure( card, &cfg , chan->dlci)){
3302                 printk(KERN_INFO
3303                         "%s: DLCI Configure failed for %d\n",
3304                                 card->devname, chan->dlci);
3305                 return 1;
3306         }
3307
3308         chan->dlci_configured = DLCI_CONFIGURED;
3309
3310         /* Read the interface byte mapping into the channel
3311          * structure.
3312          */
3313         read_DLCI_IB_mapping( card, chan );
3314
3315         return 0;
3316 }
3317 /******* Miscellaneous ******************************************************/
3318
3319 /*============================================================================
3320  * Update channel state.
3321  */
3322 static int update_chan_state(struct net_device* dev)
3323 {
3324         fr_channel_t* chan = dev->priv;
3325         sdla_t* card = chan->card;
3326         fr_mbox_t* mbox = card->mbox;
3327         int retry = MAX_CMD_RETRY;
3328         int err;
3329
3330         do
3331         {
3332                 mbox->cmd.command = FR_LIST_ACTIVE_DLCI;
3333                 mbox->cmd.length = 0;
3334                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3335         } while (err && retry-- && fr_event(card, err, mbox));
3336
3337         if (!err) {
3338
3339                 unsigned short* list = (void*)mbox->data;
3340                 int cnt = mbox->cmd.length / sizeof(short);
3341
3342                 err=1;
3343
3344                 for (; cnt; --cnt, ++list) {
3345
3346                         if (*list == chan->dlci) {
3347                                 set_chan_state(dev, WAN_CONNECTED);
3348
3349
3350                                 /* May 23 2000. NC
3351                                  * When a dlci is added or restarted,
3352                                  * the dlci_int_interface pointer must
3353                                  * be reinitialized.  */
3354                                 if (!chan->dlci_int_interface){
3355                                         err=fr_init_dlci (card,chan);
3356                                 }
3357                                 break;
3358                         }
3359                 }
3360         }
3361
3362         return err;
3363 }
3364
3365 /*============================================================================
3366  * Set channel state.
3367  */
3368 static void set_chan_state(struct net_device* dev, int state)
3369 {
3370         fr_channel_t* chan = dev->priv;
3371         sdla_t* card = chan->card;
3372
3373         if (chan->common.state != state) {
3374
3375                 switch (state) {
3376
3377                         case WAN_CONNECTED:
3378                                 printk(KERN_INFO
3379                                         "%s: Interface %s: DLCI %d connected\n",
3380                                         card->devname, dev->name, chan->dlci);
3381
3382                                 /* If the interface was previoulsy down,
3383                                  * bring it up, since the channel is active */
3384
3385                                 trigger_fr_poll (dev);
3386                                 trigger_fr_arp  (dev);
3387                                 break;
3388
3389                         case WAN_CONNECTING:
3390                                 printk(KERN_INFO
3391                                       "%s: Interface %s: DLCI %d connecting\n",
3392                                         card->devname, dev->name, chan->dlci);
3393                                 break;
3394
3395                         case WAN_DISCONNECTED:
3396                                 printk (KERN_INFO
3397                                     "%s: Interface %s: DLCI %d disconnected!\n",
3398                                         card->devname, dev->name, chan->dlci);
3399
3400                                 /* If the interface is up, bring it down,
3401                                  * since the channel is now disconnected */
3402                                 trigger_fr_poll (dev);
3403                                 break;
3404                 }
3405
3406                 chan->common.state = state;
3407         }
3408
3409         chan->state_tick = jiffies;
3410 }
3411
3412 /*============================================================================
3413  * Find network device by its channel number.
3414  *
3415  * We need this critical flag because we change
3416  * the dlci_to_dev_map outside the interrupt.
3417  *
3418  * NOTE: del_if() functions updates this array, it uses
3419  *       the spin locks to avoid corruption.
3420  */
3421 static struct net_device* find_channel(sdla_t* card, unsigned dlci)
3422 {
3423         if(dlci > HIGHEST_VALID_DLCI)
3424                 return NULL;
3425
3426         return(card->u.f.dlci_to_dev_map[dlci]);
3427 }
3428
3429 /*============================================================================
3430  * Check to see if a frame can be sent. If no transmit buffers available,
3431  * enable transmit interrupts.
3432  *
3433  * Return:      1 - Tx buffer(s) available
3434  *              0 - no buffers available
3435  */
3436 static int is_tx_ready (sdla_t* card, fr_channel_t* chan)
3437 {
3438         unsigned char sb;
3439
3440         if(card->hw.type == SDLA_S514)
3441                 return 1;
3442
3443         sb = inb(card->hw.port);
3444         if (sb & 0x02)
3445                 return 1;
3446
3447         return 0;
3448 }
3449
3450 /*============================================================================
3451  * Convert decimal string to unsigned integer.
3452  * If len != 0 then only 'len' characters of the string are converted.
3453  */
3454 static unsigned int dec_to_uint (unsigned char* str, int len)
3455 {
3456         unsigned val;
3457
3458         if (!len)
3459                 len = strlen(str);
3460
3461         for (val = 0; len && is_digit(*str); ++str, --len)
3462                 val = (val * 10) + (*str - (unsigned)'0');
3463
3464         return val;
3465 }
3466
3467
3468
3469 /*=============================================================================
3470  * Store a UDP management packet for later processing.
3471  */
3472
3473 static int store_udp_mgmt_pkt(int udp_type, char udp_pkt_src, sdla_t* card,
3474                                 struct sk_buff *skb, int dlci)
3475 {
3476         int udp_pkt_stored = 0;
3477
3478         struct net_device *dev = find_channel(card, dlci);
3479         fr_channel_t *chan;
3480
3481         if (!dev || !(chan=dev->priv))
3482                 return 1;
3483
3484         if(!card->u.f.udp_pkt_lgth && (skb->len <= MAX_LGTH_UDP_MGNT_PKT)){
3485                 card->u.f.udp_pkt_lgth = skb->len + chan->fr_header_len;
3486                 card->u.f.udp_type = udp_type;
3487                 card->u.f.udp_pkt_src = udp_pkt_src;
3488                 card->u.f.udp_dlci = dlci;
3489                 memcpy(card->u.f.udp_pkt_data, skb->data, skb->len);
3490                 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UDP;
3491                 udp_pkt_stored = 1;
3492
3493         }else{
3494                 printk(KERN_INFO "ERROR: UDP packet not stored for DLCI %d\n",
3495                                                         dlci);
3496         }
3497
3498         if(udp_pkt_src == UDP_PKT_FRM_STACK){
3499                 dev_kfree_skb_any(skb);
3500         }else{
3501                 dev_kfree_skb_any(skb);
3502         }
3503
3504         return(udp_pkt_stored);
3505 }
3506
3507
3508 /*==============================================================================
3509  * Process UDP call of type FPIPE8ND
3510  */
3511 static int process_udp_mgmt_pkt(sdla_t* card)
3512 {
3513
3514         int c_retry = MAX_CMD_RETRY;
3515         unsigned char *buf;
3516         unsigned char frames;
3517         unsigned int len;
3518         unsigned short buffer_length;
3519         struct sk_buff *new_skb;
3520         fr_mbox_t* mbox = card->mbox;
3521         int err;
3522         struct timeval tv;
3523         int udp_mgmt_req_valid = 1;
3524         struct net_device* dev;
3525         fr_channel_t* chan;
3526         fr_udp_pkt_t *fr_udp_pkt;
3527         unsigned short num_trc_els;
3528         fr_trc_el_t* ptr_trc_el;
3529         fr_trc_el_t trc_el;
3530         fpipemon_trc_t* fpipemon_trc;
3531
3532         char udp_pkt_src = card->u.f.udp_pkt_src;
3533         int dlci = card->u.f.udp_dlci;
3534
3535         /* Find network interface for this packet */
3536         dev = find_channel(card, dlci);
3537         if (!dev){
3538                 card->u.f.udp_pkt_lgth = 0;
3539                 return 1;
3540         }
3541         if ((chan = dev->priv) == NULL){
3542                 card->u.f.udp_pkt_lgth = 0;
3543                 return 1;
3544         }
3545
3546         /* If the UDP packet is from the network, we are going to have to
3547            transmit a response. Before doing so, we must check to see that
3548            we are not currently transmitting a frame (in 'if_send()') and
3549            that we are not already in a 'delayed transmit' state.
3550         */
3551         if(udp_pkt_src == UDP_PKT_FRM_NETWORK) {
3552                 if (check_tx_status(card,dev)){
3553                         card->u.f.udp_pkt_lgth = 0;
3554                         return 1;
3555                 }
3556         }
3557
3558         fr_udp_pkt = (fr_udp_pkt_t *)card->u.f.udp_pkt_data;
3559
3560         if(udp_pkt_src == UDP_PKT_FRM_NETWORK) {
3561
3562                 switch(fr_udp_pkt->cblock.command) {
3563
3564                         case FR_READ_MODEM_STATUS:
3565                         case FR_READ_STATUS:
3566                         case FPIPE_ROUTER_UP_TIME:
3567                         case FR_READ_ERROR_STATS:
3568                         case FPIPE_DRIVER_STAT_GEN:
3569                         case FR_READ_STATISTICS:
3570                         case FR_READ_ADD_DLC_STATS:
3571                         case FR_READ_CONFIG:
3572                         case FR_READ_CODE_VERSION:
3573                                 udp_mgmt_req_valid = 1;
3574                                 break;
3575                         default:
3576                                 udp_mgmt_req_valid = 0;
3577                                 break;
3578                 }
3579         }
3580
3581         if(!udp_mgmt_req_valid) {
3582                 /* set length to 0 */
3583                 fr_udp_pkt->cblock.length = 0;
3584                 /* set return code */
3585                 fr_udp_pkt->cblock.result = 0xCD;
3586
3587                 chan->drvstats_gen.UDP_PIPE_mgmt_direction_err ++;
3588
3589                 if (net_ratelimit()){
3590                         printk(KERN_INFO
3591                         "%s: Warning, Illegal UDP command attempted from network: %x\n",
3592                         card->devname,fr_udp_pkt->cblock.command);
3593                 }
3594
3595         } else {
3596
3597                 switch(fr_udp_pkt->cblock.command) {
3598
3599                 case FPIPE_ENABLE_TRACING:
3600                         if(!card->TracingEnabled) {
3601                                 do {
3602                                         mbox->cmd.command = FR_SET_TRACE_CONFIG;
3603                                         mbox->cmd.length = 1;
3604                                         mbox->cmd.dlci = 0x00;
3605                                         mbox->data[0] = fr_udp_pkt->data[0] |
3606                                                 RESET_TRC;
3607                                         err = sdla_exec(mbox) ?
3608                                                         mbox->cmd.result : CMD_TIMEOUT;
3609                                 } while (err && c_retry-- && fr_event(card, err,
3610                                          mbox));
3611
3612                                 if(err) {
3613                                         card->TracingEnabled = 0;
3614                                         /* set the return code */
3615                                         fr_udp_pkt->cblock.result =
3616                                                 mbox->cmd.result;
3617                                         mbox->cmd.length = 0;
3618                                         break;
3619                                 }
3620
3621                                 sdla_peek(&card->hw, NO_TRC_ELEMENTS_OFF,
3622                                                 &num_trc_els, 2);
3623                                 sdla_peek(&card->hw, BASE_TRC_ELEMENTS_OFF,
3624                                                 &card->u.f.trc_el_base, 4);
3625                                 card->u.f.curr_trc_el = card->u.f.trc_el_base;
3626                                 card->u.f.trc_el_last = card->u.f.curr_trc_el +
3627                                                         ((num_trc_els - 1) *
3628                                                         sizeof(fr_trc_el_t));
3629
3630                                 /* Calculate the maximum trace data area in */
3631                                 /* the UDP packet */
3632                                 card->u.f.trc_bfr_space=(MAX_LGTH_UDP_MGNT_PKT -
3633                                         //sizeof(fr_encap_hdr_t) -
3634                                         sizeof(ip_pkt_t) -
3635                                         sizeof(udp_pkt_t) -
3636                                         sizeof(wp_mgmt_t) -
3637                                         sizeof(cblock_t));
3638
3639                                 /* set return code */
3640                                 fr_udp_pkt->cblock.result = 0;
3641
3642                         } else {
3643                                 /* set return code to line trace already
3644                                    enabled */
3645                                 fr_udp_pkt->cblock.result = 1;
3646                         }
3647
3648                         mbox->cmd.length = 0;
3649                         card->TracingEnabled = 1;
3650                         break;
3651
3652
3653                 case FPIPE_DISABLE_TRACING:
3654                         if(card->TracingEnabled) {
3655
3656                                 do {
3657                                         mbox->cmd.command = FR_SET_TRACE_CONFIG;
3658                                         mbox->cmd.length = 1;
3659                                         mbox->cmd.dlci = 0x00;
3660                                         mbox->data[0] = ~ACTIVATE_TRC;
3661                                         err = sdla_exec(mbox) ?
3662                                                         mbox->cmd.result : CMD_TIMEOUT;
3663                                 } while (err && c_retry-- && fr_event(card, err, mbox));
3664                         }
3665
3666                         /* set return code */
3667                         fr_udp_pkt->cblock.result = 0;
3668                         mbox->cmd.length = 0;
3669                         card->TracingEnabled = 0;
3670                         break;
3671
3672                 case FPIPE_GET_TRACE_INFO:
3673
3674                         /* Line trace cannot be performed on the 502 */
3675                         if(!card->TracingEnabled) {
3676                                 /* set return code */
3677                                 fr_udp_pkt->cblock.result = 1;
3678                                 mbox->cmd.length = 0;
3679                                 break;
3680                         }
3681
3682                         ptr_trc_el = (void *)card->u.f.curr_trc_el;
3683
3684                         buffer_length = 0;
3685                         fr_udp_pkt->data[0x00] = 0x00;
3686
3687                         for(frames = 0; frames < MAX_FRMS_TRACED; frames ++) {
3688
3689                                 sdla_peek(&card->hw, (unsigned long)ptr_trc_el,
3690                                           (void *)&trc_el.flag,
3691                                           sizeof(fr_trc_el_t));
3692                                 if(trc_el.flag == 0x00) {
3693                                         break;
3694                                 }
3695                                 if((card->u.f.trc_bfr_space - buffer_length)
3696                                         < sizeof(fpipemon_trc_hdr_t)) {
3697                                         fr_udp_pkt->data[0x00] |= MORE_TRC_DATA;
3698                                         break;
3699                                 }
3700
3701                                 fpipemon_trc =
3702                                         (fpipemon_trc_t *)&fr_udp_pkt->data[buffer_length];
3703                                 fpipemon_trc->fpipemon_trc_hdr.status =
3704                                         trc_el.attr;
3705                                 fpipemon_trc->fpipemon_trc_hdr.tmstamp =
3706                                         trc_el.tmstamp;
3707                                 fpipemon_trc->fpipemon_trc_hdr.length =
3708                                         trc_el.length;
3709
3710                                 if(!trc_el.offset || !trc_el.length) {
3711
3712                                         fpipemon_trc->fpipemon_trc_hdr.data_passed = 0x00;
3713
3714                                 }else if((trc_el.length + sizeof(fpipemon_trc_hdr_t) + 1) >
3715                                         (card->u.f.trc_bfr_space - buffer_length)){
3716
3717                                         fpipemon_trc->fpipemon_trc_hdr.data_passed = 0x00;
3718                                         fr_udp_pkt->data[0x00] |= MORE_TRC_DATA;
3719
3720                                 }else {
3721                                         fpipemon_trc->fpipemon_trc_hdr.data_passed = 0x01;
3722                                         sdla_peek(&card->hw, trc_el.offset,
3723                                                   fpipemon_trc->data,
3724                                                   trc_el.length);
3725                                 }
3726
3727                                 trc_el.flag = 0x00;
3728                                 sdla_poke(&card->hw, (unsigned long)ptr_trc_el,
3729                                           &trc_el.flag, 1);
3730
3731                                 ptr_trc_el ++;
3732                                 if((void *)ptr_trc_el > card->u.f.trc_el_last)
3733                                         ptr_trc_el = (void*)card->u.f.trc_el_base;
3734
3735                                 buffer_length += sizeof(fpipemon_trc_hdr_t);
3736                                 if(fpipemon_trc->fpipemon_trc_hdr.data_passed) {
3737                                         buffer_length += trc_el.length;
3738                                 }
3739
3740                                 if(fr_udp_pkt->data[0x00] & MORE_TRC_DATA) {
3741                                         break;
3742                                 }
3743                         }
3744
3745                         if(frames == MAX_FRMS_TRACED) {
3746                                 fr_udp_pkt->data[0x00] |= MORE_TRC_DATA;
3747                         }
3748
3749                         card->u.f.curr_trc_el = (void *)ptr_trc_el;
3750
3751                         /* set the total number of frames passed */
3752                         fr_udp_pkt->data[0x00] |=
3753                                 ((frames << 1) & (MAX_FRMS_TRACED << 1));
3754
3755                         /* set the data length and return code */
3756                         fr_udp_pkt->cblock.length = mbox->cmd.length = buffer_length;
3757                         fr_udp_pkt->cblock.result = 0;
3758                         break;
3759
3760                 case FPIPE_FT1_READ_STATUS:
3761                         sdla_peek(&card->hw, 0xF020,
3762                                 &fr_udp_pkt->data[0x00] , 2);
3763                         fr_udp_pkt->cblock.length = mbox->cmd.length = 2;
3764                         fr_udp_pkt->cblock.result = 0;
3765                         break;
3766
3767                 case FPIPE_FLUSH_DRIVER_STATS:
3768                         init_chan_statistics(chan);
3769                         init_global_statistics(card);
3770                         mbox->cmd.length = 0;
3771                         break;
3772
3773                 case FPIPE_ROUTER_UP_TIME:
3774                         do_gettimeofday(&tv);
3775                         chan->router_up_time = tv.tv_sec -
3776                                                 chan->router_start_time;
3777                         *(unsigned long *)&fr_udp_pkt->data =
3778                                 chan->router_up_time;
3779                         mbox->cmd.length = fr_udp_pkt->cblock.length = 4;
3780                         fr_udp_pkt->cblock.result = 0;
3781                         break;
3782
3783                 case FPIPE_DRIVER_STAT_IFSEND:
3784                         memcpy(fr_udp_pkt->data,
3785                                 &chan->drvstats_if_send.if_send_entry,
3786                                 sizeof(if_send_stat_t));
3787                         mbox->cmd.length = fr_udp_pkt->cblock.length =sizeof(if_send_stat_t);
3788                         fr_udp_pkt->cblock.result = 0;
3789                         break;
3790
3791                 case FPIPE_DRIVER_STAT_INTR:
3792
3793                         memcpy(fr_udp_pkt->data,
3794                                 &card->statistics.isr_entry,
3795                                 sizeof(global_stats_t));
3796
3797                         memcpy(&fr_udp_pkt->data[sizeof(global_stats_t)],
3798                                 &chan->drvstats_rx_intr.rx_intr_no_socket,
3799                                 sizeof(rx_intr_stat_t));
3800
3801                         mbox->cmd.length = fr_udp_pkt->cblock.length =
3802                                         sizeof(global_stats_t) +
3803                                         sizeof(rx_intr_stat_t);
3804                         fr_udp_pkt->cblock.result = 0;
3805                         break;
3806
3807                 case FPIPE_DRIVER_STAT_GEN:
3808                         memcpy(fr_udp_pkt->data,
3809                                 &chan->drvstats_gen.UDP_PIPE_mgmt_kmalloc_err,
3810                                 sizeof(pipe_mgmt_stat_t));
3811
3812                         memcpy(&fr_udp_pkt->data[sizeof(pipe_mgmt_stat_t)],
3813                                &card->statistics, sizeof(global_stats_t));
3814
3815                         mbox->cmd.length = fr_udp_pkt->cblock.length = sizeof(global_stats_t)+
3816                                                      sizeof(rx_intr_stat_t);
3817                         fr_udp_pkt->cblock.result = 0;
3818                         break;
3819
3820
3821                 case FR_FT1_STATUS_CTRL:
3822                         if(fr_udp_pkt->data[0] == 1) {
3823                                 if(rCount++ != 0 ){
3824                                         fr_udp_pkt->cblock.result = 0;
3825                                         mbox->cmd.length = 1;
3826                                         break;
3827                                 }
3828                         }
3829
3830                         /* Disable FT1 MONITOR STATUS */
3831                         if(fr_udp_pkt->data[0] == 0) {
3832                                 if( --rCount != 0) {
3833                                         fr_udp_pkt->cblock.result = 0;
3834                                         mbox->cmd.length = 1;
3835                                         break;
3836                                 }
3837                         }
3838                         goto udp_mgmt_dflt;
3839
3840
3841                 default:
3842 udp_mgmt_dflt:
3843                         do {
3844                                 memcpy(&mbox->cmd,
3845                                         &fr_udp_pkt->cblock.command,
3846                                         sizeof(fr_cmd_t));
3847                                 if(mbox->cmd.length) {
3848                                         memcpy(&mbox->data,
3849                                                 (char *)fr_udp_pkt->data,
3850                                                 mbox->cmd.length);
3851                                 }
3852
3853                                 err = sdla_exec(mbox) ? mbox->cmd.result :
3854                                         CMD_TIMEOUT;
3855                         } while (err && c_retry-- && fr_event(card, err, mbox));
3856
3857                         if(!err)
3858                                 chan->drvstats_gen.
3859                                         UDP_PIPE_mgmt_adptr_cmnd_OK ++;
3860                         else
3861                                 chan->drvstats_gen.
3862                                         UDP_PIPE_mgmt_adptr_cmnd_timeout ++;
3863
3864                         /* copy the result back to our buffer */
3865                         memcpy(&fr_udp_pkt->cblock.command,
3866                                 &mbox->cmd, sizeof(fr_cmd_t));
3867
3868                         if(mbox->cmd.length) {
3869                                 memcpy(&fr_udp_pkt->data,
3870                                         &mbox->data, mbox->cmd.length);
3871                         }
3872                 }
3873         }
3874
3875         /* Fill UDP TTL */
3876         fr_udp_pkt->ip_pkt.ttl = card->wandev.ttl;
3877         len = reply_udp(card->u.f.udp_pkt_data, mbox->cmd.length);
3878
3879         if(udp_pkt_src == UDP_PKT_FRM_NETWORK) {
3880
3881                 chan->fr_header_len=2;
3882                 chan->fr_header[0]=Q922_UI;
3883                 chan->fr_header[1]=NLPID_IP;
3884
3885                 err = fr_send_data_header(card, dlci, 0, len,
3886                         card->u.f.udp_pkt_data,chan->fr_header_len);
3887                 if (err){
3888                         chan->drvstats_gen.UDP_PIPE_mgmt_adptr_send_passed ++;
3889                 }else{
3890                         chan->drvstats_gen.UDP_PIPE_mgmt_adptr_send_failed ++;
3891                 }
3892
3893         } else {
3894                 /* Allocate socket buffer */
3895                 if((new_skb = dev_alloc_skb(len)) != NULL) {
3896
3897                         /* copy data into new_skb */
3898                         buf = skb_put(new_skb, len);
3899                         memcpy(buf, card->u.f.udp_pkt_data, len);
3900
3901                         chan->drvstats_gen.
3902                                 UDP_PIPE_mgmt_passed_to_stack ++;
3903                         new_skb->dev = dev;
3904                         new_skb->protocol = htons(ETH_P_IP);
3905                         new_skb->mac.raw = new_skb->data;
3906                         netif_rx(new_skb);
3907
3908                 } else {
3909                         chan->drvstats_gen.UDP_PIPE_mgmt_no_socket ++;
3910                         printk(KERN_INFO
3911                         "%s: UDP mgmt cmnd, no socket buffers available!\n",
3912                         card->devname);
3913                 }
3914         }
3915
3916         card->u.f.udp_pkt_lgth = 0;
3917
3918         return 1;
3919 }
3920
3921 /*==============================================================================
3922  * Send Inverse ARP Request
3923  */
3924
3925 int send_inarp_request(sdla_t *card, struct net_device *dev)
3926 {
3927         int err=0;
3928
3929         arphdr_1490_t *ArpPacket;
3930         arphdr_fr_t *arphdr;
3931         fr_channel_t *chan = dev->priv;
3932         struct in_device *in_dev;
3933
3934         in_dev = dev->ip_ptr;
3935
3936         if(in_dev != NULL ) {
3937
3938                 ArpPacket = kmalloc(sizeof(arphdr_1490_t) + sizeof(arphdr_fr_t), GFP_ATOMIC);
3939                 /* SNAP Header indicating ARP */
3940                 ArpPacket->control      = 0x03;
3941                 ArpPacket->pad          = 0x00;
3942                 ArpPacket->NLPID        = 0x80;
3943                 ArpPacket->OUI[0]       = 0;
3944                 ArpPacket->OUI[1]       = 0;
3945                 ArpPacket->OUI[2]       = 0;
3946                 ArpPacket->PID          = 0x0608;
3947
3948                 arphdr = (arphdr_fr_t *)(ArpPacket + 1); // Go to ARP Packet
3949
3950                 /* InARP request */
3951                 arphdr->ar_hrd = 0x0F00;        /* Frame Relay HW type */
3952                 arphdr->ar_pro = 0x0008;        /* IP Protocol         */
3953                 arphdr->ar_hln = 2;             /* HW addr length      */
3954                 arphdr->ar_pln = 4;             /* IP addr length      */
3955                 arphdr->ar_op = htons(0x08);    /* InARP Request       */
3956                 arphdr->ar_sha = 0;             /* src HW DLCI - Doesn't matter */
3957                 if(in_dev->ifa_list != NULL)
3958                         arphdr->ar_sip = in_dev->ifa_list->ifa_local;  /* Local Address       */else
3959                         arphdr->ar_sip = 0;
3960                 arphdr->ar_tha = 0;             /* dst HW DLCI - Doesn't matter */
3961                 arphdr->ar_tip = 0;             /* Remote Address -- what we want */
3962
3963                 err = fr_send(card, chan->dlci, 0, sizeof(arphdr_1490_t) + sizeof(arphdr_fr_t),
3964                                         (void *)ArpPacket);
3965
3966                 if (!err){
3967                         printk(KERN_INFO "\n%s: Sending InARP request on DLCI %d.\n",
3968                                 card->devname, chan->dlci);
3969                         clear_bit(ARP_CRIT,&card->wandev.critical);
3970                 }
3971
3972                 kfree(ArpPacket);
3973         }else{
3974                 printk(KERN_INFO "%s: INARP ERROR: %s doesn't have a local IP address!\n",
3975                                 card->devname,dev->name);
3976                 return 1;
3977         }
3978
3979         return 0;
3980 }
3981
3982
3983 /*==============================================================================
3984  * Check packet for ARP Type
3985  */
3986
3987 int is_arp(void *buf)
3988 {
3989         arphdr_1490_t *arphdr = (arphdr_1490_t *)buf;
3990
3991         if (arphdr->pad   == 0x00  &&
3992             arphdr->NLPID == 0x80  &&
3993             arphdr->PID   == 0x0608)
3994                 return 1;
3995         else return 0;
3996 }
3997
3998 /*==============================================================================
3999  * Process ARP Packet Type
4000  */
4001
4002 int process_ARP(arphdr_1490_t *ArpPacket, sdla_t *card, struct net_device* dev)
4003 {
4004
4005
4006         arphdr_fr_t *arphdr = (arphdr_fr_t *)(ArpPacket + 1); /* Skip header */
4007         fr_rx_buf_ctl_t* frbuf = card->rxmb;
4008         struct in_device *in_dev;
4009         fr_channel_t *chan = dev->priv;
4010
4011         /* Before we transmit ARP packet, we must check
4012          * to see that we are not currently transmitting a
4013          * frame (in 'if_send()') and that we are not
4014          * already in a 'delayed transmit' state. */
4015         if (check_tx_status(card,dev)){
4016                 if (net_ratelimit()){
4017                         printk(KERN_INFO "%s: Disabling comminication to process ARP\n",
4018                                         card->devname);
4019                 }
4020                 set_bit(ARP_CRIT,&card->wandev.critical);
4021                 return 0;
4022         }
4023
4024         in_dev = dev->ip_ptr;
4025
4026         /* Check that IP addresses exist for our network address */
4027         if (in_dev == NULL || in_dev->ifa_list == NULL)
4028                 return -1;
4029
4030         switch (ntohs(arphdr->ar_op)) {
4031
4032         case 0x08:  // Inverse ARP request  -- Send Reply, add route.
4033
4034                 /* Check for valid Address */
4035                 printk(KERN_INFO "%s: Recvd PtP addr -InArp Req: %u.%u.%u.%u\n",
4036                         card->devname, NIPQUAD(arphdr->ar_sip));
4037
4038
4039                 /* Check that the network address is the same as ours, only
4040                  * if the netowrk mask is not 255.255.255.255. Otherwise
4041                  * this check would not make sense */
4042
4043                 if (in_dev->ifa_list->ifa_mask != 0xFFFFFFFF &&
4044                     (in_dev->ifa_list->ifa_mask & arphdr->ar_sip) !=
4045                     (in_dev->ifa_list->ifa_mask & in_dev->ifa_list->ifa_local)){
4046                         printk(KERN_INFO
4047                                 "%s: Invalid PtP address. %u.%u.%u.%u  InARP ignored.\n",
4048                                         card->devname,NIPQUAD(arphdr->ar_sip));
4049
4050                         printk(KERN_INFO "%s: mask %u.%u.%u.%u\n",
4051                                 card->devname, NIPQUAD(in_dev->ifa_list->ifa_mask));
4052                                 printk(KERN_INFO "%s: local %u.%u.%u.%u\n",
4053                                 card->devname,NIPQUAD(in_dev->ifa_list->ifa_local));
4054                         return -1;
4055                 }
4056
4057                 if (in_dev->ifa_list->ifa_local == arphdr->ar_sip){
4058                         printk(KERN_INFO
4059                                 "%s: Local addr = PtP addr.  InARP ignored.\n",
4060                                         card->devname);
4061                         return -1;
4062                 }
4063
4064                 arphdr->ar_op = htons(0x09);    /* InARP Reply */
4065
4066                 /* Set addresses */
4067                 arphdr->ar_tip = arphdr->ar_sip;
4068                 arphdr->ar_sip = in_dev->ifa_list->ifa_local;
4069
4070                 chan->ip_local = in_dev->ifa_list->ifa_local;
4071                 chan->ip_remote = arphdr->ar_sip;
4072
4073                 fr_send(card, frbuf->dlci, 0, frbuf->length, (void *)ArpPacket);
4074
4075                 if (test_bit(ARP_CRIT,&card->wandev.critical)){
4076                         if (net_ratelimit()){
4077                                 printk(KERN_INFO "%s: ARP Processed Enabling Communication!\n",
4078                                         card->devname);
4079                         }
4080                 }
4081                 clear_bit(ARP_CRIT,&card->wandev.critical);
4082
4083                 chan->ip_local = in_dev->ifa_list->ifa_local;
4084                 chan->ip_remote = arphdr->ar_sip;
4085
4086                 /* Add Route Flag */
4087                 /* The route will be added in the polling routine so
4088                    that it is not interrupt context. */
4089
4090                 chan->route_flag = ADD_ROUTE;
4091                 trigger_fr_poll (dev);
4092
4093                 break;
4094
4095         case 0x09:  // Inverse ARP reply
4096
4097                 /* Check for valid Address */
4098                 printk(KERN_INFO "%s: Recvd PtP addr %u.%u.%u.%u -InArp Reply\n",
4099                                 card->devname, NIPQUAD(arphdr->ar_sip));
4100
4101
4102                 /* Compare network addresses, only if network mask
4103                  * is not 255.255.255.255  It would not make sense
4104                  * to perform this test if the mask was all 1's */
4105
4106                 if (in_dev->ifa_list->ifa_mask != 0xffffffff &&
4107                     (in_dev->ifa_list->ifa_mask & arphdr->ar_sip) !=
4108                         (in_dev->ifa_list->ifa_mask & in_dev->ifa_list->ifa_local)) {
4109
4110                         printk(KERN_INFO "%s: Invalid PtP address.  InARP ignored.\n",
4111                                         card->devname);
4112                         return -1;
4113                 }
4114
4115                 /* Make sure that the received IP address is not
4116                  * the same as our own local address */
4117                 if (in_dev->ifa_list->ifa_local == arphdr->ar_sip) {
4118                         printk(KERN_INFO "%s: Local addr = PtP addr.  InARP ignored.\n",
4119                                 card->devname);
4120                         return -1;
4121                 }
4122
4123                 chan->ip_local  = in_dev->ifa_list->ifa_local;
4124                 chan->ip_remote = arphdr->ar_sip;
4125
4126                 /* Add Route Flag */
4127                 /* The route will be added in the polling routine so
4128                    that it is not interrupt context. */
4129
4130                 chan->route_flag = ADD_ROUTE;
4131                 chan->inarp = INARP_CONFIGURED;
4132                 trigger_fr_poll(dev);
4133
4134                 break;
4135         default:
4136                 break; // ARP's and RARP's -- Shouldn't happen.
4137         }
4138
4139         return 0;
4140 }
4141
4142
4143 /*============================================================
4144  * trigger_fr_arp
4145  *
4146  * Description:
4147  *      Add an fr_arp() task into a arp
4148  *      timer handler for a specific dlci/interface.
4149  *      This will kick the fr_arp() routine
4150  *      within the specified time interval.
4151  *
4152  * Usage:
4153  *      This timer is used to send ARP requests at
4154  *      certain time intervals.
4155  *      Called by an interrupt to request an action
4156  *      at a later date.
4157  */
4158
4159 static void trigger_fr_arp(struct net_device *dev)
4160 {
4161         fr_channel_t* chan = dev->priv;
4162
4163         mod_timer(&chan->fr_arp_timer, jiffies + chan->inarp_interval * HZ);
4164         return;
4165 }
4166
4167
4168
4169 /*==============================================================================
4170  * ARP Request Action
4171  *
4172  *      This funciton is called by timer interrupt to send an arp request
4173  *      to the remote end.
4174  */
4175
4176 static void fr_arp (unsigned long data)
4177 {
4178         struct net_device *dev = (struct net_device *)data;
4179         fr_channel_t *chan = dev->priv;
4180         volatile sdla_t *card = chan->card;
4181         fr508_flags_t* flags = card->flags;
4182
4183         /* Send ARP packets for all devs' until
4184          * ARP state changes to CONFIGURED */
4185
4186         if (chan->inarp == INARP_REQUEST &&
4187             chan->common.state == WAN_CONNECTED &&
4188             card->wandev.state == WAN_CONNECTED){
4189                 set_bit(0,&chan->inarp_ready);
4190                 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_ARP;
4191                 flags->imask |= FR_INTR_TIMER;
4192         }
4193
4194         return;
4195 }
4196
4197
4198 /*==============================================================================
4199  * Perform the Interrupt Test by running the READ_CODE_VERSION command MAX_INTR_
4200  * TEST_COUNTER times.
4201  */
4202 static int intr_test( sdla_t* card )
4203 {
4204         fr_mbox_t* mb = card->mbox;
4205         int err,i;
4206
4207         err = fr_set_intr_mode(card, FR_INTR_READY, card->wandev.mtu, 0 );
4208
4209         if (err == CMD_OK) {
4210
4211                 for ( i = 0; i < MAX_INTR_TEST_COUNTER; i++ ) {
4212                         /* Run command READ_CODE_VERSION */
4213                         mb->cmd.length  = 0;
4214                         mb->cmd.command = FR_READ_CODE_VERSION;
4215                         err = sdla_exec(mb) ? mb->cmd.result : CMD_TIMEOUT;
4216                         if (err != CMD_OK)
4217                                 fr_event(card, err, mb);
4218                 }
4219
4220         } else {
4221                 return err;
4222         }
4223
4224         err = fr_set_intr_mode( card, 0, card->wandev.mtu, 0 );
4225
4226         if( err != CMD_OK )
4227                 return err;
4228
4229         return 0;
4230 }
4231
4232 /*==============================================================================
4233  * Determine what type of UDP call it is. FPIPE8ND ?
4234  */
4235 static int udp_pkt_type( struct sk_buff *skb, sdla_t* card )
4236 {
4237         fr_udp_pkt_t *fr_udp_pkt = (fr_udp_pkt_t *)skb->data;
4238
4239         /* Quick HACK */
4240
4241
4242         if((fr_udp_pkt->ip_pkt.protocol == UDPMGMT_UDP_PROTOCOL) &&
4243                 (fr_udp_pkt->ip_pkt.ver_inet_hdr_length == 0x45) &&
4244                 (fr_udp_pkt->udp_pkt.udp_dst_port ==
4245                 ntohs(card->wandev.udp_port)) &&
4246                 (fr_udp_pkt->wp_mgmt.request_reply ==
4247                 UDPMGMT_REQUEST)) {
4248                         if(!strncmp(fr_udp_pkt->wp_mgmt.signature,
4249                                 UDPMGMT_FPIPE_SIGNATURE, 8)){
4250                                 return UDP_FPIPE_TYPE;
4251                         }
4252         }
4253         return UDP_INVALID_TYPE;
4254 }
4255
4256
4257 /*==============================================================================
4258  * Initializes the Statistics values in the fr_channel structure.
4259  */
4260 void init_chan_statistics( fr_channel_t* chan)
4261 {
4262         memset(&chan->drvstats_if_send.if_send_entry, 0,
4263                 sizeof(if_send_stat_t));
4264         memset(&chan->drvstats_rx_intr.rx_intr_no_socket, 0,
4265                 sizeof(rx_intr_stat_t));
4266         memset(&chan->drvstats_gen.UDP_PIPE_mgmt_kmalloc_err, 0,
4267                 sizeof(pipe_mgmt_stat_t));
4268 }
4269
4270 /*==============================================================================
4271  * Initializes the Statistics values in the Sdla_t structure.
4272  */
4273 void init_global_statistics( sdla_t* card )
4274 {
4275         /* Intialize global statistics for a card */
4276         memset(&card->statistics.isr_entry, 0, sizeof(global_stats_t));
4277 }
4278
4279 static void read_DLCI_IB_mapping( sdla_t* card, fr_channel_t* chan )
4280 {
4281         fr_mbox_t* mbox = card->mbox;
4282         int retry = MAX_CMD_RETRY;
4283         dlci_IB_mapping_t* result;
4284         int err, counter, found;
4285
4286         do {
4287                 mbox->cmd.command = FR_READ_DLCI_IB_MAPPING;
4288                 mbox->cmd.length = 0;
4289                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4290         } while (err && retry-- && fr_event(card, err, mbox));
4291
4292         if( mbox->cmd.result != 0){
4293                 printk(KERN_INFO "%s: Read DLCI IB Mapping failed\n",
4294                         chan->name);
4295         }
4296
4297         counter = mbox->cmd.length / sizeof(dlci_IB_mapping_t);
4298         result = (void *)mbox->data;
4299
4300         found = 0;
4301         for (; counter; --counter, ++result) {
4302                 if ( result->dlci == chan->dlci ) {
4303                         chan->IB_addr = result->addr_value;
4304                         if(card->hw.type == SDLA_S514){
4305                                 chan->dlci_int_interface =
4306                                         (void*)(card->hw.dpmbase +
4307                                         chan->IB_addr);
4308                         }else{
4309                                 chan->dlci_int_interface =
4310                                         (void*)(card->hw.dpmbase +
4311                                         (chan->IB_addr & 0x00001FFF));
4312
4313                         }
4314                         found = 1;
4315                         break;
4316                 }
4317         }
4318         if (!found)
4319                 printk( KERN_INFO "%s: DLCI %d not found by IB MAPPING cmd\n",
4320                 card->devname, chan->dlci);
4321 }
4322
4323
4324
4325 void s508_s514_lock(sdla_t *card, unsigned long *smp_flags)
4326 {
4327         if (card->hw.type != SDLA_S514){
4328
4329                 spin_lock_irqsave(&card->wandev.lock, *smp_flags);
4330         }else{
4331                 spin_lock(&card->u.f.if_send_lock);
4332         }
4333         return;
4334 }
4335
4336
4337 void s508_s514_unlock(sdla_t *card, unsigned long *smp_flags)
4338 {
4339         if (card->hw.type != SDLA_S514){
4340
4341                 spin_unlock_irqrestore (&card->wandev.lock, *smp_flags);
4342         }else{
4343                 spin_unlock(&card->u.f.if_send_lock);
4344         }
4345         return;
4346 }
4347
4348
4349
4350 /*----------------------------------------------------------------------
4351                   RECEIVE INTERRUPT: BOTTOM HALF HANDLERS
4352  ----------------------------------------------------------------------*/
4353
4354
4355 /*========================================================
4356  * bh_enqueue
4357  *
4358  * Description:
4359  *      Insert a received packet into a circular
4360  *      rx queue.  This packet will be picked up
4361  *      by fr_bh() and sent up the stack to the
4362  *      user.
4363  *
4364  * Usage:
4365  *      This function is called by rx interrupt,
4366  *      in API mode.
4367  *
4368  */
4369
4370 static int bh_enqueue(struct net_device *dev, struct sk_buff *skb)
4371 {
4372         /* Check for full */
4373         fr_channel_t* chan = dev->priv;
4374         sdla_t *card = chan->card;
4375
4376
4377         if (atomic_read(&chan->bh_buff_used) == MAX_BH_BUFF){
4378                 ++card->wandev.stats.rx_dropped;
4379                 dev_kfree_skb_any(skb);
4380                 return 1;
4381         }
4382
4383         ((bh_data_t *)&chan->bh_head[chan->bh_write])->skb = skb;
4384
4385         if (chan->bh_write == (MAX_BH_BUFF-1)){
4386                 chan->bh_write=0;
4387         }else{
4388                 ++chan->bh_write;
4389         }
4390
4391         atomic_inc(&chan->bh_buff_used);
4392
4393         return 0;
4394 }
4395
4396
4397 /*========================================================
4398  * trigger_fr_bh
4399  *
4400  * Description:
4401  *      Kick the fr_bh() handler
4402  *
4403  * Usage:
4404  *      rx interrupt calls this function during
4405  *      the API mode.
4406  */
4407
4408 static void trigger_fr_bh (fr_channel_t *chan)
4409 {
4410         if (!test_and_set_bit(0,&chan->tq_working)){
4411                 wanpipe_queue_work(&chan->common.wanpipe_work);
4412         }
4413 }
4414
4415
4416 /*========================================================
4417  * fr_bh
4418  *
4419  * Description:
4420  *      Frame relay receive BH handler.
4421  *      Dequeue data from the BH circular
4422  *      buffer and pass it up the API sock.
4423  *
4424  * Rationale:
4425  *      This fuction is used to offload the
4426  *      rx_interrupt during API operation mode.
4427  *      The fr_bh() function executes for each
4428  *      dlci/interface.
4429  *
4430  *      Once receive interrupt copies data from the
4431  *      card into an skb buffer, the skb buffer
4432  *      is appended to a circular BH buffer.
4433  *      Then the interrupt kicks fr_bh() to finish the
4434  *      job at a later time (not within the interrupt).
4435  *
4436  * Usage:
4437  *      Interrupts use this to defer a task to
4438  *      a polling routine.
4439  *
4440  */
4441
4442 static void fr_bh(struct net_device * dev)
4443 {
4444         fr_channel_t* chan = dev->priv;
4445         sdla_t *card = chan->card;
4446         struct sk_buff *skb;
4447
4448         if (atomic_read(&chan->bh_buff_used) == 0){
4449                 clear_bit(0, &chan->tq_working);
4450                 return;
4451         }
4452
4453         while (atomic_read(&chan->bh_buff_used)){
4454
4455                 if (chan->common.sk == NULL || chan->common.func == NULL){
4456                         clear_bit(0, &chan->tq_working);
4457                         return;
4458                 }
4459
4460                 skb  = ((bh_data_t *)&chan->bh_head[chan->bh_read])->skb;
4461
4462                 if (skb != NULL){
4463
4464                         if (chan->common.sk == NULL || chan->common.func == NULL){
4465                                 ++card->wandev.stats.rx_dropped;
4466                                 ++chan->ifstats.rx_dropped;
4467                                 dev_kfree_skb_any(skb);
4468                                 fr_bh_cleanup(dev);
4469                                 continue;
4470                         }
4471
4472                         if (chan->common.func(skb,dev,chan->common.sk) != 0){
4473                                 /* Sock full cannot send, queue us for
4474                                  * another try */
4475                                 atomic_set(&chan->common.receive_block,1);
4476                                 return;
4477                         }else{
4478                                 fr_bh_cleanup(dev);
4479                         }
4480                 }else{
4481                         fr_bh_cleanup(dev);
4482                 }
4483         }
4484         clear_bit(0, &chan->tq_working);
4485
4486         return;
4487 }
4488
4489 static int fr_bh_cleanup(struct net_device *dev)
4490 {
4491         fr_channel_t* chan = dev->priv;
4492
4493         ((bh_data_t *)&chan->bh_head[chan->bh_read])->skb = NULL;
4494
4495         if (chan->bh_read == (MAX_BH_BUFF-1)){
4496                 chan->bh_read=0;
4497         }else{
4498                 ++chan->bh_read;
4499         }
4500
4501         atomic_dec(&chan->bh_buff_used);
4502         return 0;
4503 }
4504
4505
4506 /*----------------------------------------------------------------------
4507                POLL BH HANDLERS AND KICK ROUTINES
4508  ----------------------------------------------------------------------*/
4509
4510 /*============================================================
4511  * trigger_fr_poll
4512  *
4513  * Description:
4514  *      Add a fr_poll() task into a tq_scheduler bh handler
4515  *      for a specific dlci/interface.  This will kick
4516  *      the fr_poll() routine at a later time.
4517  *
4518  * Usage:
4519  *      Interrupts use this to defer a taks to
4520  *      a polling routine.
4521  *
4522  */
4523 static void trigger_fr_poll(struct net_device *dev)
4524 {
4525         fr_channel_t* chan = dev->priv;
4526         schedule_work(&chan->fr_poll_work);
4527         return;
4528 }
4529
4530
4531 /*============================================================
4532  * fr_poll
4533  *
4534  * Rationale:
4535  *      We cannot manipulate the routing tables, or
4536  *      ip addresses withing the interrupt. Therefore
4537  *      we must perform such actons outside an interrupt
4538  *      at a later time.
4539  *
4540  * Description:
4541  *      Frame relay polling routine, responsible for
4542  *      shutting down interfaces upon disconnect
4543  *      and adding/removing routes.
4544  *
4545  * Usage:
4546  *      This function is executed for each frame relay
4547  *      dlci/interface through a tq_schedule bottom half.
4548  *
4549  *      trigger_fr_poll() function is used to kick
4550  *      the fr_poll routine.
4551  */
4552
4553 static void fr_poll(struct net_device *dev)
4554 {
4555
4556         fr_channel_t* chan;
4557         sdla_t *card;
4558         u8 check_gateway=0;
4559
4560         if (!dev || (chan = dev->priv) == NULL)
4561                 return;
4562
4563         card = chan->card;
4564
4565         /* (Re)Configuraiton is in progress, stop what you are
4566          * doing and get out */
4567         if (test_bit(PERI_CRIT,&card->wandev.critical)){
4568                 return;
4569         }
4570
4571         switch (chan->common.state){
4572
4573         case WAN_DISCONNECTED:
4574
4575                 if (test_bit(DYN_OPT_ON,&chan->interface_down) &&
4576                     !test_bit(DEV_DOWN, &chan->interface_down) &&
4577                     dev->flags&IFF_UP){
4578
4579                         printk(KERN_INFO "%s: Interface %s is Down.\n",
4580                                 card->devname,dev->name);
4581                         change_dev_flags(dev,dev->flags&~IFF_UP);
4582                         set_bit(DEV_DOWN, &chan->interface_down);
4583                         chan->route_flag = NO_ROUTE;
4584
4585                 }else{
4586                         if (chan->inarp != INARP_NONE)
4587                                 process_route(dev);
4588                 }
4589                 break;
4590
4591         case WAN_CONNECTED:
4592
4593                 if (test_bit(DYN_OPT_ON,&chan->interface_down) &&
4594                     test_bit(DEV_DOWN, &chan->interface_down) &&
4595                     !(dev->flags&IFF_UP)){
4596
4597                         printk(KERN_INFO "%s: Interface %s is Up.\n",
4598                                         card->devname,dev->name);
4599
4600                         change_dev_flags(dev,dev->flags|IFF_UP);
4601                         clear_bit(DEV_DOWN, &chan->interface_down);
4602                         check_gateway=1;
4603                 }
4604
4605                 if (chan->inarp != INARP_NONE){
4606                         process_route(dev);
4607                         check_gateway=1;
4608                 }
4609
4610                 if (chan->gateway && check_gateway)
4611                         add_gateway(card,dev);
4612
4613                 break;
4614
4615         }
4616
4617         return;
4618 }
4619
4620 /*==============================================================
4621  * check_tx_status
4622  *
4623  * Rationale:
4624  *      We cannot transmit from an interrupt while
4625  *      the if_send is transmitting data.  Therefore,
4626  *      we must check whether the tx buffers are
4627  *      begin used, before we transmit from an
4628  *      interrupt.
4629  *
4630  * Description:
4631  *      Checks whether it's safe to use the transmit
4632  *      buffers.
4633  *
4634  * Usage:
4635  *      ARP and UDP handling routines use this function
4636  *      because, they need to transmit data during
4637  *      an interrupt.
4638  */
4639
4640 static int check_tx_status(sdla_t *card, struct net_device *dev)
4641 {
4642
4643         if (card->hw.type == SDLA_S514){
4644                 if (test_bit(SEND_CRIT, (void*)&card->wandev.critical) ||
4645                         test_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical)) {
4646                         return 1;
4647                 }
4648         }
4649
4650         if (netif_queue_stopped(dev) || (card->u.f.tx_interrupts_pending))
4651                 return 1;
4652
4653         return 0;
4654 }
4655
4656 /*===============================================================
4657  * move_dev_to_next
4658  *
4659  * Description:
4660  *      Move the dev pointer to the next location in the
4661  *      link list.  Check if we are at the end of the
4662  *      list, if so start from the begining.
4663  *
4664  * Usage:
4665  *      Timer interrupt uses this function to efficiently
4666  *      step through the devices that need to send ARP data.
4667  *
4668  */
4669
4670 struct net_device *move_dev_to_next(sdla_t *card, struct net_device *dev)
4671 {
4672         if (card->wandev.new_if_cnt != 1){
4673                 if (!*((struct net_device **)dev->priv))
4674                         return card->wandev.dev;
4675                 else
4676                         return *((struct net_device **)dev->priv);
4677         }
4678         return dev;
4679 }
4680
4681 /*==============================================================
4682  * trigger_config_fr
4683  *
4684  * Rationale:
4685  *      All commands must be performed inside of a
4686  *      interrupt.
4687  *
4688  * Description:
4689  *      Kick the config_fr() routine throught the
4690  *      timer interrupt.
4691  */
4692
4693
4694 static void trigger_config_fr (sdla_t *card)
4695 {
4696         fr508_flags_t* flags = card->flags;
4697
4698         card->u.f.timer_int_enabled |= TMR_INT_ENABLED_CONFIG;
4699         flags->imask |= FR_INTR_TIMER;
4700 }
4701
4702
4703 /*==============================================================
4704  * config_fr
4705  *
4706  * Rationale:
4707  *      All commands must be performed inside of a
4708  *      interrupt.
4709  &
4710  * Description:
4711  *      Configure a DLCI. This function is executed
4712  *      by a timer_interrupt.  The if_open() function
4713  *      triggers it.
4714  *
4715  * Usage:
4716  *      new_if() collects all data necessary to
4717  *      configure the DLCI. It sets the chan->dlci_ready
4718  *      bit.  When the if_open() function is executed
4719  *      it checks this bit, and if its set it triggers
4720  *      the timer interrupt to execute the config_fr()
4721  *      function.
4722  */
4723
4724 static void config_fr (sdla_t *card)
4725 {
4726         struct net_device *dev;
4727         fr_channel_t *chan;
4728
4729         for (dev = card->wandev.dev; dev;
4730              dev = *((struct net_device **)dev->priv)) {
4731
4732                 if ((chan=dev->priv) == NULL)
4733                         continue;
4734
4735                 if (!test_bit(0,&chan->config_dlci))
4736                         continue;
4737
4738                 clear_bit(0,&chan->config_dlci);
4739
4740                 /* If signalling is set to NO, then setup
4741                  * DLCI addresses right away.  Don't have to wait for
4742                  * link to connect.
4743                  */
4744                 if (card->wandev.signalling == WANOPT_NO){
4745                         printk(KERN_INFO "%s: Signalling set to NO: Mapping DLCI's\n",
4746                                         card->wandev.name);
4747                         if (fr_init_dlci(card,chan)){
4748                                 printk(KERN_INFO "%s: ERROR: Failed to configure DLCI %i !\n",
4749                                         card->devname, chan->dlci);
4750                                 return;
4751                         }
4752                 }
4753
4754                 if (card->wandev.station == WANOPT_CPE) {
4755
4756                         update_chan_state(dev);
4757
4758                         /* CPE: issue full status enquiry */
4759                         fr_issue_isf(card, FR_ISF_FSE);
4760
4761                 } else {
4762                         /* FR switch: activate DLCI(s) */
4763
4764                         /* For Switch emulation we have to ADD and ACTIVATE
4765                          * the DLCI(s) that were configured with the SET_DLCI_
4766                          * CONFIGURATION command. Add and Activate will fail if
4767                          * DLCI specified is not included in the list.
4768                          *
4769                          * Also If_open is called once for each interface. But
4770                          * it does not get in here for all the interface. So
4771                          * we have to pass the entire list of DLCI(s) to add
4772                          * activate routines.
4773                          */
4774
4775                         if (!check_dlci_config (card, chan)){
4776                                 fr_add_dlci(card, chan->dlci);
4777                                 fr_activate_dlci(card, chan->dlci);
4778                         }
4779                 }
4780
4781                 card->u.f.dlci_to_dev_map[chan->dlci] = dev;
4782         }
4783         return;
4784 }
4785
4786
4787 /*==============================================================
4788  * config_fr
4789  *
4790  * Rationale:
4791  *      All commands must be executed during an interrupt.
4792  *
4793  * Description:
4794  *      Trigger uncofig_fr() function through
4795  *      the timer interrupt.
4796  *
4797  */
4798
4799 static void trigger_unconfig_fr(struct net_device *dev)
4800 {
4801         fr_channel_t *chan = dev->priv;
4802         volatile sdla_t *card = chan->card;
4803         unsigned long timeout;
4804         fr508_flags_t* flags = card->flags;
4805         int reset_critical=0;
4806
4807         if (test_bit(PERI_CRIT,(void*)&card->wandev.critical)){
4808                 clear_bit(PERI_CRIT,(void*)&card->wandev.critical);
4809                 reset_critical=1;
4810         }
4811
4812         /* run unconfig_dlci() function
4813          * throught the timer interrupt */
4814         set_bit(0,(void*)&chan->unconfig_dlci);
4815         card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UNCONFIG;
4816         flags->imask |= FR_INTR_TIMER;
4817
4818         /* Wait for the command to complete */
4819         timeout = jiffies;
4820         for(;;) {
4821
4822                 if(!(card->u.f.timer_int_enabled & TMR_INT_ENABLED_UNCONFIG))
4823                         break;
4824
4825                 if (time_after(jiffies, timeout + 1 * HZ)){
4826                         card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UNCONFIG;
4827                         printk(KERN_INFO "%s: Failed to delete DLCI %i\n",
4828                                 card->devname,chan->dlci);
4829                         break;
4830                 }
4831         }
4832
4833         if (reset_critical){
4834                 set_bit(PERI_CRIT,(void*)&card->wandev.critical);
4835         }
4836 }
4837
4838 /*==============================================================
4839  * unconfig_fr
4840  *
4841  * Rationale:
4842  *      All commands must be executed during an interrupt.
4843  *
4844  * Description:
4845  *      Remove the dlci from firmware.
4846  *      This funciton is used in NODE shutdown.
4847  */
4848
4849 static void unconfig_fr (sdla_t *card)
4850 {
4851         struct net_device *dev;
4852         fr_channel_t *chan;
4853
4854         for (dev = card->wandev.dev; dev;
4855              dev = *((struct net_device **)dev->priv)){
4856
4857                 if ((chan=dev->priv) == NULL)
4858                         continue;
4859
4860                 if (!test_bit(0,&chan->unconfig_dlci))
4861                         continue;
4862
4863                 clear_bit(0,&chan->unconfig_dlci);
4864
4865                 if (card->wandev.station == WANOPT_NODE){
4866                         printk(KERN_INFO "%s: Unconfiguring DLCI %i\n",
4867                                         card->devname,chan->dlci);
4868                         fr_delete_dlci(card,chan->dlci);
4869                 }
4870                 card->u.f.dlci_to_dev_map[chan->dlci] = NULL;
4871         }
4872 }
4873
4874 static int setup_fr_header(struct sk_buff **skb_orig, struct net_device* dev,
4875                            char op_mode)
4876 {
4877         struct sk_buff *skb = *skb_orig;
4878         fr_channel_t *chan=dev->priv;
4879
4880         if (op_mode == WANPIPE){
4881
4882                 chan->fr_header[0]=Q922_UI;
4883
4884                 switch (htons(skb->protocol)){
4885
4886                 case ETH_P_IP:
4887                         chan->fr_header[1]=NLPID_IP;
4888                         break;
4889                 default:
4890                         return -EINVAL;
4891                 }
4892
4893                 return 2;
4894         }
4895
4896         /* If we are in bridging mode, we must apply
4897          * an Ethernet header */
4898         if (op_mode == BRIDGE || op_mode == BRIDGE_NODE){
4899
4900
4901                 /* Encapsulate the packet as a bridged Ethernet frame. */
4902 #ifdef DEBUG
4903                 printk(KERN_INFO "%s: encapsulating skb for frame relay\n",
4904                         dev->name);
4905 #endif
4906
4907                 chan->fr_header[0] = 0x03;
4908                 chan->fr_header[1] = 0x00;
4909                 chan->fr_header[2] = 0x80;
4910                 chan->fr_header[3] = 0x00;
4911                 chan->fr_header[4] = 0x80;
4912                 chan->fr_header[5] = 0xC2;
4913                 chan->fr_header[6] = 0x00;
4914                 chan->fr_header[7] = 0x07;
4915
4916                 /* Yuck. */
4917                 skb->protocol = ETH_P_802_3;
4918                 return 8;
4919
4920         }
4921
4922         return 0;
4923 }
4924
4925
4926 static int check_dlci_config (sdla_t *card, fr_channel_t *chan)
4927 {
4928         fr_mbox_t* mbox = card->mbox;
4929         int err=0;
4930         fr_conf_t *conf=NULL;
4931         unsigned short dlci_num = chan->dlci;
4932         int dlci_offset=0;
4933         struct net_device *dev = NULL;
4934
4935         mbox->cmd.command = FR_READ_CONFIG;
4936         mbox->cmd.length = 0;
4937         mbox->cmd.dlci = dlci_num;
4938
4939         err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4940
4941         if (err == CMD_OK){
4942                 return 0;
4943         }
4944
4945         for (dev = card->wandev.dev; dev;
4946              dev=*((struct net_device **)dev->priv))
4947                 set_chan_state(dev,WAN_DISCONNECTED);
4948
4949         printk(KERN_INFO "DLCI %i Not configured, configuring\n",dlci_num);
4950
4951         mbox->cmd.command = FR_COMM_DISABLE;
4952         mbox->cmd.length = 0;
4953         err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4954         if (err != CMD_OK){
4955                 fr_event(card, err, mbox);
4956                 return 2;
4957         }
4958
4959         printk(KERN_INFO "Disabled Communications \n");
4960
4961         mbox->cmd.command = FR_READ_CONFIG;
4962         mbox->cmd.length = 0;
4963         mbox->cmd.dlci = 0;
4964
4965         err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4966
4967         if (err != CMD_OK){
4968                 fr_event(card, err, mbox);
4969                 return 2;
4970         }
4971
4972         conf = (fr_conf_t *)mbox->data;
4973
4974         dlci_offset=0;
4975         for (dev = card->wandev.dev; dev;
4976              dev = *((struct net_device **)dev->priv)) {
4977                 fr_channel_t *chan_tmp = dev->priv;
4978                 conf->dlci[dlci_offset] = chan_tmp->dlci;
4979                 dlci_offset++;
4980         }
4981
4982         printk(KERN_INFO "Got Fr configuration Buffer Length is %x Dlci %i Dlci Off %i\n",
4983                 mbox->cmd.length,
4984                 mbox->cmd.length > 0x20 ? conf->dlci[0] : -1,
4985                 dlci_offset );
4986
4987         mbox->cmd.length = 0x20 + dlci_offset*2;
4988
4989         mbox->cmd.command = FR_SET_CONFIG;
4990         mbox->cmd.dlci = 0;
4991
4992         err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4993
4994         if (err != CMD_OK){
4995                 fr_event(card, err, mbox);
4996                 return 2;
4997         }
4998
4999         initialize_rx_tx_buffers (card);
5000
5001
5002         printk(KERN_INFO "Configuraiton Succeded for new DLCI %i\n",dlci_num);
5003
5004         if (fr_comm_enable (card)){
5005                 return 2;
5006         }
5007
5008         printk(KERN_INFO "Enabling Communications \n");
5009
5010         for (dev = card->wandev.dev; dev;
5011              dev = *((struct net_device **)dev->priv)) {
5012                 fr_channel_t *chan_tmp = dev->priv;
5013                 fr_init_dlci(card,chan_tmp);
5014                 fr_add_dlci(card, chan_tmp->dlci);
5015                 fr_activate_dlci(card, chan_tmp->dlci);
5016         }
5017
5018         printk(KERN_INFO "END OF CONFIGURAITON %i\n",dlci_num);
5019
5020         return 1;
5021 }
5022
5023 static void initialize_rx_tx_buffers (sdla_t *card)
5024 {
5025         fr_buf_info_t* buf_info;
5026
5027         if (card->hw.type == SDLA_S514) {
5028
5029                 buf_info = (void*)(card->hw.dpmbase + FR_MB_VECTOR +
5030                         FR508_RXBC_OFFS);
5031
5032                 card->rxmb = (void*)(buf_info->rse_next + card->hw.dpmbase);
5033
5034                 card->u.f.rxmb_base =
5035                         (void*)(buf_info->rse_base + card->hw.dpmbase);
5036
5037                 card->u.f.rxmb_last =
5038                         (void*)(buf_info->rse_base +
5039                         (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) +
5040                         card->hw.dpmbase);
5041         }else{
5042                 buf_info = (void*)(card->hw.dpmbase + FR508_RXBC_OFFS);
5043
5044                 card->rxmb = (void*)(buf_info->rse_next -
5045                         FR_MB_VECTOR + card->hw.dpmbase);
5046
5047                 card->u.f.rxmb_base =
5048                         (void*)(buf_info->rse_base -
5049                         FR_MB_VECTOR + card->hw.dpmbase);
5050
5051                 card->u.f.rxmb_last =
5052                         (void*)(buf_info->rse_base +
5053                         (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) -
5054                         FR_MB_VECTOR + card->hw.dpmbase);
5055         }
5056
5057         card->u.f.rx_base = buf_info->buf_base;
5058         card->u.f.rx_top  = buf_info->buf_top;
5059
5060         card->u.f.tx_interrupts_pending = 0;
5061
5062         return;
5063 }
5064
5065
5066
5067 MODULE_LICENSE("GPL");
5068
5069 /****** End *****************************************************************/