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