drivers/net/wan/wanpipe_multppp.c

   1 /*****************************************************************************
   2 * wanpipe_multppp.c Multi-Port PPP driver module.
   3 *
   4 * Authors:      Nenad Corbic <ncorbic@sangoma.com>
   5 *
   6 * Copyright:    (c) 1995-2001 Sangoma Technologies Inc.
   7 *
   8 *               This program is free software; you can redistribute it and/or
   9 *               modify it under the terms of the GNU General Public License
  10 *               as published by the Free Software Foundation; either version
  11 *               2 of the License, or (at your option) any later version.
  12 * ============================================================================
  13 * Dec 15 2000   Updated for 2.4.X kernel
  14 * Nov 15 2000   Fixed the SyncPPP support for kernels 2.2.16 and higher.
  15 *               The pppstruct has changed.
  16 * Jul 13 2000   Using the kernel Syncppp module on top of RAW Wanpipe CHDLC
  17 *               module.
  18 *****************************************************************************/
  19
  20 #include <linux/module.h>
  21 #include <linux/kernel.h>       /* printk(), and other useful stuff */
  22 #include <linux/stddef.h>       /* offsetof(), etc. */
  23 #include <linux/errno.h>        /* return codes */
  24 #include <linux/string.h>       /* inline memset(), etc. */
  25 #include <linux/slab.h> /* kmalloc(), kfree() */
  26 #include <linux/wanrouter.h>    /* WAN router definitions */
  27 #include <linux/wanpipe.h>      /* WANPIPE common user API definitions */
  28 #include <linux/if_arp.h>       /* ARPHRD_* defines */
  29 #include <linux/jiffies.h>      /* time_after() macro */
  30
  31 #include <linux/in.h>           /* sockaddr_in */
  32 #include <linux/inet.h>
  33 #include <linux/if.h>
  34 #include <asm/byteorder.h>      /* htons(), etc. */
  35 #include <linux/sdlapci.h>
  36 #include <asm/io.h>
  37
  38 #include <linux/sdla_chdlc.h>           /* CHDLC firmware API definitions */
  39 #include <linux/sdla_asy.h>             /* CHDLC (async) API definitions */
  40
  41 #include <linux/if_wanpipe_common.h>    /* Socket Driver common area */
  42 #include <linux/if_wanpipe.h>
  43
  44
  45 #include <linux/inetdevice.h>
  46 #include <asm/uaccess.h>
  47
  48 #include <net/syncppp.h>
  49
  50
  51 /****** Defines & Macros ****************************************************/
  52
  53 #ifdef  _DEBUG_
  54 #define STATIC
  55 #else
  56 #define STATIC          static
  57 #endif
  58
  59 /* reasons for enabling the timer interrupt on the adapter */
  60 #define TMR_INT_ENABLED_UDP     0x01
  61 #define TMR_INT_ENABLED_UPDATE  0x02
  62 #define TMR_INT_ENABLED_CONFIG  0x04
  63
  64 #define CHDLC_DFLT_DATA_LEN     1500            /* default MTU */
  65 #define CHDLC_HDR_LEN           1
  66
  67 #define IFF_POINTTOPOINT 0x10
  68
  69 #define CHDLC_API 0x01
  70
  71 #define PORT(x)   (x == 0 ? "PRIMARY" : "SECONDARY" )
  72 #define MAX_BH_BUFF     10
  73
  74 #define CRC_LENGTH      2
  75 #define PPP_HEADER_LEN  4
  76
  77 /******Data Structures*****************************************************/
  78
  79 /* This structure is placed in the private data area of the device structure.
  80  * The card structure used to occupy the private area but now the following
  81  * structure will incorporate the card structure along with CHDLC specific data
  82  */
  83
  84 typedef struct chdlc_private_area
  85 {
  86         void *if_ptr;                           /* General Pointer used by SPPP */
  87         wanpipe_common_t common;
  88         sdla_t          *card;
  89         int             TracingEnabled;         /* For enabling Tracing */
  90         unsigned long   curr_trace_addr;        /* Used for Tracing */
  91         unsigned long   start_trace_addr;
  92         unsigned long   end_trace_addr;
  93         unsigned long   base_addr_trace_buffer;
  94         unsigned long   end_addr_trace_buffer;
  95         unsigned short  number_trace_elements;
  96         unsigned        available_buffer_space;
  97         unsigned long   router_start_time;
  98         unsigned char   route_status;
  99         unsigned char   route_removed;
 100         unsigned long   tick_counter;           /* For 5s timeout counter */
 101         unsigned long   router_up_time;
 102         u32             IP_address;             /* IP addressing */
 103         u32             IP_netmask;
 104         unsigned char  mc;                      /* Mulitcast support on/off */
 105         unsigned short udp_pkt_lgth;            /* udp packet processing */
 106         char udp_pkt_src;
 107         char udp_pkt_data[MAX_LGTH_UDP_MGNT_PKT];
 108         unsigned short timer_int_enabled;
 109         char update_comms_stats;                /* updating comms stats */
 110
 111         //FIXME: add driver stats as per frame relay!
 112
 113 } chdlc_private_area_t;
 114
 115 /* Route Status options */
 116 #define NO_ROUTE        0x00
 117 #define ADD_ROUTE       0x01
 118 #define ROUTE_ADDED     0x02
 119 #define REMOVE_ROUTE    0x03
 120
 121
 122 /* variable for keeping track of enabling/disabling FT1 monitor status */
 123 static int rCount = 0;
 124
 125 /* variable for tracking how many interfaces to open for WANPIPE on the
 126    two ports */
 127
 128 extern void disable_irq(unsigned int);
 129 extern void enable_irq(unsigned int);
 130
 131 /****** Function Prototypes *************************************************/
 132 /* WAN link driver entry points. These are called by the WAN router module. */
 133 static int update(struct wan_device* wandev);
 134 static int new_if(struct wan_device* wandev, struct net_device* dev,
 135                   wanif_conf_t* conf);
 136 static int del_if(struct wan_device* wandev, struct net_device* dev);
 137
 138 /* Network device interface */
 139 static int if_init(struct net_device* dev);
 140 static int if_open(struct net_device* dev);
 141 static int if_close(struct net_device* dev);
 142 static int if_send(struct sk_buff* skb, struct net_device* dev);
 143 static struct net_device_stats* if_stats(struct net_device* dev);
 144
 145 static void if_tx_timeout(struct net_device *dev);
 146
 147 /* CHDLC Firmware interface functions */
 148 static int chdlc_configure      (sdla_t* card, void* data);
 149 static int chdlc_comm_enable    (sdla_t* card);
 150 static int chdlc_comm_disable   (sdla_t* card);
 151 static int chdlc_read_version   (sdla_t* card, char* str);
 152 static int chdlc_set_intr_mode  (sdla_t* card, unsigned mode);
 153 static int chdlc_send (sdla_t* card, void* data, unsigned len);
 154 static int chdlc_read_comm_err_stats (sdla_t* card);
 155 static int chdlc_read_op_stats (sdla_t* card);
 156 static int config_chdlc (sdla_t *card);
 157
 158
 159 /* Miscellaneous CHDLC Functions */
 160 static int set_chdlc_config (sdla_t* card);
 161 static void init_chdlc_tx_rx_buff(sdla_t* card, struct net_device *dev);
 162 static int chdlc_error (sdla_t *card, int err, CHDLC_MAILBOX_STRUCT *mb);
 163 static int process_chdlc_exception(sdla_t *card);
 164 static int process_global_exception(sdla_t *card);
 165 static int update_comms_stats(sdla_t* card,
 166         chdlc_private_area_t* chdlc_priv_area);
 167 static void port_set_state (sdla_t *card, int);
 168
 169 /* Interrupt handlers */
 170 static void wsppp_isr (sdla_t* card);
 171 static void rx_intr (sdla_t* card);
 172 static void timer_intr(sdla_t *);
 173
 174 /* Miscellaneous functions */
 175 static int reply_udp( unsigned char *data, unsigned int mbox_len );
 176 static int intr_test( sdla_t* card);
 177 static int udp_pkt_type( struct sk_buff *skb , sdla_t* card);
 178 static int store_udp_mgmt_pkt(char udp_pkt_src, sdla_t* card,
 179                               struct sk_buff *skb, struct net_device* dev,
 180                               chdlc_private_area_t* chdlc_priv_area);
 181 static int process_udp_mgmt_pkt(sdla_t* card, struct net_device* dev,
 182                                 chdlc_private_area_t* chdlc_priv_area);
 183 static unsigned short calc_checksum (char *, int);
 184 static void s508_lock (sdla_t *card, unsigned long *smp_flags);
 185 static void s508_unlock (sdla_t *card, unsigned long *smp_flags);
 186 static void send_ppp_term_request(struct net_device *dev);
 187
 188
 189 static int  Intr_test_counter;
 190 /****** Public Functions ****************************************************/
 191
 192 /*============================================================================
 193  * Cisco HDLC protocol initialization routine.
 194  *
 195  * This routine is called by the main WANPIPE module during setup.  At this
 196  * point adapter is completely initialized and firmware is running.
 197  *  o read firmware version (to make sure it's alive)
 198  *  o configure adapter
 199  *  o initialize protocol-specific fields of the adapter data space.
 200  *
 201  * Return:      0       o.k.
 202  *              < 0     failure.
 203  */
 204 int wsppp_init (sdla_t* card, wandev_conf_t* conf)
 205 {
 206         unsigned char port_num;
 207         int err;
 208         unsigned long max_permitted_baud = 0;
 209         SHARED_MEMORY_INFO_STRUCT *flags;
 210
 211         union
 212                 {
 213                 char str[80];
 214                 } u;
 215         volatile CHDLC_MAILBOX_STRUCT* mb;
 216         CHDLC_MAILBOX_STRUCT* mb1;
 217         unsigned long timeout;
 218
 219         /* Verify configuration ID */
 220         if (conf->config_id != WANCONFIG_MPPP) {
 221                 printk(KERN_INFO "%s: invalid configuration ID %u!\n",
 222                                   card->devname, conf->config_id);
 223                 return -EINVAL;
 224         }
 225
 226         /* Find out which Port to use */
 227         if ((conf->comm_port == WANOPT_PRI) || (conf->comm_port == WANOPT_SEC)){
 228                 if (card->next){
 229
 230                         if (conf->comm_port != card->next->u.c.comm_port){
 231                                 card->u.c.comm_port = conf->comm_port;
 232                         }else{
 233                                 printk(KERN_ERR "%s: ERROR - %s port used!\n",
 234                                         card->wandev.name, PORT(conf->comm_port));
 235                                 return -EINVAL;
 236                         }
 237                 }else{
 238                         card->u.c.comm_port = conf->comm_port;
 239                 }
 240         }else{
 241                 printk(KERN_ERR "%s: ERROR - Invalid Port Selected!\n",
 242                                         card->wandev.name);
 243                 return -EINVAL;
 244         }
 245
 246
 247         /* Initialize protocol-specific fields */
 248         if(card->hw.type != SDLA_S514){
 249
 250                 if (card->u.c.comm_port == WANOPT_PRI){
 251                         card->mbox  = (void *) card->hw.dpmbase;
 252                 }else{
 253                         card->mbox  = (void *) card->hw.dpmbase +
 254                                 SEC_BASE_ADDR_MB_STRUCT - PRI_BASE_ADDR_MB_STRUCT;
 255                 }
 256         }else{
 257                 /* for a S514 adapter, set a pointer to the actual mailbox in the */
 258                 /* allocated virtual memory area */
 259                 if (card->u.c.comm_port == WANOPT_PRI){
 260                         card->mbox = (void *) card->hw.dpmbase + PRI_BASE_ADDR_MB_STRUCT;
 261                 }else{
 262                         card->mbox = (void *) card->hw.dpmbase + SEC_BASE_ADDR_MB_STRUCT;
 263                 }
 264         }
 265
 266         mb = mb1 = card->mbox;
 267
 268         if (!card->configured){
 269
 270                 /* The board will place an 'I' in the return code to indicate that it is
 271                 ready to accept commands.  We expect this to be completed in less
 272                 than 1 second. */
 273
 274                 timeout = jiffies + 1 * HZ;
 275                 while (mb->return_code != 'I')  /* Wait 1s for board to initialize */
 276                         if (time_after(jiffies, timeout)) break;
 277
 278                 if (mb->return_code != 'I') {
 279                         printk(KERN_INFO
 280                                 "%s: Initialization not completed by adapter\n",
 281                                 card->devname);
 282                         printk(KERN_INFO "Please contact Sangoma representative.\n");
 283                         return -EIO;
 284                 }
 285         }
 286
 287         /* Read firmware version.  Note that when adapter initializes, it
 288          * clears the mailbox, so it may appear that the first command was
 289          * executed successfully when in fact it was merely erased. To work
 290          * around this, we execute the first command twice.
 291          */
 292
 293         if (chdlc_read_version(card, u.str))
 294                 return -EIO;
 295
 296         printk(KERN_INFO "%s: Running Raw CHDLC firmware v%s\n"
 297                          "%s: for Multi-Port PPP protocol.\n",
 298                         card->devname,u.str,card->devname);
 299
 300         card->isr                       = &wsppp_isr;
 301         card->poll                      = NULL;
 302         card->exec                      = NULL;
 303         card->wandev.update             = &update;
 304         card->wandev.new_if             = &new_if;
 305         card->wandev.del_if             = &del_if;
 306         card->wandev.udp_port           = conf->udp_port;
 307
 308         card->wandev.new_if_cnt = 0;
 309
 310         /* reset the number of times the 'update()' proc has been called */
 311         card->u.c.update_call_count = 0;
 312
 313         card->wandev.ttl = conf->ttl;
 314         card->wandev.interface = conf->interface;
 315
 316         if ((card->u.c.comm_port == WANOPT_SEC && conf->interface == WANOPT_V35)&&
 317             card->hw.type != SDLA_S514){
 318                 printk(KERN_INFO "%s: ERROR - V35 Interface not supported on S508 %s port \n",
 319                         card->devname, PORT(card->u.c.comm_port));
 320                 return -EIO;
 321         }
 322
 323
 324         card->wandev.clocking = conf->clocking;
 325
 326         port_num = card->u.c.comm_port;
 327
 328         /* Setup Port Bps */
 329
 330         if(card->wandev.clocking) {
 331                 if((port_num == WANOPT_PRI) || card->u.c.receive_only) {
 332                         /* For Primary Port 0 */
 333                         max_permitted_baud =
 334                                 (card->hw.type == SDLA_S514) ?
 335                                 PRI_MAX_BAUD_RATE_S514 :
 336                                 PRI_MAX_BAUD_RATE_S508;
 337                 }
 338                 else if(port_num == WANOPT_SEC) {
 339                         /* For Secondary Port 1 */
 340                         max_permitted_baud =
 341                                (card->hw.type == SDLA_S514) ?
 342                                 SEC_MAX_BAUD_RATE_S514 :
 343                                 SEC_MAX_BAUD_RATE_S508;
 344                         }
 345
 346                         if(conf->bps > max_permitted_baud) {
 347                                 conf->bps = max_permitted_baud;
 348                                 printk(KERN_INFO "%s: Baud too high!\n",
 349                                         card->wandev.name);
 350                                 printk(KERN_INFO "%s: Baud rate set to %lu bps\n",
 351                                         card->wandev.name, max_permitted_baud);
 352                         }
 353
 354                         card->wandev.bps = conf->bps;
 355         }else{
 356                 card->wandev.bps = 0;
 357         }
 358
 359         /* Setup the Port MTU */
 360         if((port_num == WANOPT_PRI) || card->u.c.receive_only) {
 361
 362                 /* For Primary Port 0 */
 363                 card->wandev.mtu =
 364                         (conf->mtu >= MIN_LGTH_CHDLC_DATA_CFG) ?
 365                         min_t(unsigned int, conf->mtu, PRI_MAX_NO_DATA_BYTES_IN_FRAME) :
 366                         CHDLC_DFLT_DATA_LEN;
 367         } else if(port_num == WANOPT_SEC) {
 368                 /* For Secondary Port 1 */
 369                 card->wandev.mtu =
 370                         (conf->mtu >= MIN_LGTH_CHDLC_DATA_CFG) ?
 371                         min_t(unsigned int, conf->mtu, SEC_MAX_NO_DATA_BYTES_IN_FRAME) :
 372                         CHDLC_DFLT_DATA_LEN;
 373         }
 374
 375         /* Add on a PPP Header */
 376         card->wandev.mtu += PPP_HEADER_LEN;
 377
 378         /* Set up the interrupt status area */
 379         /* Read the CHDLC Configuration and obtain:
 380          *      Ptr to shared memory infor struct
 381          * Use this pointer to calculate the value of card->u.c.flags !
 382          */
 383         mb1->buffer_length = 0;
 384         mb1->command = READ_CHDLC_CONFIGURATION;
 385         err = sdla_exec(mb1) ? mb1->return_code : CMD_TIMEOUT;
 386         if(err != COMMAND_OK) {
 387                 clear_bit(1, (void*)&card->wandev.critical);
 388
 389                 if(card->hw.type != SDLA_S514)
 390                         enable_irq(card->hw.irq);
 391
 392                 chdlc_error(card, err, mb1);
 393                 return -EIO;
 394         }
 395
 396         if(card->hw.type == SDLA_S514){
 397                 card->u.c.flags = (void *)(card->hw.dpmbase +
 398                         (((CHDLC_CONFIGURATION_STRUCT *)mb1->data)->
 399                         ptr_shared_mem_info_struct));
 400         }else{
 401                 card->u.c.flags = (void *)(card->hw.dpmbase +
 402                         (((CHDLC_CONFIGURATION_STRUCT *)mb1->data)->
 403                         ptr_shared_mem_info_struct % SDLA_WINDOWSIZE));
 404         }
 405
 406         flags = card->u.c.flags;
 407
 408         /* This is for the ports link state */
 409         card->wandev.state = WAN_DUALPORT;
 410         card->u.c.state = WAN_DISCONNECTED;
 411
 412
 413         if (!card->wandev.piggyback){
 414                 err = intr_test(card);
 415
 416                 if(err || (Intr_test_counter < MAX_INTR_TEST_COUNTER)) {
 417                         printk(KERN_ERR "%s: Interrupt test failed (%i)\n",
 418                                         card->devname, Intr_test_counter);
 419                         printk(KERN_ERR "%s: Please choose another interrupt\n",
 420                                         card->devname);
 421                         return  -EIO;
 422                 }
 423
 424                 printk(KERN_INFO "%s: Interrupt test passed (%i)\n",
 425                                 card->devname, Intr_test_counter);
 426         }
 427
 428
 429         if (chdlc_set_intr_mode(card, APP_INT_ON_TIMER)){
 430                 printk (KERN_INFO "%s: Failed to set interrupt triggers!\n",
 431                                 card->devname);
 432                 return -EIO;
 433         }
 434
 435         /* Mask the Timer interrupt */
 436         flags->interrupt_info_struct.interrupt_permission &=
 437                 ~APP_INT_ON_TIMER;
 438
 439         printk(KERN_INFO "\n");
 440
 441         return 0;
 442 }
 443
 444 /******* WAN Device Driver Entry Points *************************************/
 445
 446 /*============================================================================
 447  * Update device status & statistics
 448  * This procedure is called when updating the PROC file system and returns
 449  * various communications statistics. These statistics are accumulated from 3
 450  * different locations:
 451  *      1) The 'if_stats' recorded for the device.
 452  *      2) Communication error statistics on the adapter.
 453  *      3) CHDLC operational statistics on the adapter.
 454  * The board level statistics are read during a timer interrupt. Note that we
 455  * read the error and operational statistics during consecitive timer ticks so
 456  * as to minimize the time that we are inside the interrupt handler.
 457  *
 458  */
 459 static int update(struct wan_device* wandev)
 460 {
 461         sdla_t* card = wandev->private;
 462         struct net_device* dev;
 463         volatile chdlc_private_area_t* chdlc_priv_area;
 464         SHARED_MEMORY_INFO_STRUCT *flags;
 465         unsigned long timeout;
 466
 467         /* sanity checks */
 468         if((wandev == NULL) || (wandev->private == NULL))
 469                 return -EFAULT;
 470
 471         if(wandev->state == WAN_UNCONFIGURED)
 472                 return -ENODEV;
 473
 474         /* more sanity checks */
 475         if(!card->u.c.flags)
 476                 return -ENODEV;
 477
 478         if((dev=card->wandev.dev) == NULL)
 479                 return -ENODEV;
 480
 481         if((chdlc_priv_area=dev->priv) == NULL)
 482                 return -ENODEV;
 483
 484         flags = card->u.c.flags;
 485
 486         if(chdlc_priv_area->update_comms_stats){
 487                 return -EAGAIN;
 488         }
 489
 490         /* we will need 2 timer interrupts to complete the */
 491         /* reading of the statistics */
 492         chdlc_priv_area->update_comms_stats = 2;
 493         flags->interrupt_info_struct.interrupt_permission |= APP_INT_ON_TIMER;
 494         chdlc_priv_area->timer_int_enabled = TMR_INT_ENABLED_UPDATE;
 495
 496         /* wait a maximum of 1 second for the statistics to be updated */
 497         timeout = jiffies + 1 * HZ;
 498         for(;;) {
 499                 if(chdlc_priv_area->update_comms_stats == 0)
 500                         break;
 501                 if (time_after(jiffies, timeout)){
 502                         chdlc_priv_area->update_comms_stats = 0;
 503                         chdlc_priv_area->timer_int_enabled &=
 504                                 ~TMR_INT_ENABLED_UPDATE;
 505                         return -EAGAIN;
 506                 }
 507         }
 508
 509         return 0;
 510 }
 511
 512
 513 /*============================================================================
 514  * Create new logical channel.
 515  * This routine is called by the router when ROUTER_IFNEW IOCTL is being
 516  * handled.
 517  * o parse media- and hardware-specific configuration
 518  * o make sure that a new channel can be created
 519  * o allocate resources, if necessary
 520  * o prepare network device structure for registaration.
 521  *
 522  * Return:      0       o.k.
 523  *              < 0     failure (channel will not be created)
 524  */
 525 static int new_if(struct wan_device* wandev, struct net_device* pdev,
 526                   wanif_conf_t* conf)
 527 {
 528
 529         struct ppp_device *pppdev = (struct ppp_device *)pdev;
 530         struct net_device *dev = NULL;
 531         struct sppp *sp;
 532         sdla_t* card = wandev->private;
 533         chdlc_private_area_t* chdlc_priv_area;
 534
 535         if ((conf->name[0] == '\0') || (strlen(conf->name) > WAN_IFNAME_SZ)) {
 536                 printk(KERN_INFO "%s: invalid interface name!\n",
 537                         card->devname);
 538                 return -EINVAL;
 539         }
 540
 541         /* allocate and initialize private data */
 542         chdlc_priv_area = kmalloc(sizeof(chdlc_private_area_t), GFP_KERNEL);
 543
 544         if(chdlc_priv_area == NULL)
 545                 return -ENOMEM;
 546
 547         memset(chdlc_priv_area, 0, sizeof(chdlc_private_area_t));
 548
 549         chdlc_priv_area->card = card;
 550
 551         /* initialize data */
 552         strcpy(card->u.c.if_name, conf->name);
 553
 554         if(card->wandev.new_if_cnt > 0) {
 555                 kfree(chdlc_priv_area);
 556                 return -EEXIST;
 557         }
 558
 559         card->wandev.new_if_cnt++;
 560
 561         chdlc_priv_area->TracingEnabled = 0;
 562
 563         //We don't need this any more
 564         chdlc_priv_area->route_status = NO_ROUTE;
 565         chdlc_priv_area->route_removed = 0;
 566
 567         printk(KERN_INFO "%s: Firmware running in HDLC STREAMING Mode\n",
 568                 wandev->name);
 569
 570         /* Setup wanpipe as a router (WANPIPE) or as an API */
 571         if( strcmp(conf->usedby, "WANPIPE") == 0) {
 572                 printk(KERN_INFO "%s: Driver running in WANPIPE mode!\n",
 573                         wandev->name);
 574                 card->u.c.usedby = WANPIPE;
 575         } else {
 576                 printk(KERN_INFO
 577                         "%s: API Mode is not supported for SyncPPP!\n",
 578                         wandev->name);
 579                 kfree(chdlc_priv_area);
 580                 return -EINVAL;
 581         }
 582
 583         /* Get Multicast Information */
 584         chdlc_priv_area->mc = conf->mc;
 585
 586
 587         chdlc_priv_area->if_ptr = pppdev;
 588
 589         /* prepare network device data space for registration */
 590
 591         strcpy(dev->name,card->u.c.if_name);
 592
 593         /* Attach PPP protocol layer to pppdev
 594          * The sppp_attach() will initilize the dev structure
 595          * and setup ppp layer protocols.
 596          * All we have to do is to bind in:
 597          *        if_open(), if_close(), if_send() and get_stats() functions.
 598          */
 599         sppp_attach(pppdev);
 600         dev = pppdev->dev;
 601         sp = &pppdev->sppp;
 602
 603         /* Enable PPP Debugging */
 604         // FIXME Fix this up somehow
 605         //sp->pp_flags |= PP_DEBUG;
 606         sp->pp_flags &= ~PP_CISCO;
 607
 608         dev->init = &if_init;
 609         dev->priv = chdlc_priv_area;
 610
 611         return 0;
 612 }
 613
 614
 615
 616
 617 /*============================================================================
 618  * Delete logical channel.
 619  */
 620 static int del_if(struct wan_device* wandev, struct net_device* dev)
 621 {
 622         chdlc_private_area_t *chdlc_priv_area = dev->priv;
 623         sdla_t *card = chdlc_priv_area->card;
 624         unsigned long smp_lock;
 625
 626         /* Detach the PPP layer */
 627         printk(KERN_INFO "%s: Detaching SyncPPP Module from %s\n",
 628                         wandev->name,dev->name);
 629
 630         lock_adapter_irq(&wandev->lock,&smp_lock);
 631
 632         sppp_detach(dev);
 633         chdlc_priv_area->if_ptr=NULL;
 634
 635         chdlc_set_intr_mode(card, 0);
 636         if (card->u.c.comm_enabled)
 637                 chdlc_comm_disable(card);
 638         unlock_adapter_irq(&wandev->lock,&smp_lock);
 639
 640         port_set_state(card, WAN_DISCONNECTED);
 641
 642         return 0;
 643 }
 644
 645
 646 /****** Network Device Interface ********************************************/
 647
 648 /*============================================================================
 649  * Initialize Linux network interface.
 650  *
 651  * This routine is called only once for each interface, during Linux network
 652  * interface registration.  Returning anything but zero will fail interface
 653  * registration.
 654  */
 655 static int if_init(struct net_device* dev)
 656 {
 657         chdlc_private_area_t* chdlc_priv_area = dev->priv;
 658         sdla_t* card = chdlc_priv_area->card;
 659         struct wan_device* wandev = &card->wandev;
 660
 661         /* NOTE: Most of the dev initialization was
 662          *       done in sppp_attach(), called by new_if()
 663          *       function. All we have to do here is
 664          *       to link four major routines below.
 665          */
 666
 667         /* Initialize device driver entry points */
 668         dev->open               = &if_open;
 669         dev->stop               = &if_close;
 670         dev->hard_start_xmit    = &if_send;
 671         dev->get_stats          = &if_stats;
 672         dev->tx_timeout         = &if_tx_timeout;
 673         dev->watchdog_timeo     = TX_TIMEOUT;
 674
 675
 676         /* Initialize hardware parameters */
 677         dev->irq        = wandev->irq;
 678         dev->dma        = wandev->dma;
 679         dev->base_addr  = wandev->ioport;
 680         dev->mem_start  = wandev->maddr;
 681         dev->mem_end    = wandev->maddr + wandev->msize - 1;
 682
 683         /* Set transmit buffer queue length
 684          * If we over fill this queue the packets will
 685          * be droped by the kernel.
 686          * sppp_attach() sets this to 10, but
 687          * 100 will give us more room at low speeds.
 688          */
 689         dev->tx_queue_len = 100;
 690
 691         return 0;
 692 }
 693
 694
 695 /*============================================================================
 696  * Handle transmit timeout event from netif watchdog
 697  */
 698 static void if_tx_timeout(struct net_device *dev)
 699 {
 700         chdlc_private_area_t* chan = dev->priv;
 701         sdla_t *card = chan->card;
 702
 703         /* If our device stays busy for at least 5 seconds then we will
 704          * kick start the device by making dev->tbusy = 0.  We expect
 705          * that our device never stays busy more than 5 seconds. So this
 706          * is only used as a last resort.
 707          */
 708
 709         ++card->wandev.stats.collisions;
 710
 711         printk (KERN_INFO "%s: Transmit timed out on %s\n", card->devname,dev->name);
 712         netif_wake_queue (dev);
 713 }
 714
 715
 716 /*============================================================================
 717  * Open network interface.
 718  * o enable communications and interrupts.
 719  * o prevent module from unloading by incrementing use count
 720  *
 721  * Return 0 if O.k. or errno.
 722  */
 723 static int if_open(struct net_device* dev)
 724 {
 725         chdlc_private_area_t* chdlc_priv_area = dev->priv;
 726         sdla_t* card = chdlc_priv_area->card;
 727         struct timeval tv;
 728         SHARED_MEMORY_INFO_STRUCT *flags = card->u.c.flags;
 729
 730         /* Only one open per interface is allowed */
 731         if (netif_running(dev))
 732                 return -EBUSY;
 733
 734         /* Start PPP Layer */
 735         if (sppp_open(dev)){
 736                 return -EIO;
 737         }
 738
 739         do_gettimeofday(&tv);
 740         chdlc_priv_area->router_start_time = tv.tv_sec;
 741
 742         netif_start_queue(dev);
 743
 744         wanpipe_open(card);
 745
 746         chdlc_priv_area->timer_int_enabled |= TMR_INT_ENABLED_CONFIG;
 747         flags->interrupt_info_struct.interrupt_permission |= APP_INT_ON_TIMER;
 748         return 0;
 749 }
 750
 751 /*============================================================================
 752  * Close network interface.
 753  * o if this is the last close, then disable communications and interrupts.
 754  * o reset flags.
 755  */
 756 static int if_close(struct net_device* dev)
 757 {
 758         chdlc_private_area_t* chdlc_priv_area = dev->priv;
 759         sdla_t* card = chdlc_priv_area->card;
 760
 761         /* Stop the PPP Layer */
 762         sppp_close(dev);
 763         netif_stop_queue(dev);
 764
 765         wanpipe_close(card);
 766
 767         return 0;
 768 }
 769
 770 /*============================================================================
 771  * Send a packet on a network interface.
 772  * o set tbusy flag (marks start of the transmission) to block a timer-based
 773  *   transmit from overlapping.
 774  * o check link state. If link is not up, then drop the packet.
 775  * o execute adapter send command.
 776  * o free socket buffer
 777  *
 778  * Return:      0       complete (socket buffer must be freed)
 779  *              non-0   packet may be re-transmitted (tbusy must be set)
 780  *
 781  * Notes:
 782  * 1. This routine is called either by the protocol stack or by the "net
 783  *    bottom half" (with interrupts enabled).
 784  * 2. Setting tbusy flag will inhibit further transmit requests from the
 785  *    protocol stack and can be used for flow control with protocol layer.
 786  */
 787 static int if_send(struct sk_buff* skb, struct net_device* dev)
 788 {
 789         chdlc_private_area_t *chdlc_priv_area = dev->priv;
 790         sdla_t *card = chdlc_priv_area->card;
 791         SHARED_MEMORY_INFO_STRUCT *flags = card->u.c.flags;
 792         INTERRUPT_INFORMATION_STRUCT *chdlc_int = &flags->interrupt_info_struct;
 793         int udp_type = 0;
 794         unsigned long smp_flags;
 795         int err=0;
 796
 797         netif_stop_queue(dev);
 798
 799
 800         if (skb == NULL){
 801                 /* If we get here, some higher layer thinks we've missed an
 802                  * tx-done interrupt.
 803                  */
 804                 printk(KERN_INFO "%s: Received NULL skb buffer! interface %s got kicked!\n",
 805                         card->devname, dev->name);
 806
 807                 netif_wake_queue(dev);
 808                 return 0;
 809         }
 810
 811         if (ntohs(skb->protocol) != htons(PVC_PROT)){
 812                 /* check the udp packet type */
 813
 814                 udp_type = udp_pkt_type(skb, card);
 815                 if (udp_type == UDP_CPIPE_TYPE){
 816                         if(store_udp_mgmt_pkt(UDP_PKT_FRM_STACK, card, skb, dev,
 817                                 chdlc_priv_area)){
 818                                 chdlc_int->interrupt_permission |=
 819                                         APP_INT_ON_TIMER;
 820                         }
 821                         netif_start_queue(dev);
 822                         return 0;
 823                 }
 824         }
 825
 826         /* Lock the 508 Card: SMP is supported */
 827         if(card->hw.type != SDLA_S514){
 828                 s508_lock(card,&smp_flags);
 829         }
 830
 831         if (test_and_set_bit(SEND_CRIT, (void*)&card->wandev.critical)){
 832
 833                 printk(KERN_INFO "%s: Critical in if_send: %lx\n",
 834                                         card->wandev.name,card->wandev.critical);
 835                 ++card->wandev.stats.tx_dropped;
 836                 netif_start_queue(dev);
 837                 goto if_send_crit_exit;
 838         }
 839
 840         if (card->wandev.state != WAN_CONNECTED){
 841                 ++card->wandev.stats.tx_dropped;
 842                 netif_start_queue(dev);
 843                 goto if_send_crit_exit;
 844         }
 845
 846         if (chdlc_send(card, skb->data, skb->len)){
 847                 netif_stop_queue(dev);
 848
 849         }else{
 850                 ++card->wandev.stats.tx_packets;
 851                 card->wandev.stats.tx_bytes += skb->len;
 852                 dev->trans_start = jiffies;
 853                 netif_start_queue(dev);
 854         }
 855
 856 if_send_crit_exit:
 857         if (!(err=netif_queue_stopped(dev))){
 858                 dev_kfree_skb_any(skb);
 859         }else{
 860                 chdlc_priv_area->tick_counter = jiffies;
 861                 chdlc_int->interrupt_permission |= APP_INT_ON_TX_FRAME;
 862         }
 863
 864         clear_bit(SEND_CRIT, (void*)&card->wandev.critical);
 865         if(card->hw.type != SDLA_S514){
 866                 s508_unlock(card,&smp_flags);
 867         }
 868
 869         return err;
 870 }
 871
 872
 873 /*============================================================================
 874  * Reply to UDP Management system.
 875  * Return length of reply.
 876  */
 877 static int reply_udp( unsigned char *data, unsigned int mbox_len )
 878 {
 879
 880         unsigned short len, udp_length, temp, ip_length;
 881         unsigned long ip_temp;
 882         int even_bound = 0;
 883         chdlc_udp_pkt_t *c_udp_pkt = (chdlc_udp_pkt_t *)data;
 884
 885         /* Set length of packet */
 886         len = sizeof(ip_pkt_t)+
 887               sizeof(udp_pkt_t)+
 888               sizeof(wp_mgmt_t)+
 889               sizeof(cblock_t)+
 890               sizeof(trace_info_t)+
 891               mbox_len;
 892
 893         /* fill in UDP reply */
 894         c_udp_pkt->wp_mgmt.request_reply = UDPMGMT_REPLY;
 895
 896         /* fill in UDP length */
 897         udp_length = sizeof(udp_pkt_t)+
 898                      sizeof(wp_mgmt_t)+
 899                      sizeof(cblock_t)+
 900                      sizeof(trace_info_t)+
 901                      mbox_len;
 902
 903         /* put it on an even boundary */
 904         if ( udp_length & 0x0001 ) {
 905                 udp_length += 1;
 906                 len += 1;
 907                 even_bound = 1;
 908         }
 909
 910         temp = (udp_length<<8)|(udp_length>>8);
 911         c_udp_pkt->udp_pkt.udp_length = temp;
 912
 913         /* swap UDP ports */
 914         temp = c_udp_pkt->udp_pkt.udp_src_port;
 915         c_udp_pkt->udp_pkt.udp_src_port =
 916                         c_udp_pkt->udp_pkt.udp_dst_port;
 917         c_udp_pkt->udp_pkt.udp_dst_port = temp;
 918
 919         /* add UDP pseudo header */
 920         temp = 0x1100;
 921         *((unsigned short *)(c_udp_pkt->data+mbox_len+even_bound)) = temp;
 922         temp = (udp_length<<8)|(udp_length>>8);
 923         *((unsigned short *)(c_udp_pkt->data+mbox_len+even_bound+2)) = temp;
 924
 925
 926         /* calculate UDP checksum */
 927         c_udp_pkt->udp_pkt.udp_checksum = 0;
 928         c_udp_pkt->udp_pkt.udp_checksum = calc_checksum(&data[UDP_OFFSET],udp_length+UDP_OFFSET);
 929
 930         /* fill in IP length */
 931         ip_length = len;
 932         temp = (ip_length<<8)|(ip_length>>8);
 933         c_udp_pkt->ip_pkt.total_length = temp;
 934
 935         /* swap IP addresses */
 936         ip_temp = c_udp_pkt->ip_pkt.ip_src_address;
 937         c_udp_pkt->ip_pkt.ip_src_address = c_udp_pkt->ip_pkt.ip_dst_address;
 938         c_udp_pkt->ip_pkt.ip_dst_address = ip_temp;
 939
 940         /* fill in IP checksum */
 941         c_udp_pkt->ip_pkt.hdr_checksum = 0;
 942         c_udp_pkt->ip_pkt.hdr_checksum = calc_checksum(data,sizeof(ip_pkt_t));
 943
 944         return len;
 945
 946 } /* reply_udp */
 947
 948 unsigned short calc_checksum (char *data, int len)
 949 {
 950         unsigned short temp;
 951         unsigned long sum=0;
 952         int i;
 953
 954         for( i = 0; i <len; i+=2 ) {
 955                 memcpy(&temp,&data[i],2);
 956                 sum += (unsigned long)temp;
 957         }
 958
 959         while (sum >> 16 ) {
 960                 sum = (sum & 0xffffUL) + (sum >> 16);
 961         }
 962
 963         temp = (unsigned short)sum;
 964         temp = ~temp;
 965
 966         if( temp == 0 )
 967                 temp = 0xffff;
 968
 969         return temp;
 970 }
 971
 972
 973 /*============================================================================
 974  * Get ethernet-style interface statistics.
 975  * Return a pointer to struct enet_statistics.
 976  */
 977 static struct net_device_stats* if_stats(struct net_device* dev)
 978 {
 979         sdla_t *my_card;
 980         chdlc_private_area_t* chdlc_priv_area;
 981
 982         /* Shutdown bug fix. In del_if() we kill
 983          * dev->priv pointer. This function, gets
 984          * called after del_if(), thus check
 985          * if pointer has been deleted */
 986         if ((chdlc_priv_area=dev->priv) == NULL)
 987                 return NULL;
 988
 989         my_card = chdlc_priv_area->card;
 990         return &my_card->wandev.stats;
 991 }
 992
 993
 994 /****** Cisco HDLC Firmware Interface Functions *******************************/
 995
 996 /*============================================================================
 997  * Read firmware code version.
 998  *      Put code version as ASCII string in str.
 999  */
