drivers/net/sdla_ppp.c

   1 /*****************************************************************************
   2 * sdla_ppp.c    WANPIPE(tm) Multiprotocol WAN Link Driver. PPP module.
   3 *
   4 * Author:       Jaspreet Singh  <jaspreet@sangoma.com>
   5 *
   6 * Copyright:    (c) 1995-1997 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 * Mar 15, 1998  Alan Cox        o 2.1.8x basic port.
  14 * Nov 27, 1997  Jaspreet Singh  o Added protection against enabling of irqs
  15 *                                 while they have been disabled.
  16 * Nov 24, 1997  Jaspreet Singh  o Fixed another RACE condition caused by
  17 *                                 disabling and enabling of irqs.
  18 *                               o Added new counters for stats on disable/enable*                                 IRQs.
  19 * Nov 10, 1997  Jaspreet Singh  o Initialized 'skb->mac.raw' to 'skb->data'
  20 *                                 before every netif_rx().
  21 *                               o Free up the device structure in del_if().
  22 * Nov 07, 1997  Jaspreet Singh  o Changed the delay to zero for Line tracing
  23 *                                 command.
  24 * Oct 20, 1997  Jaspreet Singh  o Added hooks in for Router UP time.
  25 * Oct 16, 1997  Jaspreet Singh  o The critical flag is used to maintain flow
  26 *                                 control by avoiding RACE conditions.  The
  27 *                                 cli() and restore_flags() are taken out.
  28 *                                 A new structure, "ppp_private_area", is added
  29 *                                 to provide Driver Statistics.
  30 * Jul 21, 1997  Jaspreet Singh  o Protected calls to sdla_peek() by adding
  31 *                                 save_flags(), cli() and restore_flags().
  32 * Jul 07, 1997  Jaspreet Singh  o Added configurable TTL for UDP packets
  33 *                               o Added ability to discard mulitcast and
  34 *                                 broacast source addressed packets.
  35 * Jun 27, 1997  Jaspreet Singh  o Added FT1 monitor capabilities
  36 *                                 New case (0x25) statement in if_send routine.
  37 *                                 Added a global variable rCount to keep track
  38 *                                 of FT1 status enabled on the board.
  39 * May 22, 1997  Jaspreet Singh  o Added change in the PPP_SET_CONFIG command for
  40 *                               508 card to reflect changes in the new
  41 *                               ppp508.sfm for supporting:continous transmission
  42 *                               of Configure-Request packets without receiving a
  43 *                               reply
  44 *                               OR-ed 0x300 to conf_flags
  45 *                               o Changed connect_tmout from 900 to 0
  46 * May 21, 1997  Jaspreet Singh  o Fixed UDP Management for multiple boards
  47 * Apr 25, 1997  Farhan Thawar    o added UDP Management stuff
  48 * Mar 11, 1997  Farhan Thawar   Version 3.1.1
  49 *                                o fixed (+1) bug in rx_intr()
  50 *                                o changed if_send() to return 0 if
  51 *                                  wandev.critical() is true
  52 *                                o free socket buffer in if_send() if
  53 *                                  returning 0
  54 * Jan 15, 1997  Gene Kozin      Version 3.1.0
  55 *                                o implemented exec() entry point
  56 * Jan 06, 1997  Gene Kozin      Initial version.
  57 *****************************************************************************/
  58
  59 #include <linux/kernel.h>       /* printk(), and other useful stuff */
  60 #include <linux/stddef.h>       /* offsetof(), etc. */
  61 #include <linux/errno.h>        /* return codes */
  62 #include <linux/string.h>       /* inline memset(), etc. */
  63 #include <linux/malloc.h>       /* kmalloc(), kfree() */
  64 #include <linux/wanrouter.h>    /* WAN router definitions */
  65 #include <linux/wanpipe.h>      /* WANPIPE common user API definitions */
  66 #include <linux/if_arp.h>       /* ARPHRD_* defines */
  67 #include <asm/byteorder.h>      /* htons(), etc. */
  68 #include <asm/uaccess.h>        /* copyto/from user */
  69 #define _GNUC_
  70 #include <linux/sdla_ppp.h>     /* PPP firmware API definitions */
  71
  72 /****** Defines & Macros ****************************************************/
  73
  74 #ifdef  _DEBUG_
  75 #define STATIC
  76 #else
  77 #define STATIC          static
  78 #endif
  79 #define PPP_DFLT_MTU    1500    /* default MTU */
  80 #define PPP_MAX_MTU     4000    /* maximum MTU */
  81 #define PPP_HDR_LEN     1
  82 #define CONNECT_TIMEOUT (90*HZ) /* link connection timeout */
  83 #define HOLD_DOWN_TIME  (30*HZ) /* link hold down time */
  84
  85 /* For handle_IPXWAN() */
  86 #define CVHexToAscii(b) (((unsigned char)(b) > (unsigned char)9) ? ((unsigned char)'A' + ((unsigned char)(b) - (unsigned char)10)) : ((unsigned char)'0' + (unsigned char)(b)))
  87
  88 /******Data Structures*****************************************************/
  89 /* This structure is placed in the private data area of the device structure.
  90  * The card structure used to occupy the private area but now the following
  91  * structure will incorporate the card structure along with PPP specific data
  92  */
  93
  94 typedef struct ppp_private_area
  95 {
  96         sdla_t *card;
  97         unsigned long router_start_time;        /*router start time in sec */
  98         unsigned long tick_counter;     /*used for 5 second counter */
  99         unsigned mc;            /*multicast support on or off */
 100         /* PPP specific statistics */
 101         unsigned long if_send_entry;
 102         unsigned long if_send_skb_null;
 103         unsigned long if_send_broadcast;
 104         unsigned long if_send_multicast;
 105         unsigned long if_send_critical_ISR;
 106         unsigned long if_send_critical_non_ISR;
 107         unsigned long if_send_busy;
 108         unsigned long if_send_busy_timeout;
 109         unsigned long if_send_DRVSTATS_request;
 110         unsigned long if_send_PTPIPE_request;
 111         unsigned long if_send_wan_disconnected;
 112         unsigned long if_send_adptr_bfrs_full;
 113         unsigned long if_send_protocol_error;
 114         unsigned long if_send_tx_int_enabled;
 115         unsigned long if_send_bfr_passed_to_adptr;
 116         unsigned long rx_intr_no_socket;
 117         unsigned long rx_intr_DRVSTATS_request;
 118         unsigned long rx_intr_PTPIPE_request;
 119         unsigned long rx_intr_bfr_not_passed_to_stack;
 120         unsigned long rx_intr_bfr_passed_to_stack;
 121         unsigned long UDP_PTPIPE_mgmt_kmalloc_err;
 122         unsigned long UDP_PTPIPE_mgmt_adptr_type_err;
 123         unsigned long UDP_PTPIPE_mgmt_direction_err;
 124         unsigned long UDP_PTPIPE_mgmt_adptr_cmnd_timeout;
 125         unsigned long UDP_PTPIPE_mgmt_adptr_cmnd_OK;
 126         unsigned long UDP_PTPIPE_mgmt_passed_to_adptr;
 127         unsigned long UDP_PTPIPE_mgmt_passed_to_stack;
 128         unsigned long UDP_PTPIPE_mgmt_no_socket;
 129         unsigned long UDP_DRVSTATS_mgmt_kmalloc_err;
 130         unsigned long UDP_DRVSTATS_mgmt_adptr_type_err;
 131         unsigned long UDP_DRVSTATS_mgmt_direction_err;
 132         unsigned long UDP_DRVSTATS_mgmt_adptr_cmnd_timeout;
 133         unsigned long UDP_DRVSTATS_mgmt_adptr_cmnd_OK;
 134         unsigned long UDP_DRVSTATS_mgmt_passed_to_adptr;
 135         unsigned long UDP_DRVSTATS_mgmt_passed_to_stack;
 136         unsigned long UDP_DRVSTATS_mgmt_no_socket;
 137         unsigned long router_up_time;
 138 } ppp_private_area_t;
 139
 140 /* variable for keeping track of enabling/disabling FT1 monitor status */
 141
 142 static int rCount = 0;
 143 extern void disable_irq(unsigned int);
 144 extern void enable_irq(unsigned int);
 145
 146 /****** Function Prototypes *************************************************/
 147
 148 /* WAN link driver entry points. These are called by the WAN router module. */
 149 static int update(wan_device_t * wandev);
 150 static int new_if(wan_device_t * wandev, struct net_device *dev,
 151                   wanif_conf_t * conf);
 152 static int del_if(wan_device_t * wandev, struct net_device *dev);
 153 /* WANPIPE-specific entry points */
 154 static int wpp_exec(struct sdla *card, void *u_cmd, void *u_data);
 155 /* Network device interface */
 156 static int if_init(struct net_device *dev);
 157 static int if_open(struct net_device *dev);
 158 static int if_close(struct net_device *dev);
 159 static int if_header(struct sk_buff *skb, struct net_device *dev,
 160             unsigned short type, void *daddr, void *saddr, unsigned len);
 161 static int if_rebuild_hdr(struct sk_buff *skb);
 162 static int if_send(struct sk_buff *skb, struct net_device *dev);
 163 static struct enet_statistics *if_stats(struct net_device *dev);
 164 /* PPP firmware interface functions */
 165 static int ppp_read_version(sdla_t * card, char *str);
 166 static int ppp_configure(sdla_t * card, void *data);
 167 static int ppp_set_intr_mode(sdla_t * card, unsigned mode);
 168 static int ppp_comm_enable(sdla_t * card);
 169 static int ppp_comm_disable(sdla_t * card);
 170 static int ppp_get_err_stats(sdla_t * card);
 171 static int ppp_send(sdla_t * card, void *data, unsigned len, unsigned proto);
 172 static int ppp_error(sdla_t * card, int err, ppp_mbox_t * mb);
 173 /* Interrupt handlers */
 174 STATIC void wpp_isr(sdla_t * card);
 175 static void rx_intr(sdla_t * card);
 176 static void tx_intr(sdla_t * card);
 177 /* Background polling routines */
 178 static void wpp_poll(sdla_t * card);
 179 static void poll_active(sdla_t * card);
 180 static void poll_connecting(sdla_t * card);
 181 static void poll_disconnected(sdla_t * card);
 182 /* Miscellaneous functions */
 183 static int config502(sdla_t * card);
 184 static int config508(sdla_t * card);
 185 static void show_disc_cause(sdla_t * card, unsigned cause);
 186 static unsigned char bps_to_speed_code(unsigned long bps);
 187 static int reply_udp(unsigned char *data, unsigned int mbox_len);
 188 static int process_udp_mgmt_pkt(char udp_pkt_src, sdla_t * card, struct sk_buff *skb, struct net_device *dev, ppp_private_area_t * ppp_priv_area);
 189 static int process_udp_driver_call(char udp_pkt_src, sdla_t * card, struct sk_buff *skb, struct net_device *dev, ppp_private_area_t * ppp_priv_area);
 190 static void init_ppp_tx_rx_buff(sdla_t * card);
 191 static int intr_test(sdla_t * card);
 192 static int udp_pkt_type(struct sk_buff *skb, sdla_t * card);
 193 static void init_ppp_priv_struct(ppp_private_area_t * ppp_priv_area);
 194 static void init_global_statistics(sdla_t * card);
 195 static int Intr_test_counter;
 196 static char TracingEnabled;
 197 static unsigned long curr_trace_addr;
 198 static unsigned long start_trace_addr;
 199 static unsigned short available_buffer_space;
 200 /* IPX functions */
 201 static void switch_net_numbers(unsigned char *sendpacket, unsigned long network_number, unsigned char incoming);
 202 static int handle_IPXWAN(unsigned char *sendpacket, char *devname, unsigned char enable_IPX, unsigned long network_number, unsigned short proto);
 203
 204 /****** Public Functions ****************************************************/
 205
 206 /*============================================================================
 207  * PPP protocol initialization routine.
 208  *
 209  * This routine is called by the main WANPIPE module during setup.  At this
 210  * point adapter is completely initialized and firmware is running.
 211  *  o read firmware version (to make sure it's alive)
 212  *  o configure adapter
 213  *  o initialize protocol-specific fields of the adapter data space.
 214  *
 215  * Return:      0       o.k.
 216  *              < 0     failure.
 217  */
 218 int wpp_init(sdla_t * card, wandev_conf_t * conf)
 219 {
 220         union {
 221                 char str[80];
 222         } u;
 223         /* Verify configuration ID */
 224         if (conf->config_id != WANCONFIG_PPP) {
 225                 printk(KERN_INFO "%s: invalid configuration ID %u!\n",
 226                        card->devname, conf->config_id);
 227                 return -EINVAL;
 228         }
 229         /* Initialize protocol-specific fields */
 230         switch (card->hw.fwid) {
 231         case SFID_PPP502:
 232                 card->mbox = (void *) (card->hw.dpmbase + PPP502_MB_OFFS);
 233                 card->flags = (void *) (card->hw.dpmbase + PPP502_FLG_OFFS);
 234                 break;
 235         case SFID_PPP508:
 236                 card->mbox = (void *) (card->hw.dpmbase + PPP508_MB_OFFS);
 237                 card->flags = (void *) (card->hw.dpmbase + PPP508_FLG_OFFS);
 238                 break;
 239         default:
 240                 return -EINVAL;
 241         }
 242         /* Read firmware version.  Note that when adapter initializes, it
 243          * clears the mailbox, so it may appear that the first command was
 244          * executed successfully when in fact it was merely erased. To work
 245          * around this, we execute the first command twice.
 246          */
 247         if (ppp_read_version(card, NULL) || ppp_read_version(card, u.str))
 248                 return -EIO;
 249         printk(KERN_INFO "%s: running PPP firmware v%s\n", card->devname, u.str);
 250         /* Adjust configuration and set defaults */
 251         card->wandev.mtu = (conf->mtu) ?
 252             min(conf->mtu, PPP_MAX_MTU) : PPP_DFLT_MTU;
 253         card->wandev.bps = conf->bps;
 254         card->wandev.interface = conf->interface;
 255         card->wandev.clocking = conf->clocking;
 256         card->wandev.station = conf->station;
 257         card->isr = &wpp_isr;
 258         card->poll = &wpp_poll;
 259         card->exec = &wpp_exec;
 260         card->wandev.update = &update;
 261         card->wandev.new_if = &new_if;
 262         card->wandev.del_if = &del_if;
 263         card->wandev.state = WAN_DISCONNECTED;
 264         card->wandev.udp_port = conf->udp_port;
 265         card->wandev.ttl = conf->ttl;
 266         card->irq_dis_if_send_count = 0;
 267         card->irq_dis_poll_count = 0;
 268         TracingEnabled = 0;
 269         card->wandev.enable_IPX = conf->enable_IPX;
 270         if (conf->network_number)
 271                 card->wandev.network_number = conf->network_number;
 272         else
 273                 card->wandev.network_number = 0xDEADBEEF;
 274         /* initialize global statistics */
 275         init_global_statistics(card);
 276         return 0;
 277 }
 278
 279 /******* WAN Device Driver Entry Points *************************************/
 280
 281 /*============================================================================
 282  * Update device status & statistics.
 283  */
 284 static int update(wan_device_t * wandev)
 285 {
 286         sdla_t *card;
 287         /* sanity checks */
 288         if ((wandev == NULL) || (wandev->private == NULL))
 289                 return -EFAULT;
 290         if (wandev->state == WAN_UNCONFIGURED)
 291                 return -ENODEV;
 292         if (test_and_set_bit(0, (void *) &wandev->critical))
 293                 return -EAGAIN;
 294         card = wandev->private;
 295         ppp_get_err_stats(card);
 296         wandev->critical = 0;
 297         return 0;
 298 }
 299
 300 /*============================================================================
 301  * Create new logical channel.
 302  * This routine is called by the router when ROUTER_IFNEW IOCTL is being
 303  * handled.
 304  * o parse media- and hardware-specific configuration
 305  * o make sure that a new channel can be created
 306  * o allocate resources, if necessary
 307  * o prepare network device structure for registaration.
 308  *
 309  * Return:      0       o.k.
 310  *              < 0     failure (channel will not be created)
 311  */
 312
 313 static int new_if(wan_device_t * wandev, struct net_device *dev, wanif_conf_t * conf)
 314 {
 315         sdla_t *card = wandev->private;
 316         ppp_private_area_t *ppp_priv_area;
 317         if (wandev->ndev)
 318                 return -EEXIST;
 319         if ((conf->name[0] == '\0') || (strlen(conf->name) > WAN_IFNAME_SZ)) {
 320                 printk(KERN_INFO "%s: invalid interface name!\n",
 321                        card->devname);
 322                 return -EINVAL;
 323         }
 324         /* allocate and initialize private data */
 325         ppp_priv_area = kmalloc(sizeof(ppp_private_area_t), GFP_KERNEL);
 326         if (ppp_priv_area == NULL)
 327                 return -ENOMEM;
 328         memset(ppp_priv_area, 0, sizeof(ppp_private_area_t));
 329         ppp_priv_area->card = card;
 330         /* initialize data */
 331         strcpy(card->u.p.if_name, conf->name);
 332         /* initialize data in ppp_private_area structure */
 333         init_ppp_priv_struct(ppp_priv_area);
 334         ppp_priv_area->mc = conf->mc;
 335         /* prepare network device data space for registration */
 336         dev->name = card->u.p.if_name;
 337         dev->init = &if_init;
 338         dev->priv = ppp_priv_area;
 339         return 0;
 340 }
 341
 342 /*============================================================================
 343  * Delete logical channel.
 344  */
 345
 346 static int del_if(wan_device_t * wandev, struct net_device *dev)
 347 {
 348         if (dev->priv) {
 349                 kfree(dev->priv);
 350                 dev->priv = NULL;
 351         }
 352         return 0;
 353 }
 354
 355 /****** WANPIPE-specific entry points ***************************************/
 356
 357 /*============================================================================
 358  * Execute adapter interface command.
 359  */
 360
 361 static int wpp_exec(struct sdla *card, void *u_cmd, void *u_data)
 362 {
 363         ppp_mbox_t *mbox = card->mbox;
 364         int len;
 365         if(copy_from_user((void *) &mbox->cmd, u_cmd, sizeof(ppp_cmd_t)))
 366                 return -EFAULT;
 367         len = mbox->cmd.length;
 368         if (len) {
 369                 if(copy_from_user((void *) &mbox->data, u_data, len))
 370                         return -EFAULT;
 371         }
 372         /* execute command */
 373         if (!sdla_exec(mbox))
 374                 return -EIO;
 375         /* return result */
 376         if(copy_to_user(u_cmd, (void *) &mbox->cmd, sizeof(ppp_cmd_t)))
 377                 return -EFAULT;
 378         len = mbox->cmd.length;
 379         if (len && u_data && copy_to_user(u_data, (void *) &mbox->data, len))
 380                 return -EFAULT;
 381         return 0;
 382 }
 383
 384 /****** Network Device Interface ********************************************/
 385
 386 /*============================================================================
 387  * Initialize Linux network interface.
 388  *
 389  * This routine is called only once for each interface, during Linux network
 390  * interface registration.  Returning anything but zero will fail interface
 391  * registration.
 392  */
 393
 394 static int if_init(struct net_device *dev)
 395 {
 396         ppp_private_area_t *ppp_priv_area = dev->priv;
 397         sdla_t *card = ppp_priv_area->card;
 398         wan_device_t *wandev = &card->wandev;
 399
 400         /* Initialize device driver entry points */
 401         dev->open = &if_open;
 402         dev->stop = &if_close;
 403         dev->hard_header = &if_header;
 404         dev->rebuild_header = &if_rebuild_hdr;
 405         dev->hard_start_xmit = &if_send;
 406         dev->get_stats = &if_stats;
 407         /* Initialize media-specific parameters */
 408         dev->type = ARPHRD_PPP; /* ARP h/w type */
 409         dev->mtu = wandev->mtu;
 410         dev->hard_header_len = PPP_HDR_LEN;     /* media header length */
 411         /* Initialize hardware parameters (just for reference) */
 412         dev->irq = wandev->irq;
 413         dev->dma = wandev->dma;
 414         dev->base_addr = wandev->ioport;
 415         dev->mem_start = (unsigned long)wandev->maddr;
 416         dev->mem_end = dev->mem_start + wandev->msize - 1;
 417         /* Set transmit buffer queue length */
 418         dev->tx_queue_len = 100;
 419         /* Initialize socket buffers */
 420         dev_init_buffers(dev);
 421         return 0;
 422 }
 423
 424 /*============================================================================
 425  * Open network interface.
 426  * o enable communications and interrupts.
 427  * o prevent module from unloading by incrementing use count
 428  *
 429  * Return 0 if O.k. or errno.
 430  */
 431
 432 static int if_open(struct net_device *dev)
 433 {
 434         ppp_private_area_t *ppp_priv_area = dev->priv;
 435         sdla_t *card = ppp_priv_area->card;
 436         ppp_flags_t *flags = card->flags;
 437         struct timeval tv;
 438         int err = 0;
 439         if (dev->start)
 440                 return -EBUSY;  /* only one open is allowed */
 441         if (test_and_set_bit(0, (void *) &card->wandev.critical))
 442                 return -EAGAIN;
 443         if ((card->hw.fwid == SFID_PPP502) ? config502(card) : config508(card)) {
 444                 err = -EIO;
 445                 card->wandev.critical = 0;
 446                 return err;
 447         }
 448         Intr_test_counter = 0;
 449         err = intr_test(card);
 450         if ((err) || (Intr_test_counter != (MAX_INTR_TEST_COUNTER + 1))) {
 451                 printk(KERN_INFO "%s: Interrupt Test Failed, Counter: %i\n",
 452                        card->devname, Intr_test_counter);
 453                 err = -EIO;
 454                 card->wandev.critical = 0;
 455                 return err;
 456         }
 457         printk(KERN_INFO "%s: Interrupt Test Passed, Counter: %i\n",
 458                card->devname, Intr_test_counter);
 459         /* Initialize Rx/Tx buffer control fields */
 460         init_ppp_tx_rx_buff(card);
 461         if (ppp_set_intr_mode(card, 0x03)) {
 462                 err = -EIO;
 463                 card->wandev.critical = 0;
 464                 return err;
 465         }
 466         flags->imask &= ~0x02;
 467         if (ppp_comm_enable(card)) {
 468                 err = -EIO;
 469                 card->wandev.critical = 0;
 470                 return err;
 471         }
 472         wanpipe_set_state(card, WAN_CONNECTING);
 473         wanpipe_open(card);
 474         dev->mtu = min(dev->mtu, card->wandev.mtu);
 475         dev->interrupt = 0;
 476         dev->tbusy = 0;
 477         dev->start = 1;
 478         do_gettimeofday(&tv);
 479         ppp_priv_area->router_start_time = tv.tv_sec;
 480         card->wandev.critical = 0;
 481         return err;
 482 }
 483
 484 /*============================================================================
 485  * Close network interface.
 486  * o if this is the last open, then disable communications and interrupts.
 487  * o reset flags.
 488  */
 489
 490 static int if_close(struct net_device *dev)
 491 {
 492         ppp_private_area_t *ppp_priv_area = dev->priv;
 493         sdla_t *card = ppp_priv_area->card;
 494         if (test_and_set_bit(0, (void *) &card->wandev.critical))
 495                 return -EAGAIN;
 496         dev->start = 0;
 497         wanpipe_close(card);
 498         wanpipe_set_state(card, WAN_DISCONNECTED);
 499         ppp_set_intr_mode(card, 0);
 500         ppp_comm_disable(card);
 501         card->wandev.critical = 0;
 502         return 0;
 503 }
 504
 505 /*============================================================================
 506  * Build media header.
 507  *
 508  * The trick here is to put packet type (Ethertype) into 'protocol' field of
 509  * the socket buffer, so that we don't forget it.  If packet type is not
 510  * supported, set skb->protocol to 0 and discard packet later.
 511  *
 512  * Return:      media header length.
 513  */
 514
 515 static int if_header(struct sk_buff *skb, struct net_device *dev,
 516              unsigned short type, void *daddr, void *saddr, unsigned len)
 517 {
 518         switch (type)
 519         {
 520                 case ETH_P_IP:
 521                 case ETH_P_IPX:
 522                         skb->protocol = type;
 523                         break;
 524                 default:
 525                         skb->protocol = 0;
 526         }
 527         return PPP_HDR_LEN;
 528 }
 529
 530 /*============================================================================
 531  * Re-build media header.
 532  *
 533  * Return:      1       physical address resolved.
 534  *              0       physical address not resolved
 535  */
 536
 537 static int if_rebuild_hdr(struct sk_buff *skb)
 538 {
 539         struct net_device *dev=skb->dev;
 540         ppp_private_area_t *ppp_priv_area = dev->priv;
 541         sdla_t *card = ppp_priv_area->card;
 542         printk(KERN_INFO "%s: rebuild_header() called for interface %s!\n",
 543                card->devname, dev->name);
 544         return 1;
 545 }
 546
 547 /*============================================================================
 548  * Send a packet on a network interface.
 549  * o set tbusy flag (marks start of the transmission) to block a timer-based
 550  *   transmit from overlapping.
 551  * o check link state. If link is not up, then drop the packet.
 552  * o execute adapter send command.
 553  * o free socket buffer
 554  *
 555  * Return:      0       complete (socket buffer must be freed)
 556  *              non-0   packet may be re-transmitted (tbusy must be set)
 557  *
 558  * Notes:
 559  * 1. This routine is called either by the protocol stack or by the "net
 560  *    bottom half" (with interrupts enabled).
 561  * 2. Setting tbusy flag will inhibit further transmit requests from the
 562  *    protocol stack and can be used for flow control with protocol layer.
 563  */
 564
 565 static int if_send(struct sk_buff *skb, struct net_device *dev)
 566 {
 567         ppp_private_area_t *ppp_priv_area = dev->priv;
 568         sdla_t *card = ppp_priv_area->card;
 569         unsigned char *sendpacket;
 570         unsigned long check_braddr, check_mcaddr;
 571         unsigned long host_cpu_flags;
 572         ppp_flags_t *flags = card->flags;
 573         int retry = 0;
 574         int err, udp_type;
 575         ++ppp_priv_area->if_send_entry;
 576         if (skb == NULL) {
 577                 /* If we get here, some higher layer thinks we've missed an
 578                  * tx-done interrupt.
 579                  */
 580                 printk(KERN_INFO "%s: interface %s got kicked!\n",
 581                        card->devname, dev->name);
 582                 ++ppp_priv_area->if_send_skb_null;
 583                 mark_bh(NET_BH);
 584                 return 0;
 585         }
 586         if (dev->tbusy) {
 587                 /* If our device stays busy for at least 5 seconds then we will
 588                  * kick start the device by making dev->tbusy = 0.  We expect
 589                  * that our device never stays busy more than 5 seconds. So this
 590                  * is only used as a last resort.
 591                  */
 592                 ++ppp_priv_area->if_send_busy;
 593                 ++card->wandev.stats.collisions;
 594                 if ((jiffies - ppp_priv_area->tick_counter) < (5 * HZ)) {
 595                         return 1;
 596                 }
 597                 printk(KERN_INFO "%s: Transmit times out\n", card->devname);
 598                 ++ppp_priv_area->if_send_busy_timeout;
 599                 /* unbusy the card (because only one interface per card) */
 600                 dev->tbusy = 0;
 601         }
 602         sendpacket = skb->data;
 603         udp_type = udp_pkt_type(skb, card);
 604         if (udp_type == UDP_DRVSTATS_TYPE) {
 605                 ++ppp_priv_area->if_send_DRVSTATS_request;
 606                 process_udp_driver_call(UDP_PKT_FRM_STACK, card, skb, dev,
 607                                         ppp_priv_area);
 608                 dev_kfree_skb(skb);
 609                 return 0;
 610         } else if (udp_type == UDP_PTPIPE_TYPE)
 611                 ++ppp_priv_area->if_send_PTPIPE_request;
 612         /* retreive source address in two forms: broadcast & multicast */
 613         check_braddr = sendpacket[15];
 614         check_mcaddr = sendpacket[12];
 615         check_braddr = check_braddr << 8;
 616         check_mcaddr = check_mcaddr << 8;
 617         check_braddr |= sendpacket[14];
 618         check_mcaddr |= sendpacket[13];
 619         check_braddr = check_braddr << 8;
 620         check_mcaddr = check_mcaddr << 8;
 621         check_braddr |= sendpacket[13];
 622         check_mcaddr |= sendpacket[14];
 623         check_braddr = check_braddr << 8;
 624         check_mcaddr = check_mcaddr << 8;
 625         check_braddr |= sendpacket[12];
 626         check_mcaddr |= sendpacket[15];
 627         /* if the Source Address is a Multicast address */
 628         if ((ppp_priv_area->mc == WANOPT_NO) && (check_mcaddr >= 0xE0000001)
 629             && (check_mcaddr <= 0xFFFFFFFE)) {
 630                 printk(KERN_INFO "%s: Mutlicast Src. Addr. silently discarded\n"
 631                        ,card->devname);
 632                 dev_kfree_skb(skb);
 633                 ++ppp_priv_area->if_send_multicast;
 634                 ++card->wandev.stats.tx_dropped;
 635                 return 0;
 636         }
 637         disable_irq(card->hw.irq);
 638         ++card->irq_dis_if_send_count;
 639         if (test_and_set_bit(0, (void *) &card->wandev.critical)) {
 640                 if (card->wandev.critical == CRITICAL_IN_ISR) {
 641                         /* If the critical flag is set due to an Interrupt
 642                          * then set enable transmit interrupt flag to enable
 643                          * transmit interrupt. (delay interrupt)
 644                          */
 645                         card->wandev.enable_tx_int = 1;
 646                         dev->tbusy = 1;
 647                         /* set the counter to see if we get the interrupt in
 648                          * 5 seconds.
 649                          */
 650                         ppp_priv_area->tick_counter = jiffies;
 651                         ++ppp_priv_area->if_send_critical_ISR;
 652                         save_flags(host_cpu_flags);
 653                         cli();
 654                         if ((!(--card->irq_dis_if_send_count)) &&
 655                             (!card->irq_dis_poll_count))
 656                                 enable_irq(card->hw.irq);
 657                         restore_flags(host_cpu_flags);
 658                         return 1;
 659                 }
 660                 dev_kfree_skb(skb);
 661                 ++ppp_priv_area->if_send_critical_non_ISR;
 662                 save_flags(host_cpu_flags);
 663                 cli();
 664                 if ((!(--card->irq_dis_if_send_count)) &&
 665                     (!card->irq_dis_poll_count))
 666                         enable_irq(card->hw.irq);
 667                 restore_flags(host_cpu_flags);
 668                 return 0;
 669         }
 670         if (udp_type == UDP_PTPIPE_TYPE) {
 671                 err = process_udp_mgmt_pkt(UDP_PKT_FRM_STACK, card, skb,
 672                                            dev, ppp_priv_area);
 673         } else if (card->wandev.state != WAN_CONNECTED) {
 674                 ++ppp_priv_area->if_send_wan_disconnected;
 675                 ++card->wandev.stats.tx_dropped;
 676         } else if (!skb->protocol) {
 677                 ++ppp_priv_area->if_send_protocol_error;
 678                 ++card->wandev.stats.tx_errors;
 679         } else {
 680                 /*If it's IPX change the network numbers to 0 if they're ours. */
 681                 if (skb->protocol == ETH_P_IPX) {
 682                         if (card->wandev.enable_IPX) {
 683                                 switch_net_numbers(skb->data,
 684                                          card->wandev.network_number, 0);
 685                         } else {
 686                                 ++card->wandev.stats.tx_dropped;
 687                                 goto tx_done;
 688                         }
 689                 }
 690                 if (ppp_send(card, skb->data, skb->len, skb->protocol)) {
 691                         retry = 1;
 692                         dev->tbusy = 1;
 693                         ++ppp_priv_area->if_send_adptr_bfrs_full;
 694                         ++ppp_priv_area->if_send_tx_int_enabled;
 695                         ppp_priv_area->tick_counter = jiffies;
 696                         ++card->wandev.stats.tx_errors;
 697                         flags->imask |= 0x02;   /* unmask Tx interrupts */
 698                 } else {
 699                         ++ppp_priv_area->if_send_bfr_passed_to_adptr;
 700                         ++card->wandev.stats.tx_packets;
 701                         card->wandev.stats.tx_bytes += skb->len;
 702                 }
 703         }
 704 tx_done:
 705         if (!retry) {
 706                 dev_kfree_skb(skb);
 707         }
 708         card->wandev.critical = 0;
 709         save_flags(host_cpu_flags);
 710         cli();
 711         if ((!(--card->irq_dis_if_send_count)) && (!card->irq_dis_poll_count))
 712                 enable_irq(card->hw.irq);
 713         restore_flags(host_cpu_flags);
 714         return retry;
 715 }
 716
 717 /*============================================================================
 718  * Reply to UDP Management system.
 719  * Return length of reply.
 720  */
 721
 722 static int reply_udp(unsigned char *data, unsigned int mbox_len)
 723 {
 724         unsigned short len, udp_length, temp, i, ip_length;
 725         unsigned long sum;
 726         /* Set length of packet */
 727         len = mbox_len + 60;
 728         /* fill in UDP reply */
 729         data[36] = 0x02;
 730         /* fill in UDP length */
 731         udp_length = mbox_len + 40;
 732         /* put it on an even boundary */
 733         if (udp_length & 0x0001) {
 734                 udp_length += 1;
 735                 len += 1;
 736         }
 737         temp = (udp_length << 8) | (udp_length >> 8);
 738         memcpy(&data[24], &temp, 2);
 739         /* swap UDP ports */
 740         memcpy(&temp, &data[20], 2);
 741         memcpy(&data[20], &data[22], 2);
 742         memcpy(&data[22], &temp, 2);
 743         /* add UDP pseudo header */
 744         temp = 0x1100;
 745         memcpy(&data[udp_length + 20], &temp, 2);
 746         temp = (udp_length << 8) | (udp_length >> 8);
 747         memcpy(&data[udp_length + 22], &temp, 2);
 748         /* calculate UDP checksum */
 749         data[26] = data[27] = 0;
 750         sum = 0;
 751         for (i = 0; i < udp_length + 12; i += 2) {
 752                 memcpy(&temp, &data[12 + i], 2);
 753                 sum += (unsigned long) temp;
 754         }
 755         while (sum >> 16) {
 756                 sum = (sum & 0xffffUL) + (sum >> 16);
 757         }
 758         temp = (unsigned short) sum;
 759         temp = ~temp;
 760         if (temp == 0)
 761                 temp = 0xffff;
 762         memcpy(&data[26], &temp, 2);
 763         /* fill in IP length */
 764         ip_length = udp_length + 20;
 765         temp = (ip_length << 8) | (ip_length >> 8);
 766         memcpy(&data[2], &temp, 2);
 767         /* swap IP addresses */
 768         memcpy(&temp, &data[12], 2);
 769         memcpy(&data[12], &data[16], 2);
 770         memcpy(&data[16], &temp, 2);
 771         memcpy(&temp, &data[14], 2);
 772         memcpy(&data[14], &data[18], 2);
 773         memcpy(&data[18], &temp, 2);
 774         /* fill in IP checksum */
 775         data[10] = data[11] = 0;
 776         sum = 0;
 777         for (i = 0; i < 20; i += 2) {
 778                 memcpy(&temp, &data[i], 2);
 779                 sum += (unsigned long) temp;
 780         }
 781         while (sum >> 16) {
 782                 sum = (sum & 0xffffUL) + (sum >> 16);
 783         }
 784         temp = (unsigned short) sum;
 785         temp = ~temp;
 786         if (temp == 0)
 787                 temp = 0xffff;
 788         memcpy(&data[10], &temp, 2);
 789         return len;
 790 }                               /* reply_udp */
 791
 792 /*
 793    If incoming is 0 (outgoing)- if the net numbers is ours make it 0
 794    if incoming is 1 - if the net number is 0 make it ours
 795  */
 796
 797 static void switch_net_numbers(unsigned char *sendpacket, unsigned long network_number, unsigned char incoming)
 798 {
 799         unsigned long pnetwork_number;
 800         pnetwork_number = (unsigned long) ((sendpacket[6] << 24) +
 801                            (sendpacket[7] << 16) + (sendpacket[8] << 8) +
 802                                            sendpacket[9]);
 803         if (!incoming) {
 804                 /* If the destination network number is ours, make it 0 */
 805                 if (pnetwork_number == network_number) {
 806                         sendpacket[6] = sendpacket[7] = sendpacket[8] =
 807                             sendpacket[9] = 0x00;
 808                 }
 809         } else {
 810                 /* If the incoming network is 0, make it ours */
 811                 if (pnetwork_number == 0) {
 812                         sendpacket[6] = (unsigned char) (network_number >> 24);
 813                         sendpacket[7] = (unsigned char) ((network_number &
 814                                                       0x00FF0000) >> 16);
 815                         sendpacket[8] = (unsigned char) ((network_number &
 816                                                        0x0000FF00) >> 8);
 817                         sendpacket[9] = (unsigned char) (network_number &
 818                                                          0x000000FF);
 819                 }
 820         }
 821         pnetwork_number = (unsigned long) ((sendpacket[18] << 24) +
 822                          (sendpacket[19] << 16) + (sendpacket[20] << 8) +
 823                                            sendpacket[21]);
 824         if (!incoming) {
 825                 /* If the source network is ours, make it 0 */
 826                 if (pnetwork_number == network_number) {
 827                         sendpacket[18] = sendpacket[19] = sendpacket[20] =
 828                             sendpacket[21] = 0x00;
 829                 }
 830         } else {
 831                 /* If the source network is 0, make it ours */
 832                 if (pnetwork_number == 0) {
 833                         sendpacket[18] = (unsigned char) (network_number >> 24);
 834                         sendpacket[19] = (unsigned char) ((network_number &
 835                                                       0x00FF0000) >> 16);
 836                         sendpacket[20] = (unsigned char) ((network_number &
 837                                                        0x0000FF00) >> 8);
 838                         sendpacket[21] = (unsigned char) (network_number &
 839                                                           0x000000FF);
 840                 }
 841         }
 842 }                               /* switch_net_numbers */
 843
 844 /*============================================================================
 845  * Get Ethernet-style interface statistics.
 846  * Return a pointer to struct enet_statistics.
 847  */
 848
 849 static struct enet_statistics *if_stats(struct net_device *dev)
 850 {
 851         ppp_private_area_t *ppp_priv_area = dev->priv;
 852         sdla_t *card;
 853
 854         /*
 855          *      Device is down:No statistics
 856          */
 857
 858         if(ppp_priv_area==NULL)
 859                 return NULL;
 860
 861         card = ppp_priv_area->card;
 862         return &card->wandev.stats;
 863 }
 864
 865 /****** PPP Firmware Interface Functions ************************************/
 866
 867 /*============================================================================
 868  * Read firmware code version.
 869  *      Put code version as ASCII string in str.
 870  */
 871
 872 static int ppp_read_version(sdla_t * card, char *str)
 873 {
 874         ppp_mbox_t *mb = card->mbox;
 875         int err;
 876         memset(&mb->cmd, 0, sizeof(ppp_cmd_t));
 877         mb->cmd.command = PPP_READ_CODE_VERSION;
 878         err = sdla_exec(mb) ? mb->cmd.result : CMD_TIMEOUT;
 879         if (err != CMD_OK)
 880                 ppp_error(card, err, mb);
 881         else if (str) {
 882                 int len = mb->cmd.length;
 883                 memcpy(str, mb->data, len);
 884                 str[len] = '\0';
 885         }
 886         return err;
 887 }
 888
 889 /*============================================================================
 890  * Configure PPP firmware.
 891  */
 892
 893 static int ppp_configure(sdla_t * card, void *data)
 894 {
 895         ppp_mbox_t *mb = card->mbox;
 896         int data_len = (card->hw.fwid == SFID_PPP502) ?
 897         sizeof(ppp502_conf_t) : sizeof(ppp508_conf_t);
 898         int err;
 899         memset(&mb->cmd, 0, sizeof(ppp_cmd_t));
 900         memcpy(mb->data, data, data_len);
 901         mb->cmd.length = data_len;
 902         mb->cmd.command = PPP_SET_CONFIG;
 903         err = sdla_exec(mb) ? mb->cmd.result : CMD_TIMEOUT;
 904         if (err != CMD_OK)
 905                 ppp_error(card, err, mb);
 906         return err;
 907 }
 908
 909 /*============================================================================
 910  * Set interrupt mode.
 911  */
 912
 913 static int ppp_set_intr_mode(sdla_t * card, unsigned mode)
 914 {
 915         ppp_mbox_t *mb = card->mbox;
 916         int err;
 917         memset(&mb->cmd, 0, sizeof(ppp_cmd_t));
 918         mb->data[0] = mode;
 919         switch (card->hw.fwid) {
 920         case SFID_PPP502:
 921                 mb->cmd.length = 1;
 922                 break;
 923         case SFID_PPP508:
 924         default:
 925                 mb->data[1] = card->hw.irq;
 926                 mb->cmd.length = 2;
 927         }
 928         mb->cmd.command = PPP_SET_INTR_FLAGS;
 929         err = sdla_exec(mb) ? mb->cmd.result : CMD_TIMEOUT;
 930         if (err != CMD_OK)
 931                 ppp_error(card, err, mb);
 932         return err;
 933 }
 934
 935 /*============================================================================
 936  * Enable communications.
 937  */
 938
 939 static int ppp_comm_enable(sdla_t * card)
 940 {
 941         ppp_mbox_t *mb = card->mbox;
 942         int err;
 943         memset(&mb->cmd, 0, sizeof(ppp_cmd_t));
 944         mb->cmd.command = PPP_COMM_ENABLE;
 945         err = sdla_exec(mb) ? mb->cmd.result : CMD_TIMEOUT;
 946         if (err != CMD_OK)
 947                 ppp_error(card, err, mb);
 948         return err;
 949 }
 950
 951 /*============================================================================
 952  * Disable communications.
 953  */
 954
 955 static int ppp_comm_disable(sdla_t * card)
 956 {
 957         ppp_mbox_t *mb = card->mbox;
 958         int err;
 959         memset(&mb->cmd, 0, sizeof(ppp_cmd_t));
 960         mb->cmd.command = PPP_COMM_DISABLE;
 961         err = sdla_exec(mb) ? mb->cmd.result : CMD_TIMEOUT;
 962         if (err != CMD_OK)
 963                 ppp_error(card, err, mb);
 964         return err;
 965 }
 966
 967 /*============================================================================
 968  * Get communications error statistics.
 969  */
 970
 971 static int ppp_get_err_stats(sdla_t * card)
 972 {
 973         ppp_mbox_t *mb = card->mbox;
 974         int err;
 975         memset(&mb->cmd, 0, sizeof(ppp_cmd_t));
 976         mb->cmd.command = PPP_READ_ERROR_STATS;
 977         err = sdla_exec(mb) ? mb->cmd.result : CMD_TIMEOUT;
 978         if (err == CMD_OK) {
 979                 ppp_err_stats_t *stats = (void *) mb->data;
 980                 card->wandev.stats.rx_over_errors = stats->rx_overrun;
 981                 card->wandev.stats.rx_crc_errors = stats->rx_bad_crc;
 982                 card->wandev.stats.rx_missed_errors = stats->rx_abort;
 983                 card->wandev.stats.rx_length_errors = stats->rx_lost;
 984                 card->wandev.stats.tx_aborted_errors = stats->tx_abort;
 985         } else
 986                 ppp_error(card, err, mb);
 987         return err;
 988 }
 989
 990 /*============================================================================
 991  * Send packet.
 992  *      Return: 0 - o.k.
 993  *              1 - no transmit buffers available
 994  */
 995
 996 static int ppp_send(sdla_t * card, void *data, unsigned len, unsigned proto)
 997 {
 998         ppp_buf_ctl_t *txbuf = card->u.p.txbuf;
 999         unsigned long addr;
1000         if (txbuf->flag)
1001                 return 1
1002                     ;
1003         if (card->hw.fwid == SFID_PPP502)
1004                 addr = (txbuf->buf.o_p[1] << 8) + txbuf->buf.o_p[0];
1005         else
1006                 addr = txbuf->buf.ptr;
1007         sdla_poke(&card->hw, addr, data, len);
1008         txbuf->length = len;    /* frame length */
1009         if (proto == ETH_P_IPX)
1010                 txbuf->proto = 0x01;    /* protocol ID */
1011         txbuf->flag = 1;        /* start transmission */
1012         /* Update transmit buffer control fields */
1013         card->u.p.txbuf = ++txbuf;
1014         if ((void *) txbuf > card->u.p.txbuf_last)
1015                 card->u.p.txbuf = card->u.p.txbuf_base;
1016         return 0;
1017 }
1018
1019 /****** Firmware Error Handler **********************************************/
1020
1021 /*============================================================================
1022  * Firmware error handler.
1023  *      This routine is called whenever firmware command returns non-zero
1024  *      return code.
1025  *
1026  * Return zero if previous command has to be cancelled.
1027  */
1028
1029 static int ppp_error(sdla_t * card, int err, ppp_mbox_t * mb)
1030 {
1031         unsigned cmd = mb->cmd.command;
1032         switch (err) {
1033         case CMD_TIMEOUT:
1034                 printk(KERN_ERR "%s: command 0x%02X timed out!\n",
1035                        card->devname, cmd);
1036                 break;
1037         default:
1038                 printk(KERN_INFO "%s: command 0x%02X returned 0x%02X!\n"
1039                        ,card->devname, cmd, err);
1040         }
1041         return 0;
1042 }
1043
1044 /****** Interrupt Handlers **************************************************/
1045
1046 /*============================================================================
1047  * PPP interrupt service routine.
1048  */
1049
1050 STATIC void wpp_isr(sdla_t * card)
1051 {
1052         ppp_flags_t *flags = card->flags;
1053         char *ptr = &flags->iflag;
1054         unsigned long host_cpu_flags;
1055         struct net_device *dev = card->wandev.dev;
1056         int i;
1057         card->in_isr = 1;
1058         ++card->statistics.isr_entry;
1059         if (test_and_set_bit(0, (void *) &card->wandev.critical)) {
1060                 ++card->statistics.isr_already_critical;
1061                 printk(KERN_INFO "%s: Critical while in ISR!\n", card->devname);
1062                 card->in_isr = 0;
1063                 return;
1064         }
1065         /* For all interrupts set the critical flag to CRITICAL_IN_ISR.
1066          * If the if_send routine is called with this flag set it will set
1067          * the enable transmit flag to 1. (for a delayed interrupt)
1068          */
1069         card->wandev.critical = CRITICAL_IN_ISR;
1070         card->buff_int_mode_unbusy = 0;
1071         switch (flags->iflag) {
1072         case 0x01:              /* receive interrupt */
1073                 ++card->statistics.isr_rx;
1074                 rx_intr(card);
1075                 break;
1076         case 0x02:              /* transmit interrupt */
1077                 ++card->statistics.isr_tx;
1078                 flags->imask &= ~0x02;
1079                 dev->tbusy = 0;
1080                 card->buff_int_mode_unbusy = 1;
1081                 break;
1082         case 0x08:
1083                 ++Intr_test_counter;
1084                 ++card->statistics.isr_intr_test;
1085                 break;
1086         default:                /* unexpected interrupt */
1087                 ++card->statistics.isr_spurious;
1088                 printk(KERN_INFO "%s: spurious interrupt 0x%02X!\n",
1089                        card->devname, flags->iflag);
1090                 printk(KERN_INFO "%s: ID Bytes = ", card->devname);
1091                 for (i = 0; i < 8; i++)
1092                         printk(KERN_INFO "0x%02X ", *(ptr + 0x28 + i));
1093                 printk(KERN_INFO "\n");
1094         }
1095         /* The critical flag is set to CRITICAL_INTR_HANDLED to let the
1096          * if_send call know that the interrupt is handled so that
1097          * transmit interrupts are not enabled again.
1098          */
1099         card->wandev.critical = CRITICAL_INTR_HANDLED;
1100         /* If the enable transmit interrupt flag is set then enable transmit
1101          * interrupt on the board. This only goes through if if_send is called
1102          * and the critical flag is set due to an Interrupt.
1103          */
1104         if (card->wandev.enable_tx_int) {
1105                 flags->imask |= 0x02;
1106                 card->wandev.enable_tx_int = 0;
1107                 ++card->statistics.isr_enable_tx_int;
1108         }
1109         save_flags(host_cpu_flags);
1110         cli();
1111         card->in_isr = 0;
1112         flags->iflag = 0;
1113         card->wandev.critical = 0;
1114         restore_flags(host_cpu_flags);
1115         if (card->buff_int_mode_unbusy)
1116                 mark_bh(NET_BH);
1117 }
1118
1119 /*============================================================================
1120  * Receive interrupt handler.
1121  */
1122
1123 static void rx_intr(sdla_t * card)
1124 {
1125         ppp_buf_ctl_t *rxbuf = card->rxmb;
1126         struct net_device *dev = card->wandev.dev;
1127         ppp_private_area_t *ppp_priv_area;
1128         struct sk_buff *skb;
1129         unsigned len;
1130         void *buf;
1131         int i, err;
1132         ppp_flags_t *flags = card->flags;
1133         char *ptr = &flags->iflag;
1134         int udp_type;
1135         if (rxbuf->flag != 0x01) {
1136                 printk(KERN_INFO
1137                        "%s: corrupted Rx buffer @ 0x%X, flag = 0x%02X!\n",
1138                        card->devname, (unsigned) rxbuf, rxbuf->flag);
1139                 printk(KERN_INFO "%s: ID Bytes = ", card->devname);
1140                 for (i = 0; i < 8; i++)
1141                         printk(KERN_INFO "0x%02X ", *(ptr + 0x28 + i));
1142                 printk(KERN_INFO "\n");
1143                 ++card->statistics.rx_intr_corrupt_rx_bfr;
1144                 return;
1145         }
1146         if (dev && dev->start) {
1147                 len = rxbuf->length;
1148                 ppp_priv_area = dev->priv;
1149                 /* Allocate socket buffer */
1150                 skb = dev_alloc_skb(len);
1151                 if (skb != NULL) {
1152                         /* Copy data to the socket buffer */
1153                         if (card->hw.fwid == SFID_PPP502) {
1154                                 unsigned addr = (rxbuf->buf.o_p[1] << 8) +
1155                                 rxbuf->buf.o_p[0];
1156                                 buf = skb_put(skb, len);
1157                                 sdla_peek(&card->hw, addr, buf, len);
1158                         } else {
1159                                 unsigned addr = rxbuf->buf.ptr;
1160                                 if ((addr + len) > card->u.p.rx_top + 1) {
1161                                         unsigned tmp = card->u.p.rx_top - addr
1162                                         + 1;
1163                                         buf = skb_put(skb, tmp);
1164                                         sdla_peek(&card->hw, addr, buf, tmp);
1165                                         addr = card->u.p.rx_base;
1166                                         len -= tmp;
1167                                 }
1168                                 buf = skb_put(skb, len);
1169                                 sdla_peek(&card->hw, addr, buf, len);
1170                         }
1171                         /* Decapsulate packet */
1172                         switch (rxbuf->proto) {
1173                         case 0x00:
1174                                 skb->protocol = htons(ETH_P_IP);
1175                                 break;
1176                         case 0x01:
1177                                 skb->protocol = htons(ETH_P_IPX);
1178                                 break;
1179                         }
1180                         udp_type = udp_pkt_type(skb, card);
1181                         if (udp_type == UDP_DRVSTATS_TYPE) {
1182                                 ++ppp_priv_area->rx_intr_DRVSTATS_request;
1183                                 process_udp_driver_call(
1184                                           UDP_PKT_FRM_NETWORK, card, skb,
1185                                                      dev, ppp_priv_area);
1186                                 dev_kfree_skb(skb);
1187                         } else if (udp_type == UDP_PTPIPE_TYPE) {
1188                                 ++ppp_priv_area->rx_intr_PTPIPE_request;
1189                                 err = process_udp_mgmt_pkt(
1190                                                UDP_PKT_FRM_NETWORK, card,
1191                                                 skb, dev, ppp_priv_area);
1192                                 dev_kfree_skb(skb);
1193                         } else if (handle_IPXWAN(skb->data, card->devname, card->wandev.enable_IPX, card->wandev.network_number, skb->protocol)) {
1194                                 if (card->wandev.enable_IPX) {
1195                                         ppp_send(card, skb->data, skb->len, ETH_P_IPX);
1196                                         dev_kfree_skb(skb);
1197                                 } else {
1198                                         ++card->wandev.stats.rx_dropped;
1199                                 }
1200                         } else {
1201                                 /* Pass it up the protocol stack */
1202                                 skb->dev = dev;
1203                                 skb->mac.raw = skb->data;
1204                                 netif_rx(skb);
1205                                 ++card->wandev.stats.rx_packets;
1206                                 card->wandev.stats.rx_bytes += skb->len;
1207                                 ++ppp_priv_area->rx_intr_bfr_passed_to_stack;
1208                         }
1209                 } else {
1210                         printk(KERN_INFO "%s: no socket buffers available!\n",
1211                                card->devname);
1212                         ++card->wandev.stats.rx_dropped;
1213                         ++ppp_priv_area->rx_intr_no_socket;
1214                 }
1215         } else
1216                 ++card->statistics.rx_intr_dev_not_started;
1217         /* Release buffer element and calculate a pointer to the next one */
1218         rxbuf->flag = (card->hw.fwid == SFID_PPP502) ? 0xFF : 0x00;
1219         card->rxmb = ++rxbuf;
1220         if ((void *) rxbuf > card->u.p.rxbuf_last)
1221                 card->rxmb = card->u.p.rxbuf_base;
1222 }
1223
1224 /*============================================================================
1225  * Transmit interrupt handler.
1226  */
1227
1228 static void tx_intr(sdla_t * card)
1229 {
1230         struct net_device *dev = card->wandev.dev;
1231         if (!dev || !dev->start) {
1232                 ++card->statistics.tx_intr_dev_not_started;
1233                 return;
1234         }
1235         dev->tbusy = 0;
1236         mark_bh(NET_BH);
1237 }
1238
1239 static int handle_IPXWAN(unsigned char *sendpacket, char *devname, unsigned char enable_IPX, unsigned long network_number, unsigned short proto)
1240 {
1241         int i;
1242         if (proto == htons(ETH_P_IPX)) {
1243                 /* It's an IPX packet */
1244                 if (!enable_IPX) {
1245                         /* Return 1 so we don't pass it up the stack. */
1246                         return 1;
1247                 }
1248         } else {
1249                 /* It's not IPX so pass it up the stack. */
1250                 return 0;
1251         }
1252         if (sendpacket[16] == 0x90 &&
1253             sendpacket[17] == 0x04) {
1254                 /* It's IPXWAN */
1255                 if (sendpacket[2] == 0x02 &&
1256                     sendpacket[34] == 0x00) {
1257                         /* It's a timer request packet */
1258                         printk(KERN_INFO "%s: Received IPXWAN Timer Request packet\n", devname);
1259                         /* Go through the routing options and answer no to every */
1260                         /* option except Unnumbered RIP/SAP */
1261                         for (i = 41; sendpacket[i] == 0x00; i += 5) {
1262                                 /* 0x02 is the option for Unnumbered RIP/SAP */
1263                                 if (sendpacket[i + 4] != 0x02) {
1264                                         sendpacket[i + 1] = 0;
1265                                 }
1266                         }
1267                         /* Skip over the extended Node ID option */
1268                         if (sendpacket[i] == 0x04) {
1269                                 i += 8;
1270                         }
1271                         /* We also want to turn off all header compression opt. */
1272                         for (; sendpacket[i] == 0x80;) {
1273                                 sendpacket[i + 1] = 0;
1274                                 i += (sendpacket[i + 2] << 8) + (sendpacket[i + 3]) + 4;
1275                         }
1276                         /* Set the packet type to timer response */
1277                         sendpacket[34] = 0x01;
1278                         printk(KERN_INFO "%s: Sending IPXWAN Timer Response\n", devname);
1279                 } else if (sendpacket[34] == 0x02) {
1280                         /* This is an information request packet */
1281                         printk(KERN_INFO "%s: Received IPXWAN Information Request packet\n", devname);
1282                         /* Set the packet type to information response */
1283                         sendpacket[34] = 0x03;
1284                         /* Set the router name */
1285                         sendpacket[51] = 'P';
1286                         sendpacket[52] = 'T';
1287                         sendpacket[53] = 'P';
1288                         sendpacket[54] = 'I';
1289                         sendpacket[55] = 'P';
1290                         sendpacket[56] = 'E';
1291                         sendpacket[57] = '-';
1292                         sendpacket[58] = CVHexToAscii(network_number >> 28);
1293                         sendpacket[59] = CVHexToAscii((network_number & 0x0F000000) >> 24);
1294                         sendpacket[60] = CVHexToAscii((network_number & 0x00F00000) >> 20);
1295                         sendpacket[61] = CVHexToAscii((network_number & 0x000F0000) >> 16);
1296                         sendpacket[62] = CVHexToAscii((network_number & 0x0000F000) >> 12);
1297                         sendpacket[63] = CVHexToAscii((network_number & 0x00000F00) >> 8);
1298                         sendpacket[64] = CVHexToAscii((network_number & 0x000000F0) >> 4);
1299                         sendpacket[65] = CVHexToAscii(network_number & 0x0000000F);
1300                         for (i = 66; i < 99; i += 1)
1301                                 sendpacket[i] = 0;
1302                         printk(KERN_INFO "%s: Sending IPXWAN Information Response packet\n", devname);
1303                 } else {
1304                         printk(KERN_INFO "%s: Unknown IPXWAN packet!\n", devname);
1305                         return 0;
1306                 }
1307                 /* Set the WNodeID to our network address */
1308                 sendpacket[35] = (unsigned char) (network_number >> 24);
1309                 sendpacket[36] = (unsigned char) ((network_number & 0x00FF0000) >> 16);
1310                 sendpacket[37] = (unsigned char) ((network_number & 0x0000FF00) >> 8);
1311                 sendpacket[38] = (unsigned char) (network_number & 0x000000FF);
1312                 return 1;
1313         } else {
1314                 /* If we get here's its an IPX-data packet, so it'll get passed up the stack. */
1315                 /* switch the network numbers */
1316                 switch_net_numbers(sendpacket, network_number, 1);
1317                 return 0;
1318         }
1319 }
1320
1321 /****** Background Polling Routines  ****************************************/
1322
1323 /*============================================================================
1324  * Main polling routine.
1325  * This routine is repeatedly called by the WANPIPE 'thread' to allow for
1326  * time-dependent housekeeping work.
1327  *
1328  * Notes:
1329  * 1. This routine may be called on interrupt context with all interrupts
1330  *    enabled. Beware!
1331  */
1332
1333 static void wpp_poll(sdla_t * card)
1334 {
1335         struct net_device *dev = card->wandev.dev;
1336         ppp_flags_t *adptr_flags = card->flags;
1337         unsigned long host_cpu_flags;
1338         ++card->statistics.poll_entry;
1339         /* The wpp_poll is called continously by the WANPIPE thread to allow
1340          * for line state housekeeping. However if we are in a connected state
1341          * then we do not need to go through all the checks everytime. When in
1342          * connected state execute wpp_poll once every second.
1343          */
1344         if (card->wandev.state == WAN_CONNECTED) {
1345                 if ((jiffies - card->state_tick) < HZ)
1346                         return;
1347         }
1348         disable_irq(card->hw.irq);
1349         ++card->irq_dis_poll_count;
1350         if (test_and_set_bit(0, (void *) &card->wandev.critical)) {
1351                 ++card->statistics.poll_already_critical;
1352                 printk(KERN_INFO "%s: critical inside wpp_poll\n",
1353                        card->devname);
1354                 save_flags(host_cpu_flags);
1355                 cli();
1356                 if ((!card->irq_dis_if_send_count) &&
1357                     (!(--card->irq_dis_poll_count)))
1358                         enable_irq(card->hw.irq);
1359                 restore_flags(host_cpu_flags);
1360                 return;
1361         }
1362         ++card->statistics.poll_processed;
1363         if (dev && dev->tbusy && !(adptr_flags->imask & 0x02)) {
1364                 ++card->statistics.poll_tbusy_bad_status;
1365                 printk(KERN_INFO "%s: Wpp_Poll: tbusy = 0x01, imask = 0x%02X\n"
1366                        ,card->devname, adptr_flags->imask);
1367         }
1368         switch (card->wandev.state) {
1369         case WAN_CONNECTED:
1370                 card->state_tick = jiffies;
1371                 poll_active(card);
1372                 break;
1373         case WAN_CONNECTING:
1374                 poll_connecting(card);
1375                 break;
1376         case WAN_DISCONNECTED:
1377                 poll_disconnected(card);
1378                 break;
1379         default:
1380                 printk(KERN_INFO "%s: Unknown Poll State 0x%02X\n",
1381                        card->devname, card->wandev.state);
1382                 break;
1383         }
1384         card->wandev.critical = 0;
1385         save_flags(host_cpu_flags);
1386         cli();
1387         if ((!card->irq_dis_if_send_count) && (!(--card->irq_dis_poll_count)))
1388                 enable_irq(card->hw.irq);
1389         restore_flags(host_cpu_flags);
1390 }
1391
1392 /*============================================================================
1393  * Monitor active link phase.
1394  */
1395
1396 static void poll_active(sdla_t * card)
1397 {
1398         ppp_flags_t *flags = card->flags;
1399         /* We check the lcp_state to see if we are in DISCONNECTED state.
1400          * We are considered to be connected for lcp states 0x06, 0x07, 0x08
1401          * and 0x09.
1402          */
1403         if ((flags->lcp_state <= 0x05) || (flags->disc_cause & 0x03)) {
1404                 wanpipe_set_state(card, WAN_DISCONNECTED);
1405                 show_disc_cause(card, flags->disc_cause);
1406         }
1407 }
1408
1409 /*============================================================================
1410  * Monitor link establishment phase.
1411  * o if connection timed out, disconnect the link.
1412  */
1413
1414 static void poll_connecting(sdla_t * card)
1415 {
1416         ppp_flags_t *flags = card->flags;
1417         if (flags->lcp_state == 0x09) {
1418                 wanpipe_set_state(card, WAN_CONNECTED);
1419         } else if (flags->disc_cause & 0x03) {
1420                 wanpipe_set_state(card, WAN_DISCONNECTED);
1421                 show_disc_cause(card, flags->disc_cause);
1422         }
1423 }
1424
1425 /*============================================================================
1426  * Monitor physical link disconnected phase.
1427  *  o if interface is up and the hold-down timeout has expired, then retry
1428  *    connection.
1429  */
1430
1431 static void poll_disconnected(sdla_t * card)
1432 {
1433         struct net_device *dev = card->wandev.dev;
1434         if (dev && dev->start &&
1435             ((jiffies - card->state_tick) > HOLD_DOWN_TIME)) {
1436                 wanpipe_set_state(card, WAN_CONNECTING);
1437                 if (ppp_comm_enable(card) == CMD_OK)
1438                         init_ppp_tx_rx_buff(card);
1439         }
1440 }
1441
1442 /****** Miscellaneous Functions *********************************************/
1443
1444 /*============================================================================
1445  * Configure S502 adapter.
1446  */
1447
1448 static int config502(sdla_t * card)
1449 {
1450         ppp502_conf_t cfg;
1451         /* Prepare PPP configuration structure */
1452         memset(&cfg, 0, sizeof(ppp502_conf_t));
1453         if (card->wandev.clocking)
1454                 cfg.line_speed = bps_to_speed_code(card->wandev.bps);
1455         cfg.txbuf_num = 4;
1456         cfg.mtu_local = card->wandev.mtu;
1457         cfg.mtu_remote = card->wandev.mtu;
1458         cfg.restart_tmr = 30;
1459         cfg.auth_rsrt_tmr = 30;
1460         cfg.auth_wait_tmr = 300;
1461         cfg.mdm_fail_tmr = 5;
1462         cfg.dtr_drop_tmr = 1;
1463         cfg.connect_tmout = 0;  /* changed it from 900 */
1464         cfg.conf_retry = 10;
1465         cfg.term_retry = 2;
1466         cfg.fail_retry = 5;
1467         cfg.auth_retry = 10;
1468         cfg.ip_options = 0x80;
1469         cfg.ipx_options = 0xA0;
1470         cfg.conf_flags |= 0x0E;
1471 /*
1472    cfg.ip_local         = dev->pa_addr;
1473    cfg.ip_remote                = dev->pa_dstaddr;
1474  */
1475         return ppp_configure(card, &cfg);
1476 }
1477
1478 /*============================================================================
1479  * Configure S508 adapter.
1480  */
1481
1482 static int config508(sdla_t * card)
1483 {
1484         ppp508_conf_t cfg;
1485         /* Prepare PPP configuration structure */
1486         memset(&cfg, 0, sizeof(ppp508_conf_t));
1487         if (card->wandev.clocking)
1488                 cfg.line_speed = card->wandev.bps;
1489         if (card->wandev.interface == WANOPT_RS232)
1490                 cfg.conf_flags |= 0x0020;
1491         cfg.conf_flags |= 0x300;        /*send Configure-Request packets forever */
1492         cfg.txbuf_percent = 60; /* % of Tx bufs */
1493         cfg.mtu_local = card->wandev.mtu;
1494         cfg.mtu_remote = card->wandev.mtu;
1495         cfg.restart_tmr = 30;
1496         cfg.auth_rsrt_tmr = 30;
1497         cfg.auth_wait_tmr = 300;
1498         cfg.mdm_fail_tmr = 100;
1499         cfg.dtr_drop_tmr = 1;
1500         cfg.connect_tmout = 0;  /* changed it from 900 */
1501         cfg.conf_retry = 10;
1502         cfg.term_retry = 2;
1503         cfg.fail_retry = 5;
1504         cfg.auth_retry = 10;
1505         cfg.ip_options = 0x80;
1506         cfg.ipx_options = 0xA0;
1507 /*
1508    cfg.ip_local         = dev->pa_addr;
1509    cfg.ip_remote                = dev->pa_dstaddr;
1510  */
1511         return ppp_configure(card, &cfg);
1512 }
1513
1514 /*============================================================================
1515  * Show disconnection cause.
1516  */
1517
1518 static void show_disc_cause(sdla_t * card, unsigned cause)
1519 {
1520         if (cause & 0x0002)
1521                 printk(KERN_INFO "%s: link terminated by peer\n",
1522                        card->devname);
1523         else if (cause & 0x0004)
1524                 printk(KERN_INFO "%s: link terminated by user\n",
1525                        card->devname);
1526         else if (cause & 0x0008)
1527                 printk(KERN_INFO "%s: authentication failed\n", card->devname);
1528         else if (cause & 0x0010)
1529                 printk(KERN_INFO
1530                        "%s: authentication protocol negotiation failed\n",
1531                        card->devname);
1532         else if (cause & 0x0020)
1533                 printk(KERN_INFO
1534                        "%s: peer's request for authentication rejected\n",
1535                        card->devname);
1536         else if (cause & 0x0040)
1537                 printk(KERN_INFO "%s: MRU option rejected by peer\n",
1538                        card->devname);
1539         else if (cause & 0x0080)
1540                 printk(KERN_INFO "%s: peer's MRU was too small\n",
1541                        card->devname);
1542         else if (cause & 0x0100)
1543                 printk(KERN_INFO "%s: failed to negotiate peer's LCP options\n",
1544                        card->devname);
1545         else if (cause & 0x0200)
1546                 printk(KERN_INFO "%s: failed to negotiate peer's IPCP options\n"
1547                        ,card->devname);
1548         else if (cause & 0x0400)
1549                 printk(KERN_INFO
1550                        "%s: failed to negotiate peer's IPXCP options\n",
1551                        card->devname);
1552 }
1553
1554 /*============================================================================
1555  * Convert line speed in bps to a number used by S502 code.
1556  */
1557
1558 static unsigned char bps_to_speed_code(unsigned long bps)
1559 {
1560         unsigned char number;
1561         if (bps <= 1200)
1562                 number = 0x01;
1563         else if (bps <= 2400)
1564                 number = 0x02;
1565         else if (bps <= 4800)
1566                 number = 0x03;
1567         else if (bps <= 9600)
1568                 number = 0x04;
1569         else if (bps <= 19200)
1570                 number = 0x05;
1571         else if (bps <= 38400)
1572                 number = 0x06;
1573         else if (bps <= 45000)
1574                 number = 0x07;
1575         else if (bps <= 56000)
1576                 number = 0x08;
1577         else if (bps <= 64000)
1578                 number = 0x09;
1579         else if (bps <= 74000)
1580                 number = 0x0A;
1581         else if (bps <= 112000)
1582                 number = 0x0B;
1583         else if (bps <= 128000)
1584                 number = 0x0C;
1585         else
1586                 number = 0x0D;
1587         return number;
1588 }
1589
1590 /*============================================================================
1591  * Process UDP call of type DRVSTATS.
1592  */
1593
1594 static int process_udp_driver_call(char udp_pkt_src, sdla_t * card, struct sk_buff *skb, struct net_device *dev, ppp_private_area_t * ppp_priv_area)
1595 {
1596         unsigned char *sendpacket;
1597         unsigned char buf2[5];
1598         unsigned char *data;
1599         unsigned char *buf;
1600         unsigned int len;
1601         ppp_mbox_t *mbox = card->mbox;
1602         struct sk_buff *new_skb;
1603         int err;
1604         sendpacket = skb->data;
1605         memcpy(&buf2, &card->wandev.udp_port, 2);
1606         if ((data = kmalloc(2000, GFP_ATOMIC)) == NULL) {
1607                 printk(KERN_INFO
1608                        "%s: Error allocating memory for UDP DRIVER STATS cmnd0x%02X"
1609                        ,card->devname, data[45]);
1610                 ++ppp_priv_area->UDP_DRVSTATS_mgmt_kmalloc_err;
1611                 return 1;
1612         }
1613         memcpy(data, sendpacket, skb->len);
1614         switch (data[45]) {
1615                 /* PPIPE_DRIVER_STATISTICS */
1616         case 0x26:
1617                 *(unsigned long *) &data[60] =
1618                     ppp_priv_area->if_send_entry;
1619                 *(unsigned long *) &data[64] =
1620                     ppp_priv_area->if_send_skb_null;
1621                 *(unsigned long *) &data[68] =
1622                     ppp_priv_area->if_send_broadcast;
1623                 *(unsigned long *) &data[72] =
1624                     ppp_priv_area->if_send_multicast;
1625                 *(unsigned long *) &data[76] =
1626                     ppp_priv_area->if_send_critical_ISR;
1627                 *(unsigned long *) &data[80] =
1628                     ppp_priv_area->if_send_critical_non_ISR;
1629                 *(unsigned long *) &data[84] =
1630                     ppp_priv_area->if_send_busy;
1631                 *(unsigned long *) &data[88] =
1632                     ppp_priv_area->if_send_busy_timeout;
1633                 *(unsigned long *) &data[92] =
1634                     ppp_priv_area->if_send_DRVSTATS_request;
1635                 *(unsigned long *) &data[96] =
1636                     ppp_priv_area->if_send_PTPIPE_request;
1637                 *(unsigned long *) &data[100] =
1638                     ppp_priv_area->if_send_wan_disconnected;
1639                 *(unsigned long *) &data[104] =
1640                     ppp_priv_area->if_send_adptr_bfrs_full;
1641                 *(unsigned long *) &data[108] =
1642                     ppp_priv_area->if_send_protocol_error;
1643                 *(unsigned long *) &data[112] =
1644                     ppp_priv_area->if_send_tx_int_enabled;
1645                 *(unsigned long *) &data[116] =
1646                     ppp_priv_area->if_send_bfr_passed_to_adptr;
1647                 *(unsigned long *) &data[118] =
1648                     card->irq_dis_if_send_count;
1649                 mbox->cmd.length = 62;
1650                 break;
1651         case 0x27:
1652                 *(unsigned long *) &data[60] = card->statistics.isr_entry;
1653                 *(unsigned long *) &data[64] =
1654                     card->statistics.isr_already_critical;
1655                 *(unsigned long *) &data[68] = card->statistics.isr_rx;
1656                 *(unsigned long *) &data[72] = card->statistics.isr_tx;
1657                 *(unsigned long *) &data[76] =
1658                     card->statistics.isr_intr_test;
1659                 *(unsigned long *) &data[80] =
1660                     card->statistics.isr_spurious;
1661                 *(unsigned long *) &data[84] =
1662                     card->statistics.isr_enable_tx_int;
1663                 *(unsigned long *) &data[88] =
1664                     card->statistics.rx_intr_corrupt_rx_bfr;
1665                 *(unsigned long *) &data[92] =
1666                     ppp_priv_area->rx_intr_no_socket;
1667                 *(unsigned long *) &data[96] =
1668                     ppp_priv_area->rx_intr_DRVSTATS_request;
1669                 *(unsigned long *) &data[100] =
1670                     ppp_priv_area->rx_intr_PTPIPE_request;
1671                 *(unsigned long *) &data[104] =
1672                     ppp_priv_area->rx_intr_bfr_passed_to_stack;
1673                 *(unsigned long *) &data[108] =
1674                     card->statistics.rx_intr_dev_not_started;
1675                 *(unsigned long *) &data[112] =
1676                     card->statistics.tx_intr_dev_not_started;
1677                 mbox->cmd.length = 56;
1678                 break;
1679         case 0x28:
1680                 *(unsigned long *) &data[60] =
1681                     ppp_priv_area->UDP_PTPIPE_mgmt_kmalloc_err;
1682                 *(unsigned long *) &data[64] =
1683                     ppp_priv_area->UDP_PTPIPE_mgmt_adptr_type_err;
1684                 *(unsigned long *) &data[68] =
1685                     ppp_priv_area->UDP_PTPIPE_mgmt_direction_err;
1686                 *(unsigned long *) &data[72] =
1687                     ppp_priv_area->
1688                     UDP_PTPIPE_mgmt_adptr_cmnd_timeout;
1689                 *(unsigned long *) &data[76] =
1690                     ppp_priv_area->UDP_PTPIPE_mgmt_adptr_cmnd_OK;
1691                 *(unsigned long *) &data[80] =
1692                     ppp_priv_area->UDP_PTPIPE_mgmt_passed_to_adptr;
1693                 *(unsigned long *) &data[84] =
1694                     ppp_priv_area->UDP_PTPIPE_mgmt_passed_to_stack;
1695                 *(unsigned long *) &data[88] =
1696                     ppp_priv_area->UDP_PTPIPE_mgmt_no_socket;
1697                 *(unsigned long *) &data[92] =
1698                     ppp_priv_area->UDP_DRVSTATS_mgmt_kmalloc_err;
1699                 *(unsigned long *) &data[96] =
1700                     ppp_priv_area->
1701                     UDP_DRVSTATS_mgmt_adptr_cmnd_timeout;
1702                 *(unsigned long *) &data[100] =
1703                     ppp_priv_area->UDP_DRVSTATS_mgmt_adptr_cmnd_OK;
1704                 *(unsigned long *) &data[104] =
1705                     ppp_priv_area->
1706                     UDP_DRVSTATS_mgmt_passed_to_adptr;
1707                 *(unsigned long *) &data[108] =
1708                     ppp_priv_area->
1709                     UDP_DRVSTATS_mgmt_passed_to_stack;
1710                 *(unsigned long *) &data[112] =
1711                     ppp_priv_area->UDP_DRVSTATS_mgmt_no_socket;
1712                 *(unsigned long *) &data[116] =
1713                     card->statistics.poll_entry;
1714                 *(unsigned long *) &data[120] =
1715                     card->statistics.poll_already_critical;
1716                 *(unsigned long *) &data[124] =
1717                     card->statistics.poll_processed;
1718                 *(unsigned long *) &data[126] =
1719                     card->irq_dis_poll_count;
1720                 mbox->cmd.length = 70;
1721                 break;
1722         default:
1723                 /* it's a board command */
1724                 memcpy(&mbox->cmd, &sendpacket[45], sizeof(ppp_cmd_t));
1725                 if (mbox->cmd.length) {
1726                         memcpy(&mbox->data, &sendpacket[60],
1727                                mbox->cmd.length);
1728                 }
1729                 /* run the command on the board */
1730                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
1731                 if (err != CMD_OK) {
1732                         ppp_error(card, err, mbox);
1733                         ++ppp_priv_area->
1734                             UDP_DRVSTATS_mgmt_adptr_cmnd_timeout;
1735                         break;
1736                 }
1737                 ++ppp_priv_area->UDP_DRVSTATS_mgmt_adptr_cmnd_OK;
1738                 /* copy the result back to our buffer */
1739                 memcpy(data, sendpacket, skb->len);
1740                 memcpy(&data[45], &mbox->cmd, sizeof(ppp_cmd_t));
1741                 if (mbox->cmd.length) {
1742                         memcpy(&data[60], &mbox->data, mbox->cmd.length);
1743                 }
1744         }
1745         /* Fill UDP TTL */
1746         data[8] = card->wandev.ttl;
1747         len = reply_udp(data, mbox->cmd.length);
1748         if (udp_pkt_src == UDP_PKT_FRM_NETWORK) {
1749                 ++ppp_priv_area->UDP_DRVSTATS_mgmt_passed_to_adptr;
1750                 ppp_send(card, data, len, skb->protocol);
1751         } else {
1752                 /* Pass it up the stack
1753                    Allocate socket buffer */
1754                 if ((new_skb = dev_alloc_skb(len)) != NULL) {
1755                         /* copy data into new_skb */
1756                         buf = skb_put(new_skb, len);
1757                         memcpy(buf, data, len);
1758                         ++ppp_priv_area->UDP_DRVSTATS_mgmt_passed_to_stack;
1759                         /* Decapsulate packet and pass it up the protocol
1760                            stack */
1761                         new_skb->protocol = htons(ETH_P_IP);
1762                         new_skb->dev = dev;
1763                         new_skb->mac.raw = new_skb->data;
1764                         netif_rx(new_skb);
1765                 } else {
1766                         ++ppp_priv_area->UDP_DRVSTATS_mgmt_no_socket;
1767                         printk(KERN_INFO "no socket buffers available!\n");
1768                 }
1769         }
1770         kfree(data);
1771         return 0;
1772 }
1773
1774 /*=============================================================================
1775  * Process UDP call of type PTPIPEAB.
1776  */
1777
1778 static int process_udp_mgmt_pkt(char udp_pkt_src, sdla_t * card,
1779                                 struct sk_buff *skb, struct net_device *dev,
1780                                 ppp_private_area_t * ppp_priv_area)
1781 {
1782         unsigned char *sendpacket;
1783         unsigned char buf2[5];
1784         unsigned char *data;
1785         unsigned char *buf;
1786         unsigned int frames, len;
1787         struct sk_buff *new_skb;
1788         unsigned short buffer_length, real_len;
1789         unsigned long data_ptr;
1790         int udp_mgmt_req_valid = 1;
1791         ppp_mbox_t *mbox = card->mbox;
1792         struct timeval tv;
1793         int err;
1794         sendpacket = skb->data;
1795         memcpy(&buf2, &card->wandev.udp_port, 2);
1796         if ((data = kmalloc(2000, GFP_ATOMIC)) == NULL) {
1797                 printk(KERN_INFO
1798                        "%s: Error allocating memory for UDP management cmnd0x%02X"
1799                        ,card->devname, data[45]);
1800                 ++ppp_priv_area->UDP_PTPIPE_mgmt_kmalloc_err;
1801                 return 1;
1802         }
1803         memcpy(data, sendpacket, skb->len);
1804         switch (data[45]) {
1805                 /* FT1 MONITOR STATUS */
1806         case 0x80:
1807                 if (card->hw.fwid != SFID_PPP508) {
1808                         ++ppp_priv_area->UDP_PTPIPE_mgmt_adptr_type_err;
1809                         udp_mgmt_req_valid = 0;
1810                         break;
1811                 }
1812                 /* PPIPE_ENABLE_TRACING */
1813         case 0x20:
1814                 /* PPIPE_DISABLE_TRACING */
1815         case 0x21:
1816                 /* PPIPE_GET_TRACE_INFO */
1817         case 0x22:
1818                 /* SET FT1 MODE */
1819         case 0x81:
1820                 if (udp_pkt_src == UDP_PKT_FRM_NETWORK) {
1821                         ++ppp_priv_area->UDP_PTPIPE_mgmt_direction_err;
1822                         udp_mgmt_req_valid = 0;
1823                 }
1824                 break;
1825         default:
1826                 break;
1827         }
1828         if (!udp_mgmt_req_valid) {
1829                 /* set length to 0 */
1830                 data[46] = data[47] = 0;
1831                 /* set return code */
1832                 data[48] = 0xCD;
1833         } else {
1834                 switch (data[45]) {
1835                         /* PPIPE_ENABLE_TRACING */
1836                 case 0x20:
1837                         if (!TracingEnabled) {
1838                                 /* OPERATE_DATALINE_MONITOR */
1839                                 mbox->cmd.command = 0x33;
1840                                 mbox->cmd.length = 1;
1841                                 mbox->data[0] = 0x03;
1842                                 err = sdla_exec(mbox) ?
1843                                     mbox->cmd.result : CMD_TIMEOUT;
1844                                 if (err != CMD_OK) {
1845                                         ppp_error(card, err, mbox);
1846                                         TracingEnabled = 0;
1847                                         /* set the return code */
1848                                         data[48] = mbox->cmd.result;
1849                                         mbox->cmd.length = 0;
1850                                         break;
1851                                 }
1852                                 if (card->hw.fwid == SFID_PPP502) {
1853                                         sdla_peek(&card->hw, 0x9000, &buf2, 2);
1854                                 } else {
1855                                         sdla_peek(&card->hw, 0xC000, &buf2, 2);
1856                                 }
1857                                 curr_trace_addr = 0;
1858                                 memcpy(&curr_trace_addr, &buf2, 2);
1859                                 start_trace_addr = curr_trace_addr;
1860                                 /* MAX_SEND_BUFFER_SIZE -sizeof(UDP_MGMT_PACKET)
1861                                    - 41 */
1862                                 available_buffer_space = 1926;
1863                         }
1864                         data[48] = 0;
1865                         mbox->cmd.length = 0;
1866                         TracingEnabled = 1;
1867                         break;
1868                         /* PPIPE_DISABLE_TRACING */
1869                 case 0x21:
1870                         if (TracingEnabled) {
1871                                 /* OPERATE_DATALINE_MONITOR */
1872                                 mbox->cmd.command = 0x3;
1873                                 mbox->cmd.length = 1;
1874                                 mbox->data[0] = 0x00;
1875                                 err = sdla_exec(mbox) ?
1876                                     mbox->cmd.result : CMD_TIMEOUT;
1877                         }
1878                         /*set return code */
1879                         data[48] = 0;
1880                         mbox->cmd.length = 0;
1881                         TracingEnabled = 0;
1882                         break;
1883                         /* PPIPE_GET_TRACE_INFO */
1884                 case 0x22:
1885                         if (TracingEnabled) {
1886                                 buffer_length = 0;
1887                                 /* frames < NUM_TRACE_FRAMES */
1888                                 for (frames = 0; frames < 62; frames += 1) {
1889                                         sdla_peek(&card->hw, curr_trace_addr,
1890                                                   &buf2, 1);
1891                                         /* no data on board so exit */
1892                                         if (buf2[0] == 0x00)
1893                                                 break;
1894                                         /*1+sizeof(FRAME_DATA) = 9 */
1895                                         if ((available_buffer_space -
1896                                              buffer_length) < 9) {
1897                                                 /*indicate we have more frames
1898                                                    on board and exit */
1899                                                 data[60] |= 0x02;
1900                                                 break;
1901                                         }
1902                                         /* get frame status */
1903                                         sdla_peek(&card->hw, curr_trace_addr +
1904                                                   0x01, &data[60 + buffer_length], 1);
1905                                         /* get time stamp */
1906                                         sdla_peek(&card->hw, curr_trace_addr +
1907                                                   0x06, &data[64 + buffer_length], 2);
1908                                         /* get frame length */
1909                                         sdla_peek(&card->hw, curr_trace_addr +
1910                                                   0x02, &data[62 + buffer_length], 2);
1911                                         /* get pointer to real data */
1912                                         sdla_peek(&card->hw, curr_trace_addr +
1913                                                   0x04, &buf2, 2);
1914                                         data_ptr = 0;
1915                                         memcpy(&data_ptr, &buf2, 2);
1916                                         /* see if we can fit the frame into the
1917                                            user buffer */
1918                                         memcpy(&real_len,
1919                                            &data[62 + buffer_length], 2);
1920                                         if ((data_ptr == 0) ||
1921                                             ((real_len + 8) >
1922                                              available_buffer_space)) {
1923                                                 data[61 + buffer_length] = 0x00;
1924                                         } else {
1925                                                 /* we can take it next time */
1926                                                 if ((available_buffer_space -
1927                                                      buffer_length) <
1928                                                     (real_len + 8)) {
1929                                                         data[60] |= 0x02;
1930                                                         break;
1931                                                 }
1932                                                 /* ok, get the frame */
1933                                                 data[61 + buffer_length] = 0x01;
1934                                                 /* get the data */
1935                                                 sdla_peek(&card->hw, data_ptr,
1936                                                 &data[66 + buffer_length],
1937                                                           real_len);
1938                                                 /* zero the opp flag to
1939                                                    show we got the frame */
1940                                                 buf2[0] = 0x00;
1941                                                 sdla_poke(&card->hw,
1942                                                           curr_trace_addr, &buf2, 1);
1943                                                 /* now move onto the next
1944                                                    frame */
1945                                                 curr_trace_addr += 8;
1946                                                 /* check if we passed the last
1947                                                    address */
1948                                                 if (curr_trace_addr >=
1949                                                     start_trace_addr + 0x1F0) {
1950                                                         curr_trace_addr =
1951                                                             start_trace_addr;
1952                                                 }
1953                                                 /* update buffer length and make                                                   sure its even */
1954                                                 if (data[61 + buffer_length]
1955                                                     == 0x01) {
1956                                                         buffer_length +=
1957                                                             real_len - 1;
1958                                                 }
1959                                                 /* for the header */
1960                                                 buffer_length += 8;
1961                                                 if (buffer_length & 0x0001)
1962                                                         buffer_length += 1;
1963                                         }
1964                                 }
1965                                 /* ok now set the total number of frames passed
1966                                    in the high 5 bits */
1967                                 data[60] = (frames << 2) | data[60];
1968                                 /* set the data length */
1969                                 mbox->cmd.length = buffer_length;
1970                                 memcpy(&data[46], &buffer_length, 2);
1971                                 /* set return code */
1972                                 data[48] = 0;
1973                         } else {
1974                                 /* set return code */
1975                                 data[48] = 1;
1976                                 mbox->cmd.length = 0;
1977                         }
1978                         break;
1979                         /* PPIPE_GET_IBA_DATA */
1980                 case 0x23:
1981                         mbox->cmd.length = 0x09;
1982                         if (card->hw.fwid == SFID_PPP502) {
1983                                 sdla_peek(&card->hw, 0xA003, &data[60],
1984                                           mbox->cmd.length);
1985                         } else {
1986                                 sdla_peek(&card->hw, 0xF003, &data[60],
1987                                           mbox->cmd.length);
1988                         }
1989                         /* set the length of the data */
1990                         data[46] = 0x09;
1991                         /* set return code */
1992                         data[48] = 0x00;
1993                         break;
1994                         /* PPIPE_KILL_BOARD */
1995                 case 0x24:
1996                         break;
1997                         /* PPIPE_FT1_READ_STATUS */
1998                 case 0x25:
1999                         sdla_peek(&card->hw, 0xF020, &data[60], 2);
2000                         data[46] = 2;
2001                         data[47] = 0;
2002                         data[48] = 0;
2003                         mbox->cmd.length = 2;
2004                         break;
2005                 case 0x29:
2006                         init_ppp_priv_struct(ppp_priv_area);
2007                         init_global_statistics(card);
2008                         mbox->cmd.length = 0;
2009                         break;
2010                 case 0x30:
2011                         do_gettimeofday(&tv);
2012                         ppp_priv_area->router_up_time = tv.tv_sec -
2013                             ppp_priv_area->router_start_time;
2014                         *(unsigned long *) &data[60] =
2015                             ppp_priv_area->router_up_time;
2016                         mbox->cmd.length = 4;
2017                         break;
2018                         /* FT1 MONITOR STATUS */
2019                 case 0x80:
2020                         /* Enable FT1 MONITOR STATUS */
2021                         if (data[60] == 1) {
2022                                 if (rCount++ != 0) {
2023                                         data[48] = 0;
2024                                         mbox->cmd.length = 1;
2025                                         break;
2026                                 }
2027                         }
2028                         /* Disable FT1 MONITOR STATUS */
2029                         if (data[60] == 0) {
2030                                 if (--rCount != 0) {
2031                                         data[48] = 0;
2032                                         mbox->cmd.length = 1;
2033                                         break;
2034                                 }
2035                         }
2036                 default:
2037                         /* it's a board command */
2038                         memcpy(&mbox->cmd, &sendpacket[45], sizeof(ppp_cmd_t));
2039                         if (mbox->cmd.length) {
2040                                 memcpy(&mbox->data, &sendpacket[60],
2041                                        mbox->cmd.length);
2042                         }
2043                         /* run the command on the board */
2044                         err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2045                         if (err != CMD_OK) {
2046                                 ppp_error(card, err, mbox);
2047                                 ++ppp_priv_area->
2048                                     UDP_PTPIPE_mgmt_adptr_cmnd_timeout;
2049                                 break;
2050                         }
2051                         ++ppp_priv_area->UDP_PTPIPE_mgmt_adptr_cmnd_OK;
2052                         /* copy the result back to our buffer */
2053                         memcpy(data, sendpacket, skb->len);
2054                         memcpy(&data[45], &mbox->cmd, sizeof(ppp_cmd_t));
2055                         if (mbox->cmd.length) {
2056                                 memcpy(&data[60], &mbox->data, mbox->cmd.length);
2057                         }
2058                 }               /* end of switch */
2059         }                       /* end of else */
2060         /* Fill UDP TTL */
2061         data[8] = card->wandev.ttl;
2062         len = reply_udp(data, mbox->cmd.length);
2063         if (udp_pkt_src == UDP_PKT_FRM_NETWORK) {
2064                 ++ppp_priv_area->UDP_PTPIPE_mgmt_passed_to_adptr;
2065                 ppp_send(card, data, len, skb->protocol);
2066         } else {
2067                 /* Pass it up the stack
2068                    Allocate socket buffer */
2069                 if ((new_skb = dev_alloc_skb(len)) != NULL) {
2070                         /* copy data into new_skb */
2071                         buf = skb_put(new_skb, len);
2072                         memcpy(buf, data, len);
2073                         ++ppp_priv_area->UDP_PTPIPE_mgmt_passed_to_stack;
2074                         /* Decapsulate packet and pass it up the protocol
2075                            stack */
2076                         new_skb->protocol = htons(ETH_P_IP);
2077                         new_skb->dev = dev;
2078                         new_skb->mac.raw = new_skb->data;
2079                         netif_rx(new_skb);
2080                 } else {
2081                         ++ppp_priv_area->UDP_PTPIPE_mgmt_no_socket;
2082                         printk(KERN_INFO "no socket buffers available!\n");
2083                 }
2084         }
2085         kfree(data);
2086         return 0;
2087 }
2088
2089 /*=============================================================================
2090  * Initial the ppp_private_area structure.
2091  */
2092
2093 static void init_ppp_priv_struct(ppp_private_area_t * ppp_priv_area)
2094 {
2095         ppp_priv_area->if_send_entry = 0;
2096         ppp_priv_area->if_send_skb_null = 0;
2097         ppp_priv_area->if_send_broadcast = 0;
2098         ppp_priv_area->if_send_multicast = 0;
2099         ppp_priv_area->if_send_critical_ISR = 0;
2100         ppp_priv_area->if_send_critical_non_ISR = 0;
2101         ppp_priv_area->if_send_busy = 0;
2102         ppp_priv_area->if_send_busy_timeout = 0;
2103         ppp_priv_area->if_send_DRVSTATS_request = 0;
2104         ppp_priv_area->if_send_PTPIPE_request = 0;
2105         ppp_priv_area->if_send_wan_disconnected = 0;
2106         ppp_priv_area->if_send_adptr_bfrs_full = 0;
2107         ppp_priv_area->if_send_bfr_passed_to_adptr = 0;
2108         ppp_priv_area->rx_intr_no_socket = 0;
2109         ppp_priv_area->rx_intr_DRVSTATS_request = 0;
2110         ppp_priv_area->rx_intr_PTPIPE_request = 0;
2111         ppp_priv_area->rx_intr_bfr_not_passed_to_stack = 0;
2112         ppp_priv_area->rx_intr_bfr_passed_to_stack = 0;
2113         ppp_priv_area->UDP_PTPIPE_mgmt_kmalloc_err = 0;
2114         ppp_priv_area->UDP_PTPIPE_mgmt_adptr_type_err = 0;
2115         ppp_priv_area->UDP_PTPIPE_mgmt_direction_err = 0;
2116         ppp_priv_area->UDP_PTPIPE_mgmt_adptr_cmnd_timeout = 0;
2117         ppp_priv_area->UDP_PTPIPE_mgmt_adptr_cmnd_OK = 0;
2118         ppp_priv_area->UDP_PTPIPE_mgmt_passed_to_adptr = 0;
2119         ppp_priv_area->UDP_PTPIPE_mgmt_passed_to_stack = 0;
2120         ppp_priv_area->UDP_PTPIPE_mgmt_no_socket = 0;
2121         ppp_priv_area->UDP_DRVSTATS_mgmt_kmalloc_err = 0;
2122         ppp_priv_area->UDP_DRVSTATS_mgmt_adptr_type_err = 0;
2123         ppp_priv_area->UDP_DRVSTATS_mgmt_direction_err = 0;
2124         ppp_priv_area->UDP_DRVSTATS_mgmt_adptr_cmnd_timeout = 0;
2125         ppp_priv_area->UDP_DRVSTATS_mgmt_adptr_cmnd_OK = 0;
2126         ppp_priv_area->UDP_DRVSTATS_mgmt_passed_to_adptr = 0;
2127         ppp_priv_area->UDP_DRVSTATS_mgmt_passed_to_stack = 0;
2128         ppp_priv_area->UDP_DRVSTATS_mgmt_no_socket = 0;
2129 }
2130
2131 /*============================================================================
2132  * Initialize Global Statistics
2133  */
2134
2135 static void init_global_statistics(sdla_t * card)
2136 {
2137         card->statistics.isr_entry = 0;
2138         card->statistics.isr_already_critical = 0;
2139         card->statistics.isr_tx = 0;
2140         card->statistics.isr_rx = 0;
2141         card->statistics.isr_intr_test = 0;
2142         card->statistics.isr_spurious = 0;
2143         card->statistics.isr_enable_tx_int = 0;
2144         card->statistics.rx_intr_corrupt_rx_bfr = 0;
2145         card->statistics.rx_intr_dev_not_started = 0;
2146         card->statistics.tx_intr_dev_not_started = 0;
2147         card->statistics.poll_entry = 0;
2148         card->statistics.poll_already_critical = 0;
2149         card->statistics.poll_processed = 0;
2150         card->statistics.poll_tbusy_bad_status = 0;
2151 }
2152
2153 /*============================================================================
2154  * Initialize Receive and Transmit Buffers.
2155  */
2156
2157 static void init_ppp_tx_rx_buff(sdla_t * card)
2158 {
2159         if (card->hw.fwid == SFID_PPP502) {
2160                 ppp502_buf_info_t *info =
2161                 (void *) (card->hw.dpmbase + PPP502_BUF_OFFS);
2162                 card->u.p.txbuf_base =
2163                     (void *) (card->hw.dpmbase + info->txb_offs);
2164                 card->u.p.txbuf_last = (ppp_buf_ctl_t *) card->u.p.txbuf_base +
2165                     (info->txb_num - 1);
2166                 card->u.p.rxbuf_base =
2167                     (void *) (card->hw.dpmbase + info->rxb_offs);
2168                 card->u.p.rxbuf_last = (ppp_buf_ctl_t *) card->u.p.rxbuf_base +
2169                     (info->rxb_num - 1);
2170         } else {
2171                 ppp508_buf_info_t *info =
2172                 (void *) (card->hw.dpmbase + PPP508_BUF_OFFS);
2173                 card->u.p.txbuf_base = (void *) (card->hw.dpmbase +
2174                                        (info->txb_ptr - PPP508_MB_VECT));
2175                 card->u.p.txbuf_last = (ppp_buf_ctl_t *) card->u.p.txbuf_base +
2176                     (info->txb_num - 1);
2177                 card->u.p.rxbuf_base = (void *) (card->hw.dpmbase +
2178                                        (info->rxb_ptr - PPP508_MB_VECT));
2179                 card->u.p.rxbuf_last = (ppp_buf_ctl_t *) card->u.p.rxbuf_base +
2180                     (info->rxb_num - 1);
2181                 card->u.p.rx_base = info->rxb_base;
2182                 card->u.p.rx_top = info->rxb_end;
2183         }
2184         card->u.p.txbuf = card->u.p.txbuf_base;
2185         card->rxmb = card->u.p.rxbuf_base;
2186 }
2187
2188 /*=============================================================================
2189  * Perform the Interrupt Test by running the READ_CODE_VERSION command MAX_INTR
2190  * _TEST_COUNTER times.
2191  */
2192
2193 static int intr_test(sdla_t * card)
2194 {
2195         ppp_mbox_t *mb = card->mbox;
2196         int err, i;
2197         /* The critical flag is unset because during initialization (if_open)
2198          * we want the interrupts to be enabled so that when the wpp_isr is
2199          * called it does not exit due to critical flag set.
2200          */
2201         card->wandev.critical = 0;
2202         err = ppp_set_intr_mode(card, 0x08);
2203         if (err == CMD_OK) {
2204                 for (i = 0; i < MAX_INTR_TEST_COUNTER; i++) {
2205                         /* Run command READ_CODE_VERSION */
2206                         memset(&mb->cmd, 0, sizeof(ppp_cmd_t));
2207                         mb->cmd.length = 0;
2208                         mb->cmd.command = 0x10;
2209                         err = sdla_exec(mb) ? mb->cmd.result : CMD_TIMEOUT;
2210                         if (err != CMD_OK)
2211                                 ppp_error(card, err, mb);
2212                 }
2213         } else
2214                 return err;
2215         err = ppp_set_intr_mode(card, 0);
2216         if (err != CMD_OK)
2217                 return err;
2218         card->wandev.critical = 1;
2219         return 0;
2220 }
2221
2222 /*==============================================================================
2223  * Determine what type of UDP call it is. DRVSTATS or PTPIPEAB ?
2224  */
2225
2226 static int udp_pkt_type(struct sk_buff *skb, sdla_t * card)
2227 {
2228         unsigned char *sendpacket;
2229         unsigned char buf2[5];
2230         sendpacket = skb->data;
2231         memcpy(&buf2, &card->wandev.udp_port, 2);
2232         if (sendpacket[0] == 0x45 &&    /* IP packet */
2233             sendpacket[9] == 0x11 &&    /* UDP packet */
2234             sendpacket[22] == buf2[1] &&        /* UDP Port */
2235             sendpacket[23] == buf2[0] &&
2236             sendpacket[36] == 0x01) {
2237                 if (sendpacket[28] == 0x50 &&   /* PTPIPEAB: Signature */
2238                     sendpacket[29] == 0x54 &&
2239                     sendpacket[30] == 0x50 &&
2240                     sendpacket[31] == 0x49 &&
2241                     sendpacket[32] == 0x50 &&
2242                     sendpacket[33] == 0x45 &&
2243                     sendpacket[34] == 0x41 &&
2244                     sendpacket[35] == 0x42) {
2245                         return UDP_PTPIPE_TYPE;
2246                 } else if (sendpacket[28] == 0x44 &&    /* DRVSTATS: Signature */
2247                            sendpacket[29] == 0x52 &&
2248                            sendpacket[30] == 0x56 &&
2249                            sendpacket[31] == 0x53 &&
2250                            sendpacket[32] == 0x54 &&
2251                            sendpacket[33] == 0x41 &&
2252                            sendpacket[34] == 0x54 &&
2253                            sendpacket[35] == 0x53) {
2254                         return UDP_DRVSTATS_TYPE;
2255                 } else
2256                         return UDP_INVALID_TYPE;
2257         } else
2258                 return UDP_INVALID_TYPE;
2259 }
2260
2261 /****** End *****************************************************************/