1000 static int chdlc_read_version (sdla_t* card, char* str)
1001 {
1002         CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1003         int len;
1004         char err;
1005         mb->buffer_length = 0;
1006         mb->command = READ_CHDLC_CODE_VERSION;
1007         err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1008
1009         if(err != COMMAND_OK) {
1010                 chdlc_error(card,err,mb);
1011         }
1012         else if (str) {  /* is not null */
1013                 len = mb->buffer_length;
1014                 memcpy(str, mb->data, len);
1015                 str[len] = '\0';
1016         }
1017         return (err);
1018 }
1019
1020 /*-----------------------------------------------------------------------------
1021  *  Configure CHDLC firmware.
1022  */
1023 static int chdlc_configure (sdla_t* card, void* data)
1024 {
1025         int err;
1026         CHDLC_MAILBOX_STRUCT *mailbox = card->mbox;
1027         int data_length = sizeof(CHDLC_CONFIGURATION_STRUCT);
1028
1029         mailbox->buffer_length = data_length;
1030         memcpy(mailbox->data, data, data_length);
1031         mailbox->command = SET_CHDLC_CONFIGURATION;
1032         err = sdla_exec(mailbox) ? mailbox->return_code : CMD_TIMEOUT;
1033
1034         if (err != COMMAND_OK) chdlc_error (card, err, mailbox);
1035
1036         return err;
1037 }
1038
1039
1040 /*============================================================================
1041  * Set interrupt mode -- HDLC Version.
1042  */
1043
1044 static int chdlc_set_intr_mode (sdla_t* card, unsigned mode)
1045 {
1046         CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1047         CHDLC_INT_TRIGGERS_STRUCT* int_data =
1048                  (CHDLC_INT_TRIGGERS_STRUCT *)mb->data;
1049         int err;
1050
1051         int_data->CHDLC_interrupt_triggers      = mode;
1052         int_data->IRQ                           = card->hw.irq;
1053         int_data->interrupt_timer               = 1;
1054
1055         mb->buffer_length = sizeof(CHDLC_INT_TRIGGERS_STRUCT);
1056         mb->command = SET_CHDLC_INTERRUPT_TRIGGERS;
1057         err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1058         if (err != COMMAND_OK)
1059                 chdlc_error (card, err, mb);
1060         return err;
1061 }
1062
1063
1064 /*============================================================================
1065  * Enable communications.
1066  */
1067
1068 static int chdlc_comm_enable (sdla_t* card)
1069 {
1070         int err;
1071         CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1072
1073         mb->buffer_length = 0;
1074         mb->command = ENABLE_CHDLC_COMMUNICATIONS;
1075         err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1076         if (err != COMMAND_OK)
1077                 chdlc_error(card, err, mb);
1078         else
1079                 card->u.c.comm_enabled=1;
1080
1081         return err;
1082 }
1083
1084 /*============================================================================
1085  * Disable communications and Drop the Modem lines (DCD and RTS).
1086  */
1087 static int chdlc_comm_disable (sdla_t* card)
1088 {
1089         int err;
1090         CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1091
1092         mb->buffer_length = 0;
1093         mb->command = DISABLE_CHDLC_COMMUNICATIONS;
1094         err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1095         if (err != COMMAND_OK)
1096                 chdlc_error(card,err,mb);
1097
1098         return err;
1099 }
1100
1101 /*============================================================================
1102  * Read communication error statistics.
1103  */
1104 static int chdlc_read_comm_err_stats (sdla_t* card)
1105 {
1106         int err;
1107         CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1108
1109         mb->buffer_length = 0;
1110         mb->command = READ_COMMS_ERROR_STATS;
1111         err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1112         if (err != COMMAND_OK)
1113                 chdlc_error(card,err,mb);
1114         return err;
1115 }
1116
1117
1118 /*============================================================================
1119  * Read CHDLC operational statistics.
1120  */
1121 static int chdlc_read_op_stats (sdla_t* card)
1122 {
1123         int err;
1124         CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1125
1126         mb->buffer_length = 0;
1127         mb->command = READ_CHDLC_OPERATIONAL_STATS;
1128         err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1129         if (err != COMMAND_OK)
1130                 chdlc_error(card,err,mb);
1131         return err;
1132 }
1133
1134
1135 /*============================================================================
1136  * Update communications error and general packet statistics.
1137  */
1138 static int update_comms_stats(sdla_t* card,
1139         chdlc_private_area_t* chdlc_priv_area)
1140 {
1141         CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1142         COMMS_ERROR_STATS_STRUCT* err_stats;
1143         CHDLC_OPERATIONAL_STATS_STRUCT *op_stats;
1144
1145         /* on the first timer interrupt, read the comms error statistics */
1146         if(chdlc_priv_area->update_comms_stats == 2) {
1147                 if(chdlc_read_comm_err_stats(card))
1148                         return 1;
1149                 err_stats = (COMMS_ERROR_STATS_STRUCT *)mb->data;
1150                 card->wandev.stats.rx_over_errors =
1151                                 err_stats->Rx_overrun_err_count;
1152                 card->wandev.stats.rx_crc_errors =
1153                                 err_stats->CRC_err_count;
1154                 card->wandev.stats.rx_frame_errors =
1155                                 err_stats->Rx_abort_count;
1156                 card->wandev.stats.rx_fifo_errors =
1157                                 err_stats->Rx_dis_pri_bfrs_full_count;
1158                 card->wandev.stats.rx_missed_errors =
1159                                 card->wandev.stats.rx_fifo_errors;
1160                 card->wandev.stats.tx_aborted_errors =
1161                                 err_stats->sec_Tx_abort_count;
1162         }
1163
1164         /* on the second timer interrupt, read the operational statistics */
1165         else {
1166                 if(chdlc_read_op_stats(card))
1167                         return 1;
1168                 op_stats = (CHDLC_OPERATIONAL_STATS_STRUCT *)mb->data;
1169                 card->wandev.stats.rx_length_errors =
1170                         (op_stats->Rx_Data_discard_short_count +
1171                         op_stats->Rx_Data_discard_long_count);
1172         }
1173
1174         return 0;
1175 }
1176
1177 /*============================================================================
1178  * Send packet.
1179  *      Return: 0 - o.k.
1180  *              1 - no transmit buffers available
1181  */
1182 static int chdlc_send (sdla_t* card, void* data, unsigned len)
1183 {
1184         CHDLC_DATA_TX_STATUS_EL_STRUCT *txbuf = card->u.c.txbuf;
1185
1186         if (txbuf->opp_flag)
1187                 return 1;
1188
1189         sdla_poke(&card->hw, txbuf->ptr_data_bfr, data, len);
1190
1191         txbuf->frame_length = len;
1192         txbuf->opp_flag = 1;            /* start transmission */
1193
1194         /* Update transmit buffer control fields */
1195         card->u.c.txbuf = ++txbuf;
1196
1197         if ((void*)txbuf > card->u.c.txbuf_last)
1198                 card->u.c.txbuf = card->u.c.txbuf_base;
1199
1200         return 0;
1201 }
1202
1203 /****** Firmware Error Handler **********************************************/
1204
1205 /*============================================================================
1206  * Firmware error handler.
1207  *      This routine is called whenever firmware command returns non-zero
1208  *      return code.
1209  *
1210  * Return zero if previous command has to be cancelled.
1211  */
1212 static int chdlc_error (sdla_t *card, int err, CHDLC_MAILBOX_STRUCT *mb)
1213 {
1214         unsigned cmd = mb->command;
1215
1216         switch (err) {
1217
1218         case CMD_TIMEOUT:
1219                 printk(KERN_ERR "%s: command 0x%02X timed out!\n",
1220                         card->devname, cmd);
1221                 break;
1222
1223         case S514_BOTH_PORTS_SAME_CLK_MODE:
1224                 if(cmd == SET_CHDLC_CONFIGURATION) {
1225                         printk(KERN_INFO
1226                          "%s: Configure both ports for the same clock source\n",
1227                                 card->devname);
1228                         break;
1229                 }
1230
1231         default:
1232                 printk(KERN_INFO "%s: command 0x%02X returned 0x%02X!\n",
1233                         card->devname, cmd, err);
1234         }
1235
1236         return 0;
1237 }
1238
1239 /****** Interrupt Handlers **************************************************/
1240
1241 /*============================================================================
1242  * Cisco HDLC interrupt service routine.
1243  */
1244 STATIC void wsppp_isr (sdla_t* card)
1245 {
1246         struct net_device* dev;
1247         SHARED_MEMORY_INFO_STRUCT* flags = NULL;
1248         int i;
1249         sdla_t *my_card;
1250
1251
1252         /* Check for which port the interrupt has been generated
1253          * Since Secondary Port is piggybacking on the Primary
1254          * the check must be done here.
1255          */
1256
1257         flags = card->u.c.flags;
1258         if (!flags->interrupt_info_struct.interrupt_type){
1259                 /* Check for a second port (piggybacking) */
1260                 if((my_card = card->next)){
1261                         flags = my_card->u.c.flags;
1262                         if (flags->interrupt_info_struct.interrupt_type){
1263                                 card = my_card;
1264                                 card->isr(card);
1265                                 return;
1266                         }
1267                 }
1268         }
1269
1270         dev = card->wandev.dev;
1271         card->in_isr = 1;
1272         flags = card->u.c.flags;
1273
1274         /* If we get an interrupt with no network device, stop the interrupts
1275          * and issue an error */
1276         if ((!dev || !dev->priv) && flags->interrupt_info_struct.interrupt_type !=
1277                 COMMAND_COMPLETE_APP_INT_PEND){
1278                 goto isr_done;
1279         }
1280
1281
1282         /* if critical due to peripheral operations
1283          * ie. update() or getstats() then reset the interrupt and
1284          * wait for the board to retrigger.
1285          */
1286         if(test_bit(PERI_CRIT, (void*)&card->wandev.critical)) {
1287                 flags->interrupt_info_struct.
1288                                         interrupt_type = 0;
1289                 goto isr_done;
1290         }
1291
1292
1293         /* On a 508 Card, if critical due to if_send
1294          * Major Error !!!
1295          */
1296         if(card->hw.type != SDLA_S514) {
1297                 if(test_bit(0, (void*)&card->wandev.critical)) {
1298                         printk(KERN_INFO "%s: Critical while in ISR: %lx\n",
1299                                 card->devname, card->wandev.critical);
1300                         goto isr_done;
1301                 }
1302         }
1303
1304         switch(flags->interrupt_info_struct.interrupt_type) {
1305
1306                 case RX_APP_INT_PEND:   /* 0x01: receive interrupt */
1307                         rx_intr(card);
1308                         break;
1309
1310                 case TX_APP_INT_PEND:   /* 0x02: transmit interrupt */
1311                         flags->interrupt_info_struct.interrupt_permission &=
1312                                  ~APP_INT_ON_TX_FRAME;
1313
1314                         netif_wake_queue(dev);
1315                         break;
1316
1317                 case COMMAND_COMPLETE_APP_INT_PEND:/* 0x04: cmd cplt */
1318                         ++ Intr_test_counter;
1319                         break;
1320
1321                 case CHDLC_EXCEP_COND_APP_INT_PEND:     /* 0x20 */
1322                         process_chdlc_exception(card);
1323                         break;
1324
1325                 case GLOBAL_EXCEP_COND_APP_INT_PEND:
1326                         process_global_exception(card);
1327                         break;
1328
1329                 case TIMER_APP_INT_PEND:
1330                         timer_intr(card);
1331                         break;
1332
1333                 default:
1334                         printk(KERN_INFO "%s: spurious interrupt 0x%02X!\n",
1335                                 card->devname,
1336                                 flags->interrupt_info_struct.interrupt_type);
1337                         printk(KERN_INFO "Code name: ");
1338                         for(i = 0; i < 4; i ++)
1339                                 printk(KERN_INFO "%c",
1340                                         flags->global_info_struct.codename[i]);
1341                         printk(KERN_INFO "\nCode version: ");
1342                         for(i = 0; i < 4; i ++)
1343                                 printk(KERN_INFO "%c",
1344                                         flags->global_info_struct.codeversion[i]);
1345                         printk(KERN_INFO "\n");
1346                         break;
1347         }
1348
1349 isr_done:
1350         card->in_isr = 0;
1351         flags->interrupt_info_struct.interrupt_type = 0;
1352 }
1353
1354 /*============================================================================
1355  * Receive interrupt handler.
1356  */
1357 static void rx_intr (sdla_t* card)
1358 {
1359         struct net_device *dev;
1360         chdlc_private_area_t *chdlc_priv_area;
1361         SHARED_MEMORY_INFO_STRUCT *flags = card->u.c.flags;
1362         CHDLC_DATA_RX_STATUS_EL_STRUCT *rxbuf = card->u.c.rxmb;
1363         struct sk_buff *skb;
1364         unsigned len;
1365         unsigned addr = rxbuf->ptr_data_bfr;
1366         void *buf;
1367         int i,udp_type;
1368
1369         if (rxbuf->opp_flag != 0x01) {
1370                 printk(KERN_INFO
1371                         "%s: corrupted Rx buffer @ 0x%X, flag = 0x%02X!\n",
1372                         card->devname, (unsigned)rxbuf, rxbuf->opp_flag);
1373                 printk(KERN_INFO "Code name: ");
1374                 for(i = 0; i < 4; i ++)
1375                         printk(KERN_INFO "%c",
1376                                 flags->global_info_struct.codename[i]);
1377                 printk(KERN_INFO "\nCode version: ");
1378                 for(i = 0; i < 4; i ++)
1379                         printk(KERN_INFO "%c",
1380                                 flags->global_info_struct.codeversion[i]);
1381                 printk(KERN_INFO "\n");
1382
1383
1384                 /* Bug Fix: Mar 6 2000
1385                  * If we get a corrupted mailbox, it measn that driver
1386                  * is out of sync with the firmware. There is no recovery.
1387                  * If we don't turn off all interrupts for this card
1388                  * the machine will crash.
1389                  */
1390                 printk(KERN_INFO "%s: Critical router failure ...!!!\n", card->devname);
1391                 printk(KERN_INFO "Please contact Sangoma Technologies !\n");
1392                 chdlc_set_intr_mode(card,0);
1393                 return;
1394         }
1395
1396         dev = card->wandev.dev;
1397
1398         if (!dev){
1399                 goto rx_exit;
1400         }
1401
1402         if (!netif_running(dev)){
1403                 goto rx_exit;
1404         }
1405
1406         chdlc_priv_area = dev->priv;
1407
1408         if (rxbuf->error_flag){
1409                 goto rx_exit;
1410         }
1411         /* Take off two CRC bytes */
1412
1413         if (rxbuf->frame_length < 7 || rxbuf->frame_length > 1506 ){
1414                 goto rx_exit;
1415         }
1416
1417         len = rxbuf->frame_length - CRC_LENGTH;
1418
1419         /* Allocate socket buffer */
1420         skb = dev_alloc_skb(len);
1421
1422         if (skb == NULL) {
1423                 if (net_ratelimit()){
1424                         printk(KERN_INFO "%s: no socket buffers available!\n",
1425                                                 card->devname);
1426                 }
1427                 ++card->wandev.stats.rx_dropped;
1428                 goto rx_exit;
1429         }
1430
1431         /* Copy data to the socket buffer */
1432         if((addr + len) > card->u.c.rx_top + 1) {
1433                 unsigned tmp = card->u.c.rx_top - addr + 1;
1434                 buf = skb_put(skb, tmp);
1435                 sdla_peek(&card->hw, addr, buf, tmp);
1436                 addr = card->u.c.rx_base;
1437                 len -= tmp;
1438         }
1439
1440         buf = skb_put(skb, len);
1441         sdla_peek(&card->hw, addr, buf, len);
1442
1443         skb->protocol = htons(ETH_P_WAN_PPP);
1444
1445         card->wandev.stats.rx_packets ++;
1446         card->wandev.stats.rx_bytes += skb->len;
1447         udp_type = udp_pkt_type( skb, card );
1448
1449         if(udp_type == UDP_CPIPE_TYPE) {
1450                 if(store_udp_mgmt_pkt(UDP_PKT_FRM_NETWORK,
1451                                       card, skb, dev, chdlc_priv_area)) {
1452                         flags->interrupt_info_struct.
1453                                                 interrupt_permission |=
1454                                                         APP_INT_ON_TIMER;
1455                 }
1456         }else{
1457                 /* Pass it up the protocol stack */
1458                 skb->dev = dev;
1459                 skb->mac.raw  = skb->data;
1460                 netif_rx(skb);
1461                 dev->last_rx = jiffies;
1462         }
1463
1464 rx_exit:
1465         /* Release buffer element and calculate a pointer to the next one */
1466         rxbuf->opp_flag = 0x00;
1467         card->u.c.rxmb = ++ rxbuf;
1468         if((void*)rxbuf > card->u.c.rxbuf_last){
1469                 card->u.c.rxmb = card->u.c.rxbuf_base;
1470         }
1471 }
1472
1473 /*============================================================================
1474  * Timer interrupt handler.
1475  * The timer interrupt is used for two purposes:
1476  *    1) Processing udp calls from 'cpipemon'.
1477  *    2) Reading board-level statistics for updating the proc file system.
1478  */
1479 void timer_intr(sdla_t *card)
1480 {
1481         struct net_device* dev;
1482         chdlc_private_area_t* chdlc_priv_area = NULL;
1483         SHARED_MEMORY_INFO_STRUCT* flags = NULL;
1484
1485         dev = card->wandev.dev;
1486         chdlc_priv_area = dev->priv;
1487
1488         if (chdlc_priv_area->timer_int_enabled & TMR_INT_ENABLED_CONFIG) {
1489                 if (!config_chdlc(card)){
1490                         chdlc_priv_area->timer_int_enabled &= ~TMR_INT_ENABLED_CONFIG;
1491                 }
1492         }
1493
1494         /* process a udp call if pending */
1495         if(chdlc_priv_area->timer_int_enabled & TMR_INT_ENABLED_UDP) {
1496                 process_udp_mgmt_pkt(card, dev,
1497                        chdlc_priv_area);
1498                 chdlc_priv_area->timer_int_enabled &= ~TMR_INT_ENABLED_UDP;
1499         }
1500
1501
1502         /* read the communications statistics if required */
1503         if(chdlc_priv_area->timer_int_enabled & TMR_INT_ENABLED_UPDATE) {
1504                 update_comms_stats(card, chdlc_priv_area);
1505                 if(!(-- chdlc_priv_area->update_comms_stats)) {
1506                         chdlc_priv_area->timer_int_enabled &=
1507                                 ~TMR_INT_ENABLED_UPDATE;
1508                 }
1509         }
1510
1511         /* only disable the timer interrupt if there are no udp or statistic */
1512         /* updates pending */
1513         if(!chdlc_priv_area->timer_int_enabled) {
1514                 flags = card->u.c.flags;
1515                 flags->interrupt_info_struct.interrupt_permission &=
1516                         ~APP_INT_ON_TIMER;
1517         }
1518 }
1519
1520 /*------------------------------------------------------------------------------
1521   Miscellaneous Functions
1522         - set_chdlc_config() used to set configuration options on the board
1523 ------------------------------------------------------------------------------*/
1524
1525 static int set_chdlc_config(sdla_t* card)
1526 {
1527
1528         CHDLC_CONFIGURATION_STRUCT cfg;
1529
1530         memset(&cfg, 0, sizeof(CHDLC_CONFIGURATION_STRUCT));
1531
1532         if(card->wandev.clocking)
1533                 cfg.baud_rate = card->wandev.bps;
1534
1535         cfg.line_config_options = (card->wandev.interface == WANOPT_RS232) ?
1536                 INTERFACE_LEVEL_RS232 : INTERFACE_LEVEL_V35;
1537
1538         cfg.modem_config_options        = 0;
1539         //API OPTIONS
1540         cfg.CHDLC_API_options           = DISCARD_RX_ERROR_FRAMES;
1541         cfg.modem_status_timer          = 100;
1542         cfg.CHDLC_protocol_options      = HDLC_STREAMING_MODE;
1543         cfg.percent_data_buffer_for_Tx  = 50;
1544         cfg.CHDLC_statistics_options    = (CHDLC_TX_DATA_BYTE_COUNT_STAT |
1545                 CHDLC_RX_DATA_BYTE_COUNT_STAT);
1546         cfg.max_CHDLC_data_field_length = card->wandev.mtu;
1547
1548         cfg.transmit_keepalive_timer    = 0;
1549         cfg.receive_keepalive_timer     = 0;
1550         cfg.keepalive_error_tolerance   = 0;
1551         cfg.SLARP_request_timer         = 0;
1552
1553         cfg.IP_address          = 0;
1554         cfg.IP_netmask          = 0;
1555
1556         return chdlc_configure(card, &cfg);
1557 }
1558
1559 /*============================================================================
1560  * Process global exception condition
1561  */
1562 static int process_global_exception(sdla_t *card)
1563 {
1564         CHDLC_MAILBOX_STRUCT* mbox = card->mbox;
1565         int err;
1566
1567         mbox->buffer_length = 0;
1568         mbox->command = READ_GLOBAL_EXCEPTION_CONDITION;
1569         err = sdla_exec(mbox) ? mbox->return_code : CMD_TIMEOUT;
1570
1571         if(err != CMD_TIMEOUT ){
1572
1573                 switch(mbox->return_code) {
1574
1575                 case EXCEP_MODEM_STATUS_CHANGE:
1576
1577                         printk(KERN_INFO "%s: Modem status change\n",
1578                                 card->devname);
1579
1580                         switch(mbox->data[0] & (DCD_HIGH | CTS_HIGH)) {
1581                                 case (DCD_HIGH):
1582                                         printk(KERN_INFO "%s: DCD high, CTS low\n",card->devname);
1583                                         break;
1584                                 case (CTS_HIGH):
1585                                         printk(KERN_INFO "%s: DCD low, CTS high\n",card->devname);
1586                                         break;
1587                                 case ((DCD_HIGH | CTS_HIGH)):
1588                                         printk(KERN_INFO "%s: DCD high, CTS high\n",card->devname);
1589                                         break;
1590                                 default:
1591                                         printk(KERN_INFO "%s: DCD low, CTS low\n",card->devname);
1592                                         break;
1593                         }
1594
1595                         if (!(mbox->data[0] & DCD_HIGH) || !(mbox->data[0] & DCD_HIGH)){
1596                                 //printk(KERN_INFO "Sending TERM Request Manually !\n");
1597                                 send_ppp_term_request(card->wandev.dev);
1598                         }
1599                         break;
1600
1601                 case EXCEP_TRC_DISABLED:
1602                         printk(KERN_INFO "%s: Line trace disabled\n",
1603                                 card->devname);
1604                         break;
1605
1606                 case EXCEP_IRQ_TIMEOUT:
1607                         printk(KERN_INFO "%s: IRQ timeout occurred\n",
1608                                 card->devname);
1609                         break;
1610
1611                 default:
1612                         printk(KERN_INFO "%s: Global exception %x\n",
1613                                 card->devname, mbox->return_code);
1614                         break;
1615                 }
1616         }
1617         return 0;
1618 }
1619
1620
1621 /*============================================================================
1622  * Process chdlc exception condition
1623  */
1624 static int process_chdlc_exception(sdla_t *card)
1625 {
1626         CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1627         int err;
1628
1629         mb->buffer_length = 0;
1630         mb->command = READ_CHDLC_EXCEPTION_CONDITION;
1631         err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1632         if(err != CMD_TIMEOUT) {
1633
1634                 switch (err) {
1635
1636                 case EXCEP_LINK_ACTIVE:
1637                         port_set_state(card, WAN_CONNECTED);
1638                         break;
1639
1640                 case EXCEP_LINK_INACTIVE_MODEM:
1641                         port_set_state(card, WAN_DISCONNECTED);
1642                         break;
1643
1644                 case EXCEP_LOOPBACK_CONDITION:
1645                         printk(KERN_INFO "%s: Loopback Condition Detected.\n",
1646                                                 card->devname);
1647                         break;
1648
1649                 case NO_CHDLC_EXCEP_COND_TO_REPORT:
1650                         printk(KERN_INFO "%s: No exceptions reported.\n",
1651                                                 card->devname);
1652                         break;
1653                 default:
1654                         printk(KERN_INFO "%s: Exception Condition %x!\n",
1655                                         card->devname,err);
1656                         break;
1657                 }
1658
1659         }
1660         return 0;
1661 }
1662
1663
1664 /*=============================================================================
1665  * Store a UDP management packet for later processing.
1666  */
1667
1668 static int store_udp_mgmt_pkt(char udp_pkt_src, sdla_t* card,
1669                               struct sk_buff *skb, struct net_device* dev,
1670                               chdlc_private_area_t* chdlc_priv_area )
1671 {
1672         int udp_pkt_stored = 0;
1673
1674         if(!chdlc_priv_area->udp_pkt_lgth &&
1675           (skb->len <= MAX_LGTH_UDP_MGNT_PKT)) {
1676                 chdlc_priv_area->udp_pkt_lgth = skb->len;
1677                 chdlc_priv_area->udp_pkt_src = udp_pkt_src;
1678                 memcpy(chdlc_priv_area->udp_pkt_data, skb->data, skb->len);
1679                 chdlc_priv_area->timer_int_enabled = TMR_INT_ENABLED_UDP;
1680                 udp_pkt_stored = 1;
1681         }
1682
1683         if(udp_pkt_src == UDP_PKT_FRM_STACK)
1684                 dev_kfree_skb_any(skb);
1685         else
1686                 dev_kfree_skb_any(skb);
1687
1688         return(udp_pkt_stored);
1689 }
1690
1691
1692 /*=============================================================================
1693  * Process UDP management packet.
1694  */
1695
1696 static int process_udp_mgmt_pkt(sdla_t* card, struct net_device* dev,
1697                                 chdlc_private_area_t* chdlc_priv_area )
1698 {
1699         unsigned char *buf;
1700         unsigned int frames, len;
1701         struct sk_buff *new_skb;
1702         unsigned short buffer_length, real_len;
1703         unsigned long data_ptr;
1704         unsigned data_length;
1705         int udp_mgmt_req_valid = 1;
1706         CHDLC_MAILBOX_STRUCT *mb = card->mbox;
1707         SHARED_MEMORY_INFO_STRUCT *flags = card->u.c.flags;
1708         chdlc_udp_pkt_t *chdlc_udp_pkt;
1709         struct timeval tv;
1710         int err;
1711         char ut_char;
1712
1713         chdlc_udp_pkt = (chdlc_udp_pkt_t *) chdlc_priv_area->udp_pkt_data;
1714
1715         if(chdlc_priv_area->udp_pkt_src == UDP_PKT_FRM_NETWORK) {
1716
1717                 switch(chdlc_udp_pkt->cblock.command) {
1718                         case READ_GLOBAL_STATISTICS:
1719                         case READ_MODEM_STATUS:
1720                         case READ_CHDLC_LINK_STATUS:
1721                         case CPIPE_ROUTER_UP_TIME:
1722                         case READ_COMMS_ERROR_STATS:
1723                         case READ_CHDLC_OPERATIONAL_STATS:
1724
1725                         /* These two commands are executed for
1726                          * each request */
1727                         case READ_CHDLC_CONFIGURATION:
1728                         case READ_CHDLC_CODE_VERSION:
1729                                 udp_mgmt_req_valid = 1;
1730                                 break;
1731                         default:
1732                                 udp_mgmt_req_valid = 0;
1733                                 break;
1734                 }
1735         }
1736
1737         if(!udp_mgmt_req_valid) {
1738
1739                 /* set length to 0 */
1740                 chdlc_udp_pkt->cblock.buffer_length = 0;
1741
1742                 /* set return code */
1743                 chdlc_udp_pkt->cblock.return_code = 0xCD;
1744
1745                 if (net_ratelimit()){
1746                         printk(KERN_INFO
1747                         "%s: Warning, Illegal UDP command attempted from network: %x\n",
1748                         card->devname,chdlc_udp_pkt->cblock.command);
1749                 }
1750
1751         } else {
1752                 unsigned long trace_status_cfg_addr = 0;
1753                 TRACE_STATUS_EL_CFG_STRUCT trace_cfg_struct;
1754                 TRACE_STATUS_ELEMENT_STRUCT trace_element_struct;
1755
1756                 switch(chdlc_udp_pkt->cblock.command) {
1757
1758                 case CPIPE_ENABLE_TRACING:
1759                      if (!chdlc_priv_area->TracingEnabled) {
1760
1761                         /* OPERATE_DATALINE_MONITOR */
1762
1763                         mb->buffer_length = sizeof(LINE_TRACE_CONFIG_STRUCT);
1764                         mb->command = SET_TRACE_CONFIGURATION;
1765
1766                         ((LINE_TRACE_CONFIG_STRUCT *)mb->data)->
1767                                 trace_config = TRACE_ACTIVE;
1768                         /* Trace delay mode is not used because it slows
1769                            down transfer and results in a standoff situation
1770                            when there is a lot of data */
1771
1772                         /* Configure the Trace based on user inputs */
1773                         ((LINE_TRACE_CONFIG_STRUCT *)mb->data)->trace_config |=
1774                                         chdlc_udp_pkt->data[0];
1775
1776                         ((LINE_TRACE_CONFIG_STRUCT *)mb->data)->
1777                            trace_deactivation_timer = 4000;
1778
1779
1780                         err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1781                         if (err != COMMAND_OK) {
1782                                 chdlc_error(card,err,mb);
1783                                 card->TracingEnabled = 0;
1784                                 chdlc_udp_pkt->cblock.return_code = err;
1785                                 mb->buffer_length = 0;
1786                                 break;
1787                         }
1788
1789                         /* Get the base address of the trace element list */
1790                         mb->buffer_length = 0;
1791                         mb->command = READ_TRACE_CONFIGURATION;
1792                         err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1793
1794                         if (err != COMMAND_OK) {
1795                                 chdlc_error(card,err,mb);
1796                                 chdlc_priv_area->TracingEnabled = 0;
1797                                 chdlc_udp_pkt->cblock.return_code = err;
1798                                 mb->buffer_length = 0;
1799                                 break;
1800                         }
1801
1802                         trace_status_cfg_addr =((LINE_TRACE_CONFIG_STRUCT *)
1803                                 mb->data) -> ptr_trace_stat_el_cfg_struct;
1804
1805                         sdla_peek(&card->hw, trace_status_cfg_addr,
1806                                  &trace_cfg_struct, sizeof(trace_cfg_struct));
1807
1808                         chdlc_priv_area->start_trace_addr = trace_cfg_struct.
1809                                 base_addr_trace_status_elements;
1810
1811                         chdlc_priv_area->number_trace_elements =
1812                                         trace_cfg_struct.number_trace_status_elements;
1813
1814                         chdlc_priv_area->end_trace_addr = (unsigned long)
1815                                         ((TRACE_STATUS_ELEMENT_STRUCT *)
1816                                          chdlc_priv_area->start_trace_addr +
1817                                          (chdlc_priv_area->number_trace_elements - 1));
1818
1819                         chdlc_priv_area->base_addr_trace_buffer =
1820                                         trace_cfg_struct.base_addr_trace_buffer;
1821
1822                         chdlc_priv_area->end_addr_trace_buffer =
1823                                         trace_cfg_struct.end_addr_trace_buffer;
1824
1825                         chdlc_priv_area->curr_trace_addr =
1826                                         trace_cfg_struct.next_trace_element_to_use;
1827
1828                         chdlc_priv_area->available_buffer_space = 2000 -
1829                                                                   sizeof(ip_pkt_t) -
1830                                                                   sizeof(udp_pkt_t) -
1831                                                                   sizeof(wp_mgmt_t) -
1832                                                                   sizeof(cblock_t) -
1833                                                                   sizeof(trace_info_t);
1834                      }
1835                      chdlc_udp_pkt->cblock.return_code = COMMAND_OK;
1836                      mb->buffer_length = 0;
1837                      chdlc_priv_area->TracingEnabled = 1;
1838                      break;
1839
1840
1841                 case CPIPE_DISABLE_TRACING:
1842                      if (chdlc_priv_area->TracingEnabled) {
1843
1844                         /* OPERATE_DATALINE_MONITOR */
1845                         mb->buffer_length = sizeof(LINE_TRACE_CONFIG_STRUCT);
1846                         mb->command = SET_TRACE_CONFIGURATION;
1847                         ((LINE_TRACE_CONFIG_STRUCT *)mb->data)->
1848                                 trace_config = TRACE_INACTIVE;
1849                         err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1850                      }
1851
1852                      chdlc_priv_area->TracingEnabled = 0;
1853                      chdlc_udp_pkt->cblock.return_code = COMMAND_OK;
1854                      mb->buffer_length = 0;
1855                      break;
1856
1857
1858                 case CPIPE_GET_TRACE_INFO:
1859
1860                      if (!chdlc_priv_area->TracingEnabled) {
1861                         chdlc_udp_pkt->cblock.return_code = 1;
1862                         mb->buffer_length = 0;
1863                         break;
1864                      }
1865
1866                      chdlc_udp_pkt->trace_info.ismoredata = 0x00;
1867                      buffer_length = 0; /* offset of packet already occupied */
1868
1869                      for (frames=0; frames < chdlc_priv_area->number_trace_elements; frames++){
1870
1871                         trace_pkt_t *trace_pkt = (trace_pkt_t *)
1872                                 &chdlc_udp_pkt->data[buffer_length];
1873
1874                         sdla_peek(&card->hw, chdlc_priv_area->curr_trace_addr,
1875                                   (unsigned char *)&trace_element_struct,
1876                                   sizeof(TRACE_STATUS_ELEMENT_STRUCT));
1877
1878                         if (trace_element_struct.opp_flag == 0x00) {
1879                                 break;
1880                         }
1881
1882                         /* get pointer to real data */
1883                         data_ptr = trace_element_struct.ptr_data_bfr;
1884
1885                         /* See if there is actual data on the trace buffer */
1886                         if (data_ptr){
1887                                 data_length = trace_element_struct.trace_length;
1888                         }else{
1889                                 data_length = 0;
1890                                 chdlc_udp_pkt->trace_info.ismoredata = 0x01;
1891                         }
1892
1893                         if( (chdlc_priv_area->available_buffer_space - buffer_length)
1894                                 < ( sizeof(trace_pkt_t) + data_length) ) {
1895
1896                             /* indicate there are more frames on board & exit */
1897                                 chdlc_udp_pkt->trace_info.ismoredata = 0x01;
1898                                 break;
1899                          }
1900
1901                         trace_pkt->status = trace_element_struct.trace_type;
1902
1903                         trace_pkt->time_stamp =
1904                                 trace_element_struct.trace_time_stamp;
1905
1906                         trace_pkt->real_length =
1907                                 trace_element_struct.trace_length;
1908
1909                         /* see if we can fit the frame into the user buffer */
1910                         real_len = trace_pkt->real_length;
1911
1912                         if (data_ptr == 0) {
1913                                 trace_pkt->data_avail = 0x00;
1914                         } else {
1915                                 unsigned tmp = 0;
1916
1917                                 /* get the data from circular buffer
1918                                     must check for end of buffer */
1919                                 trace_pkt->data_avail = 0x01;
1920
1921                                 if ((data_ptr + real_len) >
1922                                              chdlc_priv_area->end_addr_trace_buffer + 1){
1923
1924                                         tmp = chdlc_priv_area->end_addr_trace_buffer - data_ptr + 1;
1925                                         sdla_peek(&card->hw, data_ptr,
1926                                                   trace_pkt->data,tmp);
1927                                         data_ptr = chdlc_priv_area->base_addr_trace_buffer;
1928                                 }
1929
1930                                 sdla_peek(&card->hw, data_ptr,
1931                                           &trace_pkt->data[tmp], real_len - tmp);
1932                         }
1933
1934                         /* zero the opp flag to show we got the frame */
1935                         ut_char = 0x00;
1936                         sdla_poke(&card->hw, chdlc_priv_area->curr_trace_addr, &ut_char, 1);
1937
1938                         /* now move onto the next frame */
1939                         chdlc_priv_area->curr_trace_addr += sizeof(TRACE_STATUS_ELEMENT_STRUCT);
1940
1941                         /* check if we went over the last address */
1942                         if ( chdlc_priv_area->curr_trace_addr > chdlc_priv_area->end_trace_addr ) {
1943                                 chdlc_priv_area->curr_trace_addr = chdlc_priv_area->start_trace_addr;
1944                         }
1945
1946                         if(trace_pkt->data_avail == 0x01) {
1947                                 buffer_length += real_len - 1;
1948                         }
1949
1950                         /* for the header */
1951                         buffer_length += sizeof(trace_pkt_t);
1952
1953                      }  /* For Loop */
1954
1955                      if (frames == chdlc_priv_area->number_trace_elements){
1956                         chdlc_udp_pkt->trace_info.ismoredata = 0x01;
1957                      }
1958                      chdlc_udp_pkt->trace_info.num_frames = frames;
1959
1960                      mb->buffer_length = buffer_length;
1961                      chdlc_udp_pkt->cblock.buffer_length = buffer_length;
1962
1963                      chdlc_udp_pkt->cblock.return_code = COMMAND_OK;
1964
1965                      break;
1966
1967
1968                 case CPIPE_FT1_READ_STATUS:
1969                         ((unsigned char *)chdlc_udp_pkt->data )[0] =
1970                                 flags->FT1_info_struct.parallel_port_A_input;
1971
1972                         ((unsigned char *)chdlc_udp_pkt->data )[1] =
1973                                 flags->FT1_info_struct.parallel_port_B_input;
1974
1975                         chdlc_udp_pkt->cblock.return_code = COMMAND_OK;
1976                         mb->buffer_length = 2;
1977                         break;
1978
1979                 case CPIPE_ROUTER_UP_TIME:
1980                         do_gettimeofday( &tv );
1981                         chdlc_priv_area->router_up_time = tv.tv_sec -
1982                                         chdlc_priv_area->router_start_time;
1983                         *(unsigned long *)&chdlc_udp_pkt->data =
1984                                         chdlc_priv_area->router_up_time;
1985                         mb->buffer_length = sizeof(unsigned long);
1986                         break;
1987
1988                 case FT1_MONITOR_STATUS_CTRL:
1989                         /* Enable FT1 MONITOR STATUS */
1990                         if ((chdlc_udp_pkt->data[0] & ENABLE_READ_FT1_STATUS) ||
1991                                 (chdlc_udp_pkt->data[0] & ENABLE_READ_FT1_OP_STATS)) {
1992
1993                                 if( rCount++ != 0 ) {
1994                                         chdlc_udp_pkt->cblock.
1995                                         return_code = COMMAND_OK;
1996                                         mb->buffer_length = 1;
1997                                         break;
1998                                 }
1999                         }
2000
2001                         /* Disable FT1 MONITOR STATUS */
2002                         if( chdlc_udp_pkt->data[0] == 0) {
2003
2004                                 if( --rCount != 0) {
2005                                         chdlc_udp_pkt->cblock.
2006                                         return_code = COMMAND_OK;
2007                                         mb->buffer_length = 1;
2008                                         break;
2009                                 }
2010                         }
2011
2012                 default:
2013                         /* it's a board command */
2014                         mb->command = chdlc_udp_pkt->cblock.command;
2015                         mb->buffer_length = chdlc_udp_pkt->cblock.buffer_length;
2016                         if (mb->buffer_length) {
2017                                 memcpy(&mb->data, (unsigned char *) chdlc_udp_pkt->
2018                                                         data, mb->buffer_length);
2019                         }
2020                         /* run the command on the board */
2021                         err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
2022                         if (err != COMMAND_OK) {
2023                                 break;
2024                         }
2025
2026                         /* copy the result back to our buffer */
2027                         memcpy(&chdlc_udp_pkt->cblock, mb, sizeof(cblock_t));
2028
2029                         if (mb->buffer_length) {
2030                                 memcpy(&chdlc_udp_pkt->data, &mb->data,
2031                                                                 mb->buffer_length);
2032                         }
2033
2034                 } /* end of switch */
2035         } /* end of else */
2036
2037         /* Fill UDP TTL */
2038         chdlc_udp_pkt->ip_pkt.ttl = card->wandev.ttl;
2039
2040         len = reply_udp(chdlc_priv_area->udp_pkt_data, mb->buffer_length);
2041
2042         if(chdlc_priv_area->udp_pkt_src == UDP_PKT_FRM_NETWORK) {
2043                 if(!chdlc_send(card, chdlc_priv_area->udp_pkt_data, len)) {
2044                         ++ card->wandev.stats.tx_packets;
2045                         card->wandev.stats.tx_bytes += len;
2046                 }
2047         } else {
2048
2049                 /* Pass it up the stack
2050                    Allocate socket buffer */
2051                 if ((new_skb = dev_alloc_skb(len)) != NULL) {
2052                         /* copy data into new_skb */
2053
2054                         buf = skb_put(new_skb, len);
2055                         memcpy(buf, chdlc_priv_area->udp_pkt_data, len);
2056
2057                         /* Decapsulate pkt and pass it up the protocol stack */
2058                         new_skb->protocol = htons(ETH_P_IP);
2059                         new_skb->dev = dev;
2060                         new_skb->mac.raw  = new_skb->data;
2061
2062                         netif_rx(new_skb);
2063                         dev->last_rx = jiffies;
2064                 } else {
2065
2066                         printk(KERN_INFO "%s: no socket buffers available!\n",
2067                                         card->devname);
2068                 }
2069         }
2070
2071         chdlc_priv_area->udp_pkt_lgth = 0;
2072
2073         return 0;
2074 }
2075
2076 /*============================================================================
2077  * Initialize Receive and Transmit Buffers.
2078  */
2079
2080 static void init_chdlc_tx_rx_buff(sdla_t* card, struct net_device *dev)
2081 {
2082         CHDLC_MAILBOX_STRUCT* mb = card->mbox;
2083         CHDLC_TX_STATUS_EL_CFG_STRUCT *tx_config;
2084         CHDLC_RX_STATUS_EL_CFG_STRUCT *rx_config;
2085         char err;
2086
2087         mb->buffer_length = 0;
2088         mb->command = READ_CHDLC_CONFIGURATION;
2089         err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
2090
2091         if(err != COMMAND_OK) {
2092                 chdlc_error(card,err,mb);
2093                 return;
2094         }
2095
2096         if(card->hw.type == SDLA_S514) {
2097                 tx_config = (CHDLC_TX_STATUS_EL_CFG_STRUCT *)(card->hw.dpmbase +
2098                 (((CHDLC_CONFIGURATION_STRUCT *)mb->data)->
2099                             ptr_CHDLC_Tx_stat_el_cfg_struct));
2100                 rx_config = (CHDLC_RX_STATUS_EL_CFG_STRUCT *)(card->hw.dpmbase +
2101                 (((CHDLC_CONFIGURATION_STRUCT *)mb->data)->
2102                             ptr_CHDLC_Rx_stat_el_cfg_struct));
2103
2104                 /* Setup Head and Tails for buffers */
2105                 card->u.c.txbuf_base = (void *)(card->hw.dpmbase +
2106                 tx_config->base_addr_Tx_status_elements);
2107                 card->u.c.txbuf_last =
2108                 (CHDLC_DATA_TX_STATUS_EL_STRUCT *)
2109                 card->u.c.txbuf_base +
2110                 (tx_config->number_Tx_status_elements - 1);
2111
2112                 card->u.c.rxbuf_base = (void *)(card->hw.dpmbase +
2113                 rx_config->base_addr_Rx_status_elements);
2114                 card->u.c.rxbuf_last =
2115                 (CHDLC_DATA_RX_STATUS_EL_STRUCT *)
2116                 card->u.c.rxbuf_base +
2117                 (rx_config->number_Rx_status_elements - 1);
2118
2119                 /* Set up next pointer to be used */
2120                 card->u.c.txbuf = (void *)(card->hw.dpmbase +
2121                 tx_config->next_Tx_status_element_to_use);
2122                 card->u.c.rxmb = (void *)(card->hw.dpmbase +
2123                 rx_config->next_Rx_status_element_to_use);
2124         }
2125         else {
2126                 tx_config = (CHDLC_TX_STATUS_EL_CFG_STRUCT *)(card->hw.dpmbase +
2127                         (((CHDLC_CONFIGURATION_STRUCT *)mb->data)->
2128                         ptr_CHDLC_Tx_stat_el_cfg_struct % SDLA_WINDOWSIZE));
2129
2130                 rx_config = (CHDLC_RX_STATUS_EL_CFG_STRUCT *)(card->hw.dpmbase +
2131                         (((CHDLC_CONFIGURATION_STRUCT *)mb->data)->
2132                         ptr_CHDLC_Rx_stat_el_cfg_struct % SDLA_WINDOWSIZE));
2133
2134                 /* Setup Head and Tails for buffers */
2135                 card->u.c.txbuf_base = (void *)(card->hw.dpmbase +
2136                 (tx_config->base_addr_Tx_status_elements % SDLA_WINDOWSIZE));
2137                 card->u.c.txbuf_last =
2138                 (CHDLC_DATA_TX_STATUS_EL_STRUCT *)card->u.c.txbuf_base
2139                 + (tx_config->number_Tx_status_elements - 1);
2140                 card->u.c.rxbuf_base = (void *)(card->hw.dpmbase +
2141                 (rx_config->base_addr_Rx_status_elements % SDLA_WINDOWSIZE));
2142                 card->u.c.rxbuf_last =
2143                 (CHDLC_DATA_RX_STATUS_EL_STRUCT *)card->u.c.rxbuf_base
2144                 + (rx_config->number_Rx_status_elements - 1);
2145
2146                  /* Set up next pointer to be used */
2147                 card->u.c.txbuf = (void *)(card->hw.dpmbase +
2148                 (tx_config->next_Tx_status_element_to_use % SDLA_WINDOWSIZE));
2149                 card->u.c.rxmb = (void *)(card->hw.dpmbase +
2150                 (rx_config->next_Rx_status_element_to_use % SDLA_WINDOWSIZE));
2151         }
2152
2153         /* Setup Actual Buffer Start and end addresses */
2154         card->u.c.rx_base = rx_config->base_addr_Rx_buffer;
2155         card->u.c.rx_top  = rx_config->end_addr_Rx_buffer;
2156
2157 }
2158
2159 /*=============================================================================
2160  * Perform Interrupt Test by running READ_CHDLC_CODE_VERSION command MAX_INTR
2161  * _TEST_COUNTER times.
2162  */
2163 static int intr_test( sdla_t* card)
2164 {
2165         CHDLC_MAILBOX_STRUCT* mb = card->mbox;
2166         int err,i;
2167
2168         Intr_test_counter = 0;
2169
2170         /* The critical flag is unset because during initialization (if_open)
2171          * we want the interrupts to be enabled so that when the wpc_isr is
2172          * called it does not exit due to critical flag set.
2173          */
2174
2175         err = chdlc_set_intr_mode(card, APP_INT_ON_COMMAND_COMPLETE);
2176
2177         if (err == CMD_OK) {
2178                 for (i = 0; i < MAX_INTR_TEST_COUNTER; i ++) {
2179                         mb->buffer_length  = 0;
2180                         mb->command = READ_CHDLC_CODE_VERSION;
2181                         err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
2182                 }
2183         }
2184         else {
2185                 return err;
2186         }
2187
2188         err = chdlc_set_intr_mode(card, 0);
2189
2190         if (err != CMD_OK)
2191                 return err;
2192
2193         return 0;
2194 }
2195
2196 /*==============================================================================
2197  * Determine what type of UDP call it is. CPIPEAB ?
2198  */
2199 static int udp_pkt_type(struct sk_buff *skb, sdla_t* card)
2200 {
2201          chdlc_udp_pkt_t *chdlc_udp_pkt = (chdlc_udp_pkt_t *)skb->data;
2202
2203         if (!strncmp(chdlc_udp_pkt->wp_mgmt.signature,UDPMGMT_SIGNATURE,8) &&
2204            (chdlc_udp_pkt->udp_pkt.udp_dst_port == ntohs(card->wandev.udp_port)) &&
2205            (chdlc_udp_pkt->ip_pkt.protocol == UDPMGMT_UDP_PROTOCOL) &&
2206            (chdlc_udp_pkt->wp_mgmt.request_reply == UDPMGMT_REQUEST)) {
2207                 return UDP_CPIPE_TYPE;
2208         }
2209         else return UDP_INVALID_TYPE;
2210 }
2211
2212 /*============================================================================
2213  * Set PORT state.
2214  */
2215 static void port_set_state (sdla_t *card, int state)
2216 {
2217         struct net_device *dev = card->wandev.dev;
2218         chdlc_private_area_t *chdlc_priv_area = dev->priv;
2219
2220         if (card->u.c.state != state)
2221         {
2222                 switch (state)
2223                 {
2224                 case WAN_CONNECTED:
2225                         printk (KERN_INFO "%s: HDLC link connected!\n",
2226                                 card->devname);
2227                       break;
2228
2229                 case WAN_CONNECTING:
2230                         printk (KERN_INFO "%s: HDLC link connecting...\n",
2231                                 card->devname);
2232                         break;
2233
2234                 case WAN_DISCONNECTED:
2235                         printk (KERN_INFO "%s: HDLC link disconnected!\n",
2236                                 card->devname);
2237                         break;
2238                 }
2239
2240                 card->wandev.state = card->u.c.state = state;
2241                 chdlc_priv_area->common.state = state;
2242         }
2243 }
2244
2245 void s508_lock (sdla_t *card, unsigned long *smp_flags)
2246 {
2247         spin_lock_irqsave(&card->wandev.lock, *smp_flags);
2248         if (card->next){
2249                 /* It is ok to use spin_lock here, since we
2250                  * already turned off interrupts */
2251                 spin_lock(&card->next->wandev.lock);
2252         }
2253 }
2254
2255 void s508_unlock (sdla_t *card, unsigned long *smp_flags)
2256 {
2257         if (card->next){
2258                 spin_unlock(&card->next->wandev.lock);
2259         }
2260         spin_unlock_irqrestore(&card->wandev.lock, *smp_flags);
2261 }
2262
2263
2264
2265 /*===========================================================================
2266  * config_chdlc
2267  *
2268  *      Configure the chdlc protocol and enable communications.
2269  *
2270  *      The if_open() function binds this function to the poll routine.
2271  *      Therefore, this function will run every time the chdlc interface
2272  *      is brought up. We cannot run this function from the if_open
2273  *      because if_open does not have access to the remote IP address.
2274  *
2275  *      If the communications are not enabled, proceed to configure
2276  *      the card and enable communications.
2277  *
2278  *      If the communications are enabled, it means that the interface
2279  *      was shutdown by ether the user or driver. In this case, we
2280  *      have to check that the IP addresses have not changed.  If
2281  *      the IP addresses have changed, we have to reconfigure the firmware
2282  *      and update the changed IP addresses.  Otherwise, just exit.
2283  *
2284  */
2285
2286 static int config_chdlc (sdla_t *card)
2287 {
2288         struct net_device *dev = card->wandev.dev;
2289         SHARED_MEMORY_INFO_STRUCT *flags = card->u.c.flags;
2290
2291         if (card->u.c.comm_enabled){
2292                 chdlc_comm_disable(card);
2293                 port_set_state(card, WAN_DISCONNECTED);
2294         }
2295
2296         if (set_chdlc_config(card)) {
2297                 printk(KERN_INFO "%s: CHDLC Configuration Failed!\n",
2298                                 card->devname);
2299                 return 0;
2300         }
2301         init_chdlc_tx_rx_buff(card, dev);
2302
2303         /* Set interrupt mode and mask */
2304         if (chdlc_set_intr_mode(card, APP_INT_ON_RX_FRAME |
2305                                 APP_INT_ON_GLOBAL_EXCEP_COND |
2306                                 APP_INT_ON_TX_FRAME |
2307                                 APP_INT_ON_CHDLC_EXCEP_COND | APP_INT_ON_TIMER)){
2308                 printk (KERN_INFO "%s: Failed to set interrupt triggers!\n",
2309                                 card->devname);
2310                 return 0;
2311         }
2312
2313
2314         /* Mask the Transmit and Timer interrupt */
2315         flags->interrupt_info_struct.interrupt_permission &=
2316                 ~(APP_INT_ON_TX_FRAME | APP_INT_ON_TIMER);
2317
2318
2319         if (chdlc_comm_enable(card) != 0) {
2320                 printk(KERN_INFO "%s: Failed to enable chdlc communications!\n",
2321                                 card->devname);
2322                 flags->interrupt_info_struct.interrupt_permission = 0;
2323                 card->u.c.comm_enabled=0;
2324                 chdlc_set_intr_mode(card,0);
2325                 return 0;
2326         }
2327
2328         /* Initialize Rx/Tx buffer control fields */
2329         port_set_state(card, WAN_CONNECTING);
2330         return 0;
2331 }
2332
2333
2334 static void send_ppp_term_request(struct net_device *dev)
2335 {
2336         struct sk_buff *new_skb;
2337         unsigned char *buf;
2338
2339         if ((new_skb = dev_alloc_skb(8)) != NULL) {
2340                 /* copy data into new_skb */
2341
2342                 buf = skb_put(new_skb, 8);
2343                 sprintf(buf,"%c%c%c%c%c%c%c%c", 0xFF,0x03,0xC0,0x21,0x05,0x98,0x00,0x07);
2344
2345                 /* Decapsulate pkt and pass it up the protocol stack */
2346                 new_skb->protocol = htons(ETH_P_WAN_PPP);
2347                 new_skb->dev = dev;
2348                 new_skb->mac.raw  = new_skb->data;
2349
2350                 netif_rx(new_skb);
2351                 dev->last_rx = jiffies;
2352         }
2353 }
2354
2355
2356 MODULE_LICENSE("GPL");
2357
2358 /****** End ****************************************************************/