drivers/net/sdla_fr.c

   1 /****************************************************************************
   2 * sdla_fr.c     WANPIPE(tm) Multiprotocol WAN Link Driver. Frame relay module.
   3 *
   4 * Author(s):    Gene Kozin
   5 *               Jaspreet Singh          <jaspreet@sangoma.com>
   6 *
   7 * Copyright:    (c) 1995-1997 Sangoma Technologies Inc.
   8 *
   9 *               This program is free software; you can redistribute it and/or
  10 *               modify it under the terms of the GNU General Public License
  11 *               as published by the Free Software Foundation; either version
  12 *               2 of the License, or (at your option) any later version.
  13 * ============================================================================
  14 * Nov 26, 1997  Jaspreet Singh  o Improved load sharing with multiple boards
  15 *                               o Added Cli() to protect enabling of interrupts
  16 *                                 while polling is called.
  17 * Nov 24, 1997  Jaspreet Singh  o Added counters to avoid enabling of interrupts
  18 *                                 when they have been disabled by another
  19 *                                 interface or routine (eg. wpf_poll).
  20 * Nov 06, 1997  Jaspreet Singh  o Added INTR_TEST_MODE to avoid polling
  21 *                                 routine disable interrupts during interrupt
  22 *                                 testing.
  23 * Oct 20, 1997  Jaspreet Singh  o Added hooks in for Router UP time.
  24 * Oct 16, 1997  Jaspreet Singh  o The critical flag is used to maintain flow
  25 *                                 control by avoiding RACE conditions.  The
  26 *                                 cli() and restore_flags() are taken out.
  27 *                                 The fr_channel structure is appended for
  28 *                                 Driver Statistics.
  29 * Oct 15, 1997  Farhan Thawar    o updated if_send() and receive for IPX
  30 * Aug 29, 1997  Farhan Thawar    o Removed most of the cli() and sti()
  31 *                                o Abstracted the UDP management stuff
  32 *                                o Now use tbusy and critical more intelligently
  33 * Jul 21, 1997  Jaspreet Singh   o Can configure T391, T392, N391, N392 & N393
  34 *                                  through router.conf.
  35 *                                o Protected calls to sdla_peek() by adDing
  36 *                                  save_flags(), cli() and restore_flags().
  37 *                                o Added error message for Inactive DLCIs in
  38 *                                  fr_event() and update_chan_state().
  39 *                                o Fixed freeing up of buffers using kfree()
  40 *                                  when packets are received.
  41 * Jul 07, 1997  Jaspreet Singh   o Added configurable TTL for UDP packets
  42 *                                o Added ability to discard multicast and
  43 *                                  broadcast source addressed packets
  44 * Jun 27, 1997  Jaspreet Singh   o Added FT1 monitor capabilities
  45 *                                  New case (0x44) statement in if_send routine *                                  Added a global variable rCount to keep track
  46 *                                  of FT1 status enabled on the board.
  47 * May 29, 1997  Jaspreet Singh   o Fixed major Flow Control Problem
  48 *                                  With multiple boards a problem was seen where
  49 *                                  the second board always stopped transmitting
  50 *                                  packet after running for a while. The code
  51 *                                  got into a stage where the interrupts were
  52 *                                  disabled and dev->tbusy was set to 1.
  53 *                                  This caused the If_send() routine to get into*                                  the if clause for it(0,dev->tbusy)
  54 *                                  forever.
  55 *                                  The code got into this stage due to an
  56 *                                  interrupt occuring within the if clause for
  57 *                                  set_bit(0,dev->tbusy).  Since an interrupt
  58 *                                  disables furhter transmit interrupt and
  59 *                                  makes dev->tbusy = 0, this effect was undone *                                  by making dev->tbusy = 1 in the if clause.
  60 *                                  The Fix checks to see if Transmit interrupts
  61 *                                  are disabled then do not make dev->tbusy = 1
  62 *                                  Introduced a global variable: int_occur and
  63 *                                  added tx_int_enabled in the wan_device
  64 *                                  structure.
  65 * May 21, 1997  Jaspreet Singh   o Fixed UDP Management for multiple
  66 *                                  boards.
  67 *
  68 * Apr 25, 1997  Farhan Thawar    o added UDP Management stuff
  69 *                                o fixed bug in if_send() and tx_intr() to
  70 *                                  sleep and wakeup all devices
  71 * Mar 11, 1997  Farhan Thawar   Version 3.1.1
  72 *                                o fixed (+1) bug in fr508_rx_intr()
  73 *                                o changed if_send() to return 0 if
  74 *                                  wandev.critical() is true
  75 *                                o free socket buffer in if_send() if
  76 *                                  returning 0
  77 *                                o added tx_intr() routine
  78 * Jan 30, 1997  Gene Kozin      Version 3.1.0
  79 *                                o implemented exec() entry point
  80 *                                o fixed a bug causing driver configured as
  81 *                                  a FR switch to be stuck in WAN_
  82 *                                  mode
  83 * Jan 02, 1997  Gene Kozin      Initial version.
  84 *****************************************************************************/
  85
  86 #if     !defined(__KERNEL__) || !defined(MODULE)
  87 #error  This code MUST be compiled as a kernel module!
  88 #endif
  89
  90 #include <linux/config.h>       /* OS configuration options */
  91 #include <linux/kernel.h>       /* printk(), and other useful stuff */
  92 #include <linux/stddef.h>       /* offsetof(), etc. */
  93 #include <linux/errno.h>        /* return codes */
  94 #include <linux/string.h>       /* inline memset(), etc. */
  95 #include <linux/malloc.h>       /* kmalloc(), kfree() */
  96 #include <linux/init.h>         /* __initfunc */
  97 #include <linux/wanrouter.h>    /* WAN router definitions */
  98 #include <linux/wanpipe.h>      /* WANPIPE common user API definitions */
  99 #include <linux/if_arp.h>       /* ARPHRD_* defines */
 100 #include <asm/byteorder.h>      /* htons(), etc. */
 101 #include <asm/io.h>             /* for inb(), outb(), etc. */
 102 #include <asm/uaccess.h>
 103 #include <linux/time.h>         /* for do_gettimeofday */
 104
 105 #define _GNUC_
 106 #include <linux/sdla_fr.h>      /* frame relay firmware API definitions */
 107 /****** Defines & Macros ****************************************************/
 108
 109 #define MAX_CMD_RETRY   10              /* max number of firmware retries */
 110
 111 #define FR_HEADER_LEN   8               /* max encapsulation header size */
 112 #define FR_CHANNEL_MTU  1500            /* unfragmented logical channel MTU */
 113
 114 /* Q.922 frame types */
 115 #define Q922_UI         0x03            /* Unnumbered Info frame */
 116 #define Q922_XID        0xAF            /* ??? */
 117
 118 /* DLCI configured or not */
 119 #define DLCI_NOT_CONFIGURED     0x00
 120 #define DLCI_CONFIG_PENDING     0x01
 121 #define DLCI_CONFIGURED         0x02
 122
 123 /* CIR enabled or not */
 124 #define CIR_ENABLED     0x00
 125 #define CIR_DISABLED    0x01
 126
 127 /* Interrupt mode for DLCI = 0 */
 128 #define BUFFER_INTR_MODE        0x00
 129 #define DLCI_LIST_INTR_MODE     0x01
 130
 131 /* Transmit Interrupt Status */
 132 #define DISABLED                0x00
 133 #define WAITING_TO_BE_ENABLED   0x01
 134
 135 /* For handle_IPXWAN() */
 136 #define CVHexToAscii(b) (((unsigned char)(b) > (unsigned char)9) ? ((unsigned char)'A' + ((unsigned char)(b) - (unsigned char)10)) : ((unsigned char)'0' + (unsigned char)(b)))
 137
 138 /****** Data Structures *****************************************************/
 139
 140 /* This is an extention of the 'struct device' we create for each network
 141  * interface to keep the rest of channel-specific data.
 142  */
 143 typedef struct fr_channel
 144 {
 145         char name[WAN_IFNAME_SZ+1];     /* interface name, ASCIIZ */
 146         unsigned dlci_configured  ;     /* check whether configured or not */
 147         unsigned cir_status;            /* check whether CIR enabled or not */
 148         unsigned dlci;                  /* logical channel number */
 149         unsigned cir;                   /* committed information rate */
 150         unsigned bc;                    /* committed burst size */
 151         unsigned be;                    /* excess burst size */
 152         unsigned mc;                    /* multicast support on or off */
 153         unsigned tx_int_status;         /* Transmit Interrupt Status */
 154         unsigned short pkt_length;      /* Packet Length */
 155         unsigned long router_start_time;/* Router start time in seconds */
 156         unsigned long tick_counter;     /* counter for transmit time out */
 157         char dev_pending_devtint;       /* interface pending dev_tint() */
 158         char state;                     /* channel state */
 159         void* dlci_int_interface;       /* pointer to the DLCI Interface */
 160         unsigned long IB_addr;          /* physical address of Interface Byte */
 161         unsigned long state_tick;       /* time of the last state change */
 162         sdla_t* card;                   /* -> owner */
 163         struct enet_statistics ifstats; /* interface statistics */
 164
 165         unsigned long if_send_entry;
 166         unsigned long if_send_skb_null;
 167         unsigned long if_send_broadcast;
 168         unsigned long if_send_multicast;
 169         unsigned long if_send_critical_ISR;
 170         unsigned long if_send_critical_non_ISR;
 171         unsigned long if_send_busy;
 172         unsigned long if_send_busy_timeout;
 173         unsigned long if_send_FPIPE_request;
 174         unsigned long if_send_DRVSTATS_request;
 175         unsigned long if_send_wan_disconnected;
 176         unsigned long if_send_dlci_disconnected;
 177         unsigned long if_send_no_bfrs;
 178         unsigned long if_send_adptr_bfrs_full;
 179         unsigned long if_send_bfrs_passed_to_adptr;
 180
 181         unsigned long rx_intr_no_socket;
 182         unsigned long rx_intr_dev_not_started;
 183         unsigned long rx_intr_FPIPE_request;
 184         unsigned long rx_intr_DRVSTATS_request;
 185         unsigned long rx_intr_bfr_not_passed_to_stack;
 186         unsigned long rx_intr_bfr_passed_to_stack;
 187
 188         unsigned long UDP_FPIPE_mgmt_kmalloc_err;
 189         unsigned long UDP_FPIPE_mgmt_direction_err;
 190         unsigned long UDP_FPIPE_mgmt_adptr_type_err;
 191         unsigned long UDP_FPIPE_mgmt_adptr_cmnd_OK;
 192         unsigned long UDP_FPIPE_mgmt_adptr_cmnd_timeout;
 193         unsigned long UDP_FPIPE_mgmt_adptr_send_passed;
 194         unsigned long UDP_FPIPE_mgmt_adptr_send_failed;
 195         unsigned long UDP_FPIPE_mgmt_not_passed_to_stack;
 196         unsigned long UDP_FPIPE_mgmt_passed_to_stack;
 197         unsigned long UDP_FPIPE_mgmt_no_socket;
 198         unsigned long UDP_DRVSTATS_mgmt_kmalloc_err;
 199         unsigned long UDP_DRVSTATS_mgmt_adptr_cmnd_OK;
 200         unsigned long UDP_DRVSTATS_mgmt_adptr_cmnd_timeout;
 201         unsigned long UDP_DRVSTATS_mgmt_adptr_send_passed;
 202         unsigned long UDP_DRVSTATS_mgmt_adptr_send_failed;
 203         unsigned long UDP_DRVSTATS_mgmt_not_passed_to_stack;
 204         unsigned long UDP_DRVSTATS_mgmt_passed_to_stack;
 205         unsigned long UDP_DRVSTATS_mgmt_no_socket;
 206         unsigned long router_up_time;
 207 } fr_channel_t;
 208
 209 typedef struct dlci_status
 210 {
 211         unsigned short dlci     PACKED;
 212         unsigned char state     PACKED;
 213 } dlci_status_t;
 214
 215 typedef struct dlci_IB_mapping
 216 {
 217         unsigned short dlci             PACKED;
 218         unsigned long  addr_value       PACKED;
 219 } dlci_IB_mapping_t;
 220
 221 /* This structure is used for DLCI list Tx interrupt mode.  It is used to
 222    enable interrupt bit and set the packet length for transmission
 223  */
 224 typedef struct fr_dlci_interface
 225 {
 226         unsigned char gen_interrupt     PACKED;
 227         unsigned short packet_length    PACKED;
 228         unsigned char reserved          PACKED;
 229 } fr_dlci_interface_t;
 230
 231 static unsigned short num_frames;
 232 static unsigned long curr_trace_addr;
 233 static unsigned long start_trace_addr;
 234 static unsigned short available_buffer_space;
 235 static char TracingEnabled;
 236
 237 /* variable for keeping track of enabling/disabling FT1 monitor status */
 238 static int rCount = 0;
 239
 240 extern void disable_irq(unsigned int);
 241 extern void enable_irq(unsigned int);
 242
 243 /* variable for keeping track of number of interrupts generated during
 244  * interrupt test routine
 245  */
 246 static int Intr_test_counter;
 247
 248 /****** Function Prototypes *************************************************/
 249
 250 /* WAN link driver entry points. These are called by the WAN router module. */
 251 static int update (wan_device_t* wandev);
 252 static int new_if (wan_device_t* wandev, struct device* dev,
 253         wanif_conf_t* conf);
 254 static int del_if (wan_device_t* wandev, struct device* dev);
 255
 256 /* WANPIPE-specific entry points */
 257 static int wpf_exec (struct sdla* card, void* u_cmd, void* u_data);
 258
 259 /* Network device interface */
 260 static int if_init   (struct device* dev);
 261 static int if_open   (struct device* dev);
 262 static int if_close  (struct device* dev);
 263 static int if_header (struct sk_buff* skb, struct device* dev,
 264         unsigned short type, void* daddr, void* saddr, unsigned len);
 265 static int if_rebuild_hdr (struct sk_buff* skb);
 266 static int if_send (struct sk_buff* skb, struct device* dev);
 267 static struct enet_statistics* if_stats (struct device* dev);
 268
 269 /* Interrupt handlers */
 270 static void fr502_isr (sdla_t* card);
 271 static void fr508_isr (sdla_t* card);
 272 static void fr502_rx_intr (sdla_t* card);
 273 static void fr508_rx_intr (sdla_t* card);
 274 static void tx_intr (sdla_t* card);
 275 static void spur_intr (sdla_t* card);
 276
 277 /* Background polling routines */
 278 static void wpf_poll (sdla_t* card);
 279
 280 /* Frame relay firmware interface functions */
 281 static int fr_read_version (sdla_t* card, char* str);
 282 static int fr_configure (sdla_t* card, fr_conf_t *conf);
 283 static int fr_dlci_configure (sdla_t* card, fr_dlc_conf_t *conf, unsigned dlci);
 284 static int fr_set_intr_mode (sdla_t* card, unsigned mode, unsigned mtu);
 285 static int fr_comm_enable (sdla_t* card);
 286 static int fr_comm_disable (sdla_t* card);
 287 static int fr_get_err_stats (sdla_t* card);
 288 static int fr_get_stats (sdla_t* card);
 289 static int fr_add_dlci (sdla_t* card, int dlci, int num);
 290 static int fr_activate_dlci (sdla_t* card, int dlci, int num);
 291 static int fr_issue_isf (sdla_t* card, int isf);
 292 static int fr502_send (sdla_t* card, int dlci, int attr, int len, void *buf);
 293 static int fr508_send (sdla_t* card, int dlci, int attr, int len, void *buf);
 294
 295 /* Firmware asynchronous event handlers */
 296 static int fr_event (sdla_t* card, int event, fr_mbox_t* mbox);
 297 static int fr_modem_failure (sdla_t *card, fr_mbox_t* mbox);
 298 static int fr_dlci_change (sdla_t *card, fr_mbox_t* mbox);
 299
 300 /* Miscellaneous functions */
 301 static int update_chan_state (struct device* dev);
 302 static void set_chan_state (struct device* dev, int state);
 303 static struct device* find_channel (sdla_t* card, unsigned dlci);
 304 static int is_tx_ready (sdla_t* card, fr_channel_t* chan);
 305 static unsigned int dec_to_uint (unsigned char* str, int len);
 306 static int reply_udp( unsigned char *data, unsigned int mbox_len );
 307
 308 static int intr_test( sdla_t* card );
 309 static void init_chan_statistics( fr_channel_t* chan );
 310 static void init_global_statistics( sdla_t* card );
 311 static void read_DLCI_IB_mapping( sdla_t* card, fr_channel_t* chan );
 312
 313 /* Udp management functions */
 314 static int process_udp_mgmt_pkt(char udp_pkt_src, sdla_t* card, struct sk_buff *skb, struct device* dev, int dlci, fr_channel_t* chan);
 315 static int process_udp_driver_call(char udp_pkt_src, sdla_t* card, struct sk_buff *skb, struct device* dev, int dlci, fr_channel_t* chan);
 316 static int udp_pkt_type( struct sk_buff *skb, sdla_t* card );
 317
 318 /* IPX functions */
 319 static void switch_net_numbers(unsigned char *sendpacket, unsigned long network_number, unsigned char incoming);
 320 static int handle_IPXWAN(unsigned char *sendpacket, char *devname, unsigned char enable_IPX, unsigned long network_number);
 321
 322 /****** Public Functions ****************************************************/
 323
 324 /*============================================================================
 325  * Frame relay protocol initialization routine.
 326  *
 327  * This routine is called by the main WANPIPE module during setup.  At this
 328  * point adapter is completely initialized and firmware is running.
 329  *  o read firmware version (to make sure it's alive)
 330  *  o configure adapter
 331  *  o initialize protocol-specific fields of the adapter data space.
 332  *
 333  * Return:      0       o.k.
 334  *              < 0     failure.
 335  */
 336 __initfunc(int wpf_init(sdla_t * card, wandev_conf_t * conf))
 337 {
 338         union {
 339                 char str[80];
 340                 fr_conf_t cfg;
 341         } u;
 342
 343         /* Verify configuration ID */
 344         if (conf->config_id != WANCONFIG_FR) {
 345                 printk(KERN_INFO "%s: invalid configuration ID %u!\n",
 346                        card->devname, conf->config_id);
 347                 return -EINVAL;
 348         }
 349         /* Initialize protocol-specific fields of adapter data space */
 350         switch (card->hw.fwid)
 351         {
 352                 case SFID_FR502:
 353                         card->mbox = (void *) (card->hw.dpmbase + FR502_MBOX_OFFS);
 354                         card->rxmb = (void *) (card->hw.dpmbase + FR502_RXMB_OFFS);
 355                         card->flags = (void *) (card->hw.dpmbase + FR502_FLAG_OFFS);
 356                         card->isr = &fr502_isr;
 357                         break;
 358
 359                 case SFID_FR508:
 360                         card->mbox = (void *) (card->hw.dpmbase + FR508_MBOX_OFFS);
 361                         card->flags = (void *) (card->hw.dpmbase + FR508_FLAG_OFFS);
 362                         card->isr = &fr508_isr;
 363                         break;
 364
 365                 default:
 366                         return -EINVAL;
 367         }
 368
 369         /* Read firmware version.  Note that when adapter initializes, it
 370          * clears the mailbox, so it may appear that the first command was
 371          * executed successfully when in fact it was merely erased. To work
 372          * around this, we execute the first command twice.
 373          */
 374         if (fr_read_version(card, NULL) || fr_read_version(card, u.str))
 375                 return -EIO
 376                     ;
 377         printk(KERN_INFO "%s: running frame relay firmware v%s\n",
 378                card->devname, u.str);
 379
 380         /* Adjust configuration */
 381         conf->mtu = max(min(conf->mtu, 4080), FR_CHANNEL_MTU + FR_HEADER_LEN);
 382         conf->bps = min(conf->bps, 2048000);
 383
 384         /* Configure adapter firmware */
 385         memset(&u.cfg, 0, sizeof(u.cfg));
 386         u.cfg.mtu = conf->mtu;
 387         u.cfg.t391 = 10;
 388         u.cfg.t392 = 15;
 389         u.cfg.n391 = 6;
 390         u.cfg.n392 = 3;
 391         u.cfg.n393 = 4;
 392         u.cfg.kbps = conf->bps / 1000;
 393         u.cfg.cir_fwd = 16;
 394         u.cfg.cir_bwd = u.cfg.bc_fwd = u.cfg.bc_bwd = u.cfg.cir_fwd;
 395         u.cfg.options = 0x0081; /* direct Rx, no CIR check */
 396
 397         switch (conf->u.fr.signalling)
 398         {
 399                 case WANOPT_FR_Q933:
 400                         u.cfg.options |= 0x0200;
 401                         break;
 402                 case WANOPT_FR_LMI:
 403                         u.cfg.options |= 0x0400;
 404                         break;
 405         }
 406
 407         if (conf->station == WANOPT_CPE)
 408         {
 409                 u.cfg.options |= 0x8000;        /* auto config DLCI */
 410         }
 411         else
 412         {
 413                 u.cfg.station = 1;      /* switch emulation mode */
 414                 card->u.f.node_dlci = conf->u.fr.dlci ? conf->u.fr.dlci : 16;
 415                 card->u.f.dlci_num = min(max(conf->u.fr.dlci_num, 1), 100);
 416         }
 417
 418         if (conf->clocking == WANOPT_INTERNAL)
 419                 u.cfg.port |= 0x0001
 420                     ;
 421         if (conf->interface == WANOPT_RS232)
 422                 u.cfg.port |= 0x0002
 423                     ;
 424         if (conf->u.fr.t391)
 425                 u.cfg.t391 = min(conf->u.fr.t391, 30);
 426         if (conf->u.fr.t392)
 427                 u.cfg.t392 = min(conf->u.fr.t392, 30);
 428         if (conf->u.fr.n391)
 429                 u.cfg.n391 = min(conf->u.fr.n391, 255);
 430         if (conf->u.fr.n392)
 431                 u.cfg.n392 = min(conf->u.fr.n392, 10);
 432         if (conf->u.fr.n393)
 433                 u.cfg.n393 = min(conf->u.fr.n393, 10);
 434
 435         if (fr_configure(card, &u.cfg))
 436                 return -EIO
 437                     ;
 438
 439         if (card->hw.fwid == SFID_FR508)
 440         {
 441                 fr_buf_info_t *buf_info =
 442                 (void *) (card->hw.dpmbase + FR508_RXBC_OFFS);
 443
 444                 card->rxmb =
 445                     (void *) (buf_info->rse_next -
 446                               FR_MB_VECTOR + card->hw.dpmbase);
 447                 card->u.f.rxmb_base =
 448                     (void *) (buf_info->rse_base -
 449                               FR_MB_VECTOR + card->hw.dpmbase);
 450                 card->u.f.rxmb_last =
 451                     (void *) (buf_info->rse_base +
 452                          (buf_info->rse_num - 1) * sizeof(fr_buf_ctl_t) -
 453                               FR_MB_VECTOR + card->hw.dpmbase);
 454                 card->u.f.rx_base = buf_info->buf_base;
 455                 card->u.f.rx_top = buf_info->buf_top;
 456         }
 457         card->wandev.mtu = conf->mtu;
 458         card->wandev.bps = conf->bps;
 459         card->wandev.interface = conf->interface;
 460         card->wandev.clocking = conf->clocking;
 461         card->wandev.station = conf->station;
 462         card->poll = &wpf_poll;
 463         card->exec = &wpf_exec;
 464         card->wandev.update = &update;
 465         card->wandev.new_if = &new_if;
 466         card->wandev.del_if = &del_if;
 467         card->wandev.state = WAN_DISCONNECTED;
 468         card->wandev.udp_port = conf->udp_port;
 469         TracingEnabled = '0';
 470         return 0;
 471 }
 472
 473 /******* WAN Device Driver Entry Points *************************************/
 474
 475 /*============================================================================
 476  * Update device status & statistics.
 477  */
 478 static int update(wan_device_t * wandev)
 479 {
 480         sdla_t *card;
 481
 482         /* sanity checks */
 483         if ((wandev == NULL) || (wandev->private == NULL))
 484                 return -EFAULT
 485                     ;
 486         if (wandev->state == WAN_UNCONFIGURED)
 487                 return -ENODEV
 488                     ;
 489         if (test_and_set_bit(0, (void *) &wandev->critical))
 490                 return -EAGAIN
 491                     ;
 492         card = wandev->private;
 493         fr_get_err_stats(card);
 494         fr_get_stats(card);
 495         wandev->critical = 0;
 496         return 0;
 497 }
 498
 499 /*============================================================================
 500  * Create new logical channel.
 501  * This routine is called by the router when ROUTER_IFNEW IOCTL is being
 502  * handled.
 503  * o parse media- and hardware-specific configuration
 504  * o make sure that a new channel can be created
 505  * o allocate resources, if necessary
 506  * o prepare network device structure for registaration.
 507  *
 508  * Return:      0       o.k.
 509  *              < 0     failure (channel will not be created)
 510  */
 511 static int new_if(wan_device_t * wandev, struct device *dev, wanif_conf_t * conf)
 512 {
 513         sdla_t *card = wandev->private;
 514         fr_channel_t *chan;
 515         int err = 0;
 516
 517         if ((conf->name[0] == '\0') || (strlen(conf->name) > WAN_IFNAME_SZ)) {
 518                 printk(KERN_INFO "%s: invalid interface name!\n",
 519                        card->devname);
 520                 return -EINVAL;
 521         }
 522         /* allocate and initialize private data */
 523         chan = kmalloc(sizeof(fr_channel_t), GFP_KERNEL);
 524         if (chan == NULL)
 525                 return -ENOMEM
 526                     ;
 527         memset(chan, 0, sizeof(fr_channel_t));
 528         strcpy(chan->name, conf->name);
 529         chan->card = card;
 530
 531         /* verify media address */
 532         if (is_digit(conf->addr[0])) {
 533                 int dlci = dec_to_uint(conf->addr, 0);
 534
 535                 if (dlci && (dlci <= 4095)) {
 536                         chan->dlci = dlci;
 537                 } else {
 538                         printk(KERN_ERR
 539                                "%s: invalid DLCI %u on interface %s!\n",
 540                                wandev->name, dlci, chan->name);
 541                         err = -EINVAL;
 542                 }
 543         } else {
 544                 printk(KERN_ERR
 545                        "%s: invalid media address on interface %s!\n",
 546                        wandev->name, chan->name);
 547                 err = -EINVAL;
 548         }
 549         if (err) {
 550                 kfree(chan);
 551                 return err;
 552         }
 553
 554         /* place cir,be,bc and other channel specific information into the
 555          * chan structure
 556          */
 557         if (conf->cir)
 558         {
 559                 chan->cir = max( 1, min( conf->cir, 512 ) );
 560                 chan->cir_status = CIR_ENABLED;
 561
 562                 if (conf->bc)
 563                         chan->bc = max( 1, min( conf->bc, 512 ) );
 564                 if (conf->be)
 565                         chan->be = max( 0, min( conf->be, 511) );
 566
 567         }
 568         else
 569                 chan->cir_status = CIR_DISABLED;
 570
 571         chan->mc = conf->mc;
 572
 573         chan->dlci_configured = DLCI_NOT_CONFIGURED;
 574
 575         chan->tx_int_status = DISABLED;
 576
 577         init_chan_statistics( chan );
 578
 579         /* prepare network device data space for registration */
 580         dev->name = chan->name;
 581         dev->init = &if_init;
 582         dev->priv = chan;
 583         return 0;
 584 }
 585
 586 /*============================================================================
 587  * Delete logical channel.
 588  */
 589 static int del_if(wan_device_t * wandev, struct device *dev)
 590 {
 591         if (dev->priv) {
 592                 kfree(dev->priv);
 593                 dev->priv = NULL;
 594         }
 595         return 0;
 596 }
 597
 598 /****** WANPIPE-specific entry points ***************************************/
 599
 600 /*============================================================================
 601  * Execute adapter interface command.
 602  */
 603 static int wpf_exec(struct sdla *card, void *u_cmd, void *u_data)
 604 {
 605         fr_mbox_t *mbox = card->mbox;
 606         int retry = MAX_CMD_RETRY;
 607         int err, len;
 608         fr_cmd_t cmd;
 609
 610         if (copy_from_user((void *) &cmd, u_cmd, sizeof(cmd)))
 611                 return -EFAULT;
 612         /* execute command */
 613         do {
 614                 memcpy(&mbox->cmd, &cmd, sizeof(cmd));
 615                 if (cmd.length)
 616                         if (copy_from_user((void *) &mbox->data, u_data, cmd.length))
 617                                 return -EFAULT;
 618                 if (sdla_exec(mbox))
 619                         err = mbox->cmd.result;
 620                 else
 621                         return -EIO;
 622         }
 623         while (err && retry-- && fr_event(card, err, mbox));
 624
 625         /* return result */
 626         if (copy_to_user(u_cmd, (void *) &mbox->cmd, sizeof(fr_cmd_t)))
 627                 return -EFAULT;
 628         len = mbox->cmd.length;
 629         if (len && u_data && copy_to_user(u_data, (void *) &mbox->data, len))
 630                 return -EFAULT;
 631         return 0;
 632 }
 633
 634 /****** Network Device Interface ********************************************/
 635
 636 /*============================================================================
 637  * Initialize Linux network interface.
 638  *
 639  * This routine is called only once for each interface, during Linux network
 640  * interface registration.  Returning anything but zero will fail interface
 641  * registration.
 642  */
 643 static int if_init(struct device *dev)
 644 {
 645         fr_channel_t *chan = dev->priv;
 646         sdla_t *card = chan->card;
 647         wan_device_t *wandev = &card->wandev;
 648         int i;
 649
 650         /* Initialize device driver entry points */
 651         dev->open = &if_open;
 652         dev->stop = &if_close;
 653         dev->hard_header = &if_header;
 654         dev->rebuild_header = &if_rebuild_hdr;
 655         dev->hard_start_xmit = &if_send;
 656         dev->get_stats = &if_stats;
 657
 658         /* Initialize media-specific parameters */
 659         dev->family = AF_INET;  /* address family */
 660         dev->type = ARPHRD_DLCI;        /* ARP h/w type */
 661         dev->mtu = FR_CHANNEL_MTU;
 662         dev->hard_header_len = FR_HEADER_LEN;   /* media header length */
 663         dev->addr_len = 2;      /* hardware address length */
 664         *(unsigned short *) dev->dev_addr = htons(chan->dlci);
 665
 666         /* Initialize hardware parameters (just for reference) */
 667         dev->irq = wandev->irq;
 668         dev->dma = wandev->dma;
 669         dev->base_addr = wandev->ioport;
 670         dev->mem_start = wandev->maddr;
 671         dev->mem_end = wandev->maddr + wandev->msize - 1;
 672
 673         /* Set transmit buffer queue length */
 674         dev->tx_queue_len = 30;
 675
 676         dev_init_buffers(dev);
 677
 678         set_chan_state(dev, WAN_DISCONNECTED);
 679         return 0;
 680 }
 681
 682 /*============================================================================
 683  * Open network interface.
 684  * o if this is the first open, then enable communications and interrupts.
 685  * o prevent module from unloading by incrementing use count
 686  *
 687  * Return 0 if O.k. or errno.
 688  */
 689
 690 static int if_open(struct device *dev)
 691 {
 692         fr_channel_t *chan = dev->priv;
 693         sdla_t *card = chan->card;
 694         struct device *dev2;
 695         int err = 0;
 696         fr508_flags_t *flags = card->flags;
 697         struct timeval tv;
 698
 699         if (dev->start)
 700                 return -EBUSY;  /* only one open is allowed */
 701
 702         if (test_and_set_bit(0, (void *) &card->wandev.critical))
 703                 return -EAGAIN;
 704
 705         if (!card->open_cnt)
 706         {
 707                 Intr_test_counter = 0;
 708                 card->intr_mode = INTR_TEST_MODE;
 709                 err = intr_test( card );
 710
 711                 if ((err) || (Intr_test_counter !=(MAX_INTR_TEST_COUNTER +1))) {
 712                         printk(KERN_INFO
 713                                 "%s: Interrupt Test Failed, Counter: %i\n",
 714                                 card->devname, Intr_test_counter);
 715                         err = -EIO;
 716                         card->wandev.critical = 0;
 717                         return err;
 718                 }
 719
 720                 printk(KERN_INFO "%s: Interrupt Test Passed, Counter: %i\n"
 721                         ,card->devname, Intr_test_counter);
 722
 723                 /* The following allocates and intializes a circular
 724                  * link list of interfaces per card.
 725                  */
 726
 727                 card->devs_struct = kmalloc(sizeof(load_sharing_t), GFP_KERNEL);
 728                 if (card->devs_struct == NULL)
 729                         return -ENOMEM;
 730                 card->dev_to_devtint_next = card->devs_struct;
 731
 732                 for (dev2 = card->wandev.dev; dev2; dev2 = dev2->slave) {
 733                         (card->devs_struct)->dev_ptr = dev2;
 734                         if(dev2->slave == NULL)
 735                                 (card->devs_struct)->next = card->dev_to_devtint_next;
 736                         else {
 737                                 (card->devs_struct)->next = kmalloc(
 738                                         sizeof(load_sharing_t), GFP_KERNEL);
 739                                 if ((card->devs_struct)->next == NULL)
 740                                         return -ENOMEM;
 741                                 card->devs_struct = (card->devs_struct)->next;
 742                         }
 743                 }
 744
 745                 card->devs_struct = card->dev_to_devtint_next;
 746
 747                 card->intr_mode = BUFFER_INTR_MODE;
 748
 749                 /*
 750                 check all the interfaces for the device to see if CIR has
 751                 been enabled for any DLCI(s). If so then use the DLCI list
 752                 Interrupt mode for fr_set_intr_mode(), otherwise use the                        default global interrupt mode
 753                 */
 754
 755                 for (dev2 = card->wandev.dev; dev2; dev2 = dev2->slave) {
 756
 757                         if( ((fr_channel_t *)dev2->priv)->cir_status
 758                                                         == CIR_ENABLED)  {
 759                                 card->intr_mode = DLCI_LIST_INTR_MODE;
 760                                 break;
 761                         }
 762                 }
 763
 764                 /*
 765                  *      If you enable comms and then set ints, you get a Tx int as you
 766                  *      perform the SET_INT_TRIGGERS command. So, we only set int
 767                  *      triggers and then adjust the interrupt mask (to disable Tx ints)                before enabling comms.
 768                  */
 769                 if (card->intr_mode == BUFFER_INTR_MODE)
 770                 {
 771                         if (fr_set_intr_mode(card, 0x03, card->wandev.mtu))
 772                         {
 773                                 err = -EIO;
 774                                 card->wandev.critical = 0;
 775                                 return err;
 776                         }
 777
 778                         printk( KERN_INFO
 779                                 "%s: Global Buffering Tx Interrupt Mode\n"
 780                                 , card->devname);
 781
 782                 }
 783                 else if (card->intr_mode == DLCI_LIST_INTR_MODE)
 784                 {
 785                         if (fr_set_intr_mode(card, 0x83, card->wandev.mtu))
 786                         {
 787                                 err = -EIO;
 788                                 card->wandev.critical = 0;
 789                                 return err;
 790                         }
 791
 792                         printk( KERN_INFO "%s: DLCI list Tx Interrupt Mode\n",
 793                                 card->devname);
 794
 795                 }
 796
 797                 flags->imask &= ~0x02;
 798
 799                 if (fr_comm_enable(card))
 800                 {
 801                         err = -EIO;
 802                         card->wandev.critical = 0;
 803                         return err;
 804                 }
 805
 806                 wanpipe_set_state(card, WAN_CONNECTED);
 807
 808                 if (card->wandev.station == WANOPT_CPE)
 809                 {
 810                         /* CPE: issue full status enquiry */
 811                         fr_issue_isf(card, FR_ISF_FSE);
 812                 }
 813                 else
 814                 {       /* FR switch: activate DLCI(s) */
 815
 816                         /* For Switch emulation we have to ADD and ACTIVATE
 817                          * the DLCI(s) that were configured with the SET_DLCI_
 818                          * CONFIGURATION command. Add and Activate will fail if
 819                          * DLCI specified is not included in the list.
 820                          *
 821                          * Also If_open is called once for each interface. But
 822                          * it does not get in here for all the interface. So
 823                          * we have to pass the entire list of DLCI(s) to add
 824                          * activate routines.
 825                          */
 826
 827                         fr_add_dlci(card, card->u.f.node_dlci[0], card->u.f.dlci_num);
 828                         fr_activate_dlci(card, card->u.f.node_dlci, card->u.f.dlci_num);
 829                 }
 830         }
 831         dev->mtu = min(dev->mtu, card->wandev.mtu - FR_HEADER_LEN);
 832         dev->interrupt = 0;
 833         dev->tbusy = 0;
 834         dev->start = 1;
 835         wanpipe_open(card);
 836         update_chan_state(dev);
 837
 838         do_gettimeofday( &tv );
 839         chan->router_start_time = tv.tv_sec;
 840         card->wandev.critical = 0;
 841         return err;
 842 }
 843
 844 /*============================================================================
 845  * Close network interface.
 846  * o if this is the last open, then disable communications and interrupts.
 847  * o reset flags.
 848  */
 849 static int if_close(struct device *dev)
 850 {
 851         fr_channel_t *chan = dev->priv;
 852         sdla_t *card = chan->card;
 853
 854         if (test_and_set_bit(0, (void *) &card->wandev.critical))
 855                 return -EAGAIN;
 856         ;
 857         dev->start = 0;
 858         wanpipe_close(card);
 859         if (!card->open_cnt) {
 860                 wanpipe_set_state(card, WAN_DISCONNECTED);
 861                 fr_set_intr_mode(card, 0, 0);
 862                 fr_comm_disable(card);
 863         }
 864         card->wandev.critical = 0;
 865         return 0;
 866 }
 867
 868 /*============================================================================
 869  * Build media header.
 870  * o encapsulate packet according to encapsulation type.
 871  *
 872  * The trick here is to put packet type (Ethertype) into 'protocol' field of
 873  * the socket buffer, so that we don't forget it.  If encapsulation fails,
 874  * set skb->protocol to 0 and discard packet later.
 875  *
 876  * Return:      media header length.
 877  */
 878 static int if_header(struct sk_buff *skb, struct device *dev,
 879              unsigned short type, void *daddr, void *saddr, unsigned len)
 880 {
 881         int hdr_len = 0;
 882
 883         skb->protocol = type;
 884         hdr_len = wan_encapsulate(skb, dev);
 885         if (hdr_len < 0) {
 886                 hdr_len = 0;
 887                 skb->protocol = 0;
 888         }
 889         skb_push(skb, 1);
 890         skb->data[0] = Q922_UI;
 891         ++hdr_len;
 892         return hdr_len;
 893 }
 894
 895 /*============================================================================
 896  * Re-build media header.
 897  *
 898  * Return:      1       physical address resolved.
 899  *              0       physical address not resolved
 900  */
 901 static int if_rebuild_hdr(struct sk_buff *skb)
 902 {
 903         fr_channel_t *chan = skb->dev->priv;
 904         sdla_t *card = chan->card;
 905
 906         printk(KERN_INFO "%s: rebuild_header() called for interface %s!\n",
 907                card->devname, skb->dev->name);
 908         return 1;
 909 }
 910
 911 /*============================================================================
 912  * Send a packet on a network interface.
 913  * o set tbusy flag (marks start of the transmission) to block a timer-based
 914  *   transmit from overlapping.
 915  * o check link state. If link is not up, then drop the packet.
 916  * o check channel status. If it's down then initiate a call.
 917  * o pass a packet to corresponding WAN device.
 918  * o free socket buffer
 919  *
 920  * Return:      0       complete (socket buffer must be freed)
 921  *              non-0   packet may be re-transmitted (tbusy must be set)
 922  *
 923  * Notes:
 924  * 1. This routine is called either by the protocol stack or by the "net
 925  *    bottom half" (with interrupts enabled).
 926  * 2. Setting tbusy flag will inhibit further transmit requests from the
 927  *    protocol stack and can be used for flow control with protocol layer.
 928  */
 929 static int if_send(struct sk_buff *skb, struct device *dev)
 930 {
 931         fr_channel_t *chan = dev->priv;
 932         sdla_t *card = chan->card;
 933         int retry = 0, err;
 934         struct device *dev2;
 935         fr508_flags_t* adptr_flags = card->flags;
 936         fr_dlci_interface_t* dlci_interface = chan->dlci_int_interface;
 937         unsigned long host_cpu_flags;
 938         int send_data = 0;
 939         ++chan->if_send_entry;
 940
 941         if (dev->tbusy)
 942         {
 943                 /* If our device stays busy for at least 5 seconds then we will
 944                  * kick start the device by making dev->tbusy = 0.  We expect
 945                  * that our device never stays busy more than 5 seconds. So this                 * is only used as a last resort.
 946                  */
 947
 948                 ++chan->if_send_busy;
 949                 ++chan->ifstats.collisions;
 950
 951                 if ((jiffies - chan->tick_counter) < (5*HZ))
 952                         return 1;
 953
 954                 printk(KERN_INFO "%s: Transmit timed out\n", chan->name);
 955
 956                 ++chan->if_send_busy_timeout;
 957
 958                 /* unbusy all the interfaces on the card */
 959                 for (dev2 = card->wandev.dev; dev2; dev2 = dev2->slave)
 960                         dev2->tbusy = 0;
 961         }
 962
 963         if (test_and_set_bit(0, (void *) &card->wandev.critical)) {
 964 #ifdef _DEBUG_
 965                 printk(KERN_INFO "%s: if_send() hit critical section!\n",
 966                        card->devname);
 967 #endif
 968                 dev_kfree_skb(skb, FREE_WRITE);
 969                 return 0;
 970         }
 971         disable_irq(card->hw.irq);
 972         ++card->irq_dis_if_send_count;
 973
 974         if (test_and_set_bit(0, (void*)&card->wandev.critical))
 975         {
 976                 if (card->wandev.critical == CRITICAL_IN_ISR)
 977                 {
 978                         ++chan->if_send_critical_ISR;
 979
 980                         if (card->intr_mode == DLCI_LIST_INTR_MODE)
 981                         {
 982                                 /* The enable_tx_int flag is set here so that if
 983                                  * the critical flag is set due to an interrupt
 984                                  * then we want to enable transmit interrupts
 985                                  * again.
 986                                  */
 987
 988                                 card->wandev.enable_tx_int = 1;
 989
 990                                 /* Setting this flag to WAITING_TO_BE_ENABLED
 991                                  * specifies that interrupt bit has to be
 992                                  * enabled for that particular interface.
 993                                  * (delayed interrupt)
 994                                  */
 995
 996                                 chan->tx_int_status = WAITING_TO_BE_ENABLED;
 997
 998                                 /* This is used for enabling dynamic calculation
 999                                  * of CIRs relative to the packet length.
1000                                  */
1001
1002                                 chan->pkt_length = skb->len;
1003                                 dev->tbusy = 1;
1004                                 chan->tick_counter = jiffies;
1005                         }
1006                         else
1007                         {
1008                                 card->wandev.enable_tx_int = 1;
1009                                 dev->tbusy = 1;
1010                                 chan->tick_counter = jiffies;
1011                         }
1012                         save_flags(host_cpu_flags);
1013                         cli();
1014                         if ((!(--card->irq_dis_if_send_count)) &&
1015                                         (!card->irq_dis_poll_count))
1016                                 enable_irq(card->hw.irq);
1017                         restore_flags(host_cpu_flags);
1018                         return 1;
1019                 }
1020
1021                 ++chan->if_send_critical_non_ISR;
1022                 ++chan->ifstats.tx_dropped;
1023                 dev_kfree_skb(skb, FREE_WRITE);
1024                 save_flags(host_cpu_flags);
1025                 cli();
1026                 if ((!(--card->irq_dis_if_send_count)) &&
1027                                          (!card->irq_dis_poll_count))
1028                         enable_irq(card->hw.irq);
1029                 restore_flags(host_cpu_flags);
1030                 return 0;
1031         }
1032
1033         card->wandev.critical = 0x21;
1034
1035         if (card->wandev.state != WAN_CONNECTED)
1036         {
1037                 ++chan->if_send_wan_disconnected;
1038                 ++chan->ifstats.tx_dropped;
1039                 ++card->wandev.stats.tx_dropped;
1040         }
1041         else if (chan->state != WAN_CONNECTED)
1042         {
1043                 ++chan->if_send_dlci_disconnected;
1044                 update_chan_state(dev);
1045                 ++chan->ifstats.tx_dropped;
1046                 ++card->wandev.stats.tx_dropped;
1047         }
1048         else if (!is_tx_ready(card, chan))
1049         {
1050                 if (card->intr_mode == DLCI_LIST_INTR_MODE )
1051                 {
1052                         dlci_interface->gen_interrupt |= 0x40;
1053                         dlci_interface->packet_length = skb->len;
1054                 }
1055                 dev->tbusy = 1;
1056                 chan->tick_counter = jiffies;
1057
1058                 adptr_flags->imask |= 0x02;
1059
1060                 ++ chan->if_send_no_bfrs;
1061                 retry = 1;
1062         }
1063         else
1064         {
1065                 send_data = 1;
1066                 /* If it's an IPX packet */
1067                 if( sendpacket[1] == 0x00 &&
1068                     sendpacket[2] == 0x80 &&
1069                     sendpacket[6] == 0x81 &&
1070                     sendpacket[7] == 0x37)
1071                 {
1072                         if( card->wandev.enable_IPX )
1073                         {
1074                                 switch_net_numbers(sendpacket,
1075                                         card->wandev.network_number, 0);
1076                         }
1077                         else
1078                         {
1079                                 /* increment some statistic here! */
1080                                 send_data = 0;
1081                         }
1082                 }
1083
1084                 if (send_data)
1085                 {
1086                         err = (card->hw.fwid == SFID_FR508) ?
1087                         fr508_send(card, chan->dlci, 0, skb->len, skb->data) :
1088                         fr502_send(card, chan->dlci, 0, skb->len, skb->data);
1089
1090                         if (err)
1091                         {
1092                                 if (card->intr_mode == DLCI_LIST_INTR_MODE)
1093                                 {
1094                                         dlci_interface->gen_interrupt |= 0x40;
1095                                         dlci_interface->packet_length = skb->len;
1096                                 }
1097                                 dev->tbusy = 1;
1098                                 chan->tick_counter = jiffies;
1099                                 adptr_flags->imask |= 0x02;
1100                                 retry = 1;
1101                                 ++ chan->if_send_adptr_bfrs_full;
1102                                 ++ chan->ifstats.tx_errors;
1103                                 ++ card->wandev.stats.tx_errors;
1104                         }
1105                         else
1106                         {
1107                                 ++ chan->if_send_bfrs_passed_to_adptr;
1108                                 ++chan->ifstats.tx_packets;
1109                                 ++card->wandev.stats.tx_packets;
1110                         }
1111                 }
1112         }
1113
1114         if (!retry)
1115                 dev_kfree_skb(skb, FREE_WRITE);
1116
1117         card->wandev.critical = 0;
1118         save_flags(host_cpu_flags);
1119         cli();
1120         if ((!(--card->irq_dis_if_send_count)) && (!card->irq_dis_poll_count))
1121                 enable_irq(card->hw.irq);
1122         restore_flags(host_cpu_flags);
1123         return retry;
1124 }
1125
1126 /*
1127  *      If incoming is 0 (outgoing)- if the net numbers is ours make it 0
1128  *      if incoming is 1 - if the net number is 0 make it ours
1129  *
1130  */
1131
1132 static void switch_net_numbers(unsigned char *sendpacket, unsigned long network_number, unsigned char incoming)
1133 {
1134         unsigned long pnetwork_number;
1135
1136         pnetwork_number = (unsigned long)((sendpacket[14] << 24) +
1137                           (sendpacket[15] << 16) + (sendpacket[16] << 8) +
1138                           sendpacket[17]);
1139
1140         if (!incoming) {
1141                 if( pnetwork_number == network_number) {
1142                         sendpacket[14] = sendpacket[15] = sendpacket[16] =
1143                                          sendpacket[17] = 0x00;
1144                 }
1145         } else {
1146                 if( pnetwork_number == 0) {
1147                         sendpacket[14] = (unsigned char)(network_number >> 24);
1148                         sendpacket[15] = (unsigned char)((network_number &
1149                                          0x00FF0000) >> 16);
1150                         sendpacket[16] = (unsigned char)((network_number &
1151                                          0x0000FF00) >> 8);
1152                         sendpacket[17] = (unsigned char)(network_number &
1153                                          0x000000FF);
1154                 }
1155         }
1156
1157
1158         pnetwork_number = (unsigned long)((sendpacket[26] << 24) +
1159                           (sendpacket[27] << 16) + (sendpacket[28] << 8) +
1160                           sendpacket[29]);
1161
1162         if( !incoming ) {
1163                 if( pnetwork_number == network_number) {
1164                         sendpacket[26] = sendpacket[27] = sendpacket[28] =
1165                                          sendpacket[29] = 0x00;
1166                 }
1167         } else {
1168                 if( pnetwork_number == 0 ) {
1169                         sendpacket[26] = (unsigned char)(network_number >> 24);
1170                         sendpacket[27] = (unsigned char)((network_number &
1171                                          0x00FF0000) >> 16);
1172                         sendpacket[28] = (unsigned char)((network_number &
1173                                          0x0000FF00) >> 8);
1174                         sendpacket[29] = (unsigned char)(network_number &
1175                                          0x000000FF);
1176                 }
1177         }
1178 } /* switch_net_numbers */
1179
1180
1181 /*============================================================================
1182  * Get ethernet-style interface statistics.
1183  * Return a pointer to struct enet_statistics.
1184  */
1185 static struct net_device_stats *if_stats(struct device *dev)
1186 {
1187         fr_channel_t *chan = dev->priv;
1188
1189         return &chan->ifstats;
1190 }
1191
1192 /****** Interrupt Handlers **************************************************/
1193
1194 /*============================================================================
1195  * S502 frame relay interrupt service routine.
1196  */
1197 static void fr502_isr(sdla_t * card)
1198 {
1199         fr502_flags_t *flags = card->flags;
1200
1201         switch (flags->iflag)
1202         {
1203                 case 0x01:              /* receive interrupt */
1204                         fr502_rx_intr(card);
1205                         break;
1206
1207                 case 0x02:              /* transmit interrupt */
1208                         flags->imask &= ~0x02;
1209                         tx_intr(card);
1210                         break;
1211
1212                 default:
1213                         spur_intr(card);
1214         }
1215         flags->iflag = 0;
1216 }
1217
1218 /*============================================================================
1219  * S508 frame relay interrupt service routine.
1220  */
1221 static void fr508_isr(sdla_t * card)
1222 {
1223         fr508_flags_t *flags = card->flags;
1224         fr_buf_ctl_t *bctl;
1225         char *ptr = &flags->iflag;
1226         struct device* dev = card->wandev.dev;
1227         struct device* dev2;
1228         int i;
1229         unsigned long host_cpu_flags;
1230         unsigned disable_tx_intr =1;
1231         fr_channel_t* chan;
1232         fr_dlci_interface_t* dlci_interface;
1233
1234         /* This flag prevents nesting of interrupts.  See sdla_isr() routine
1235          * in sdlamain.c.
1236          */
1237         card->in_isr = 1;
1238
1239         ++card->statistics.isr_entry;
1240
1241         if (test_and_set_bit(0, (void*)&card->wandev.critical))
1242         {
1243                 printk(KERN_INFO "fr508_isr: %s, wandev.critical set to 0x%02X, int type = 0x%02X\n", card->devname, card->wandev.critical, flags->iflag);
1244                 ++card->statistics.isr_already_critical;
1245                 card->in_isr = 0;
1246                 return;
1247         }
1248         int_occur = 1;
1249
1250         /* For all interrupts set the critical flag to CRITICAL_RX_INTR.
1251          * If the if_send routine is called with this flag set it will set
1252          * the enable transmit flag to 1. (for a delayed interrupt)
1253          */
1254         card->wandev.critical = CRITICAL_IN_ISR;
1255
1256         card->dlci_int_mode_unbusy = 0;
1257         card->buff_int_mode_unbusy = 0;
1258
1259         switch (flags->iflag) {
1260                 case 0x01:  /* receive interrupt */
1261                         ++card->statistics.isr_rx;
1262                         fr508_rx_intr(card);
1263                         break;
1264
1265                 case 0x02:  /* transmit interrupt */
1266                         ++card->statistics.isr_tx;
1267                         bctl = (void*)(flags->tse_offs - FR_MB_VECTOR +
1268                                 card->hw.dpmbase);
1269                         bctl->flag = 0xA0;
1270
1271                         if (card->intr_mode == DLCI_LIST_INTR_MODE )
1272                         {
1273                                 /* Find the structure and make it unbusy */
1274                                 dev = find_channel( card, flags->dlci);
1275                                 dev->tbusy = 0;
1276
1277                                 /* This is used to perform devtint at the
1278                                  * end of the isr
1279                                  */
1280                                 card->dlci_int_mode_unbusy = 1;
1281
1282                                 /* check to see if any other interfaces are
1283                                  * busy. If so then do not disable the tx
1284                                  * interrupts
1285                                  */
1286                                 for (dev2 = card->wandev.dev; dev2;
1287                                                 dev2 = dev2->slave)
1288                                 {
1289                                         if ( dev2->tbusy == 1)
1290                                         {
1291                                                 disable_tx_intr = 0;
1292                                                 break;
1293                                         }
1294                                 }
1295                                 if (disable_tx_intr)
1296                                         flags->imask &= ~0x02;
1297
1298                         }
1299                         else if (card->intr_mode == BUFFER_INTR_MODE)
1300                         {
1301                                 for (dev2 = card->wandev.dev; dev2;
1302                                                         dev2 = dev2->slave)
1303                                 {
1304                                         if ( !dev2 || !dev2->start )
1305                                         {
1306                                                 ++card->statistics.
1307                                                 tx_intr_dev_not_started;
1308                                                 continue;
1309                                         }
1310                                         if(dev2->tbusy)
1311                                         {
1312                                                 card->buff_int_mode_unbusy = 1;
1313                                                 ((fr_channel_t*)dev2->priv)->dev_pending_devtint = 1;
1314                                                 dev2->tbusy = 0;
1315                                         } else
1316                                                 ((fr_channel_t*)dev2->priv)->dev_pending_devtint = 0;
1317                                 }
1318                                 flags->imask &= ~0x02;
1319                         }
1320                         break;
1321
1322                 case 0x08:
1323                         Intr_test_counter++;
1324                         ++card->statistics.isr_intr_test;
1325                         break;
1326
1327                 default:
1328                         ++card->statistics.isr_spurious;
1329                         spur_intr(card);
1330                         printk(KERN_INFO "%s: Interrupt Type 0x%02X!\n",
1331                                 card->devname, flags->iflag);
1332
1333                         printk(KERN_INFO "%s: ID Bytes = ",card->devname);
1334                         for(i = 0; i < 8; i ++)
1335                                 printk(KERN_INFO "0x%02X ", *(ptr + 0x28 + i));
1336                         printk(KERN_INFO "\n");
1337
1338                         break;
1339         }
1340
1341         card->wandev.critical = CRITICAL_INTR_HANDLED;
1342         if (card->wandev.enable_tx_int)
1343         {
1344                 if( card->intr_mode == DLCI_LIST_INTR_MODE )
1345                 {
1346                         for (dev2 = card->wandev.dev; dev2; dev2 = dev2->slave)
1347                         {
1348                                 chan = dev2->priv;
1349                                 if ( chan->tx_int_status ==
1350                                                 WAITING_TO_BE_ENABLED )
1351                                 {
1352                                         dlci_interface =
1353                                                 chan->dlci_int_interface;
1354                                         dlci_interface->gen_interrupt |= 0x40;
1355                                         dlci_interface->packet_length =
1356                                                         chan->pkt_length;
1357                                         chan->tx_int_status = DISABLED;
1358                                 }
1359                         }
1360                 }
1361                 card->wandev.enable_tx_int = 0;
1362                 flags->imask |= 0x02;
1363                 ++card->statistics.isr_enable_tx_int;
1364         }
1365         save_flags(host_cpu_flags);
1366         cli();
1367         card->in_isr = 0;
1368         card->wandev.critical = 0xD1;
1369         flags->iflag = 0;
1370         card->wandev.critical = 0;
1371         restore_flags(host_cpu_flags);
1372
1373         /*
1374          *      Device is now ready to send. The instant this is executed the If_Send
1375          *      routine is called. That is why this is put at the bottom of the ISR
1376          *      to prevent a endless loop condition caused by repeated Interrupts and
1377          *      enable_tx_int flag.
1378          */
1379
1380         if(card->dlci_int_mode_unbusy)
1381                 dev_tint(dev);
1382
1383         if(card->buff_int_mode_unbusy)
1384         {
1385                 for (;;)
1386                 {
1387                         if (((fr_channel_t*)((card->devs_struct)->dev_ptr)->priv)->dev_pending_devtint == 1){
1388
1389                                 ((fr_channel_t*)((card->devs_struct)->dev_ptr)->priv)->dev_pending_devtint=0;
1390                                 dev_tint((card->devs_struct)->dev_ptr);
1391                         }
1392                         if ((card->devs_struct)->next == card->dev_to_devtint_next)
1393                                 break;
1394                         card->devs_struct = (card->devs_struct)->next;
1395                 }
1396                 card->devs_struct = (card->dev_to_devtint_next)->next;
1397                 card->dev_to_devtint_next = card->devs_struct;
1398         }
1399 }
1400
1401 /*============================================================================
1402  * Receive interrupt handler.
1403  */
1404
1405 static void fr502_rx_intr(sdla_t * card)
1406 {
1407         fr_mbox_t *mbox = card->rxmb;
1408         struct sk_buff *skb;
1409         struct device *dev;
1410         fr_channel_t *chan;
1411         unsigned dlci, len;
1412         void *buf;
1413
1414         sdla_mapmem(&card->hw, FR502_RX_VECTOR);
1415
1416         dlci = mbox->cmd.dlci;
1417         len = mbox->cmd.length;
1418
1419         /* Find network interface for this packet */
1420         dev = find_channel(card, dlci);
1421         if (dev == NULL) {
1422                 /* Invalid channel, discard packet */
1423                 printk(KERN_INFO "%s: receiving on orphaned DLCI %d!\n",
1424                        card->devname, dlci);
1425                 sdla_mapmem(&card->hw, FR_MB_VECTOR);
1426         }
1427         chan = dev->priv;
1428         if (!dev->start) {
1429                 ++chan->ifstats.rx_dropped;
1430                 sdla_mapmem(&card->hw, FR_MB_VECTOR);
1431         }
1432         /* Allocate socket buffer */
1433         skb = dev_alloc_skb(len);
1434         if (skb == NULL) {
1435                 printk(KERN_INFO "%s: no socket buffers available!\n",
1436                        card->devname);
1437                 ++chan->ifstats.rx_dropped;
1438                 sdla_mapmem(&card->hw, FR_MB_VECTOR);
1439         }
1440         /* Copy data to the socket buffer */
1441         buf = skb_put(skb, len);
1442         memcpy(buf, mbox->data, len);
1443         sdla_mapmem(&card->hw, FR_MB_VECTOR);
1444
1445         /* Decapsulate packet and pass it up the protocol stack */
1446         skb->dev = dev;
1447         buf = skb_pull(skb, 1); /* remove hardware header */
1448         if (!wan_type_trans(skb, dev)) {
1449                 /* can't decapsulate packet */
1450                 dev_kfree_skb(skb, FREE_READ);
1451                 ++chan->ifstats.rx_errors;
1452                 ++card->wandev.stats.rx_errors;
1453         } else {
1454                 netif_rx(skb);
1455                 ++chan->ifstats.rx_packets;
1456                 ++card->wandev.stats.rx_packets;
1457         }
1458         sdla_mapmem(&card->hw, FR_MB_VECTOR);
1459 }
1460
1461 /*============================================================================
1462  * Receive interrupt handler.
1463  */
1464 static void fr508_rx_intr(sdla_t * card)
1465 {
1466         fr_buf_ctl_t *frbuf = card->rxmb;
1467         struct sk_buff *skb;
1468         struct device *dev;
1469         fr_channel_t *chan;
1470         unsigned dlci, len, offs;
1471         void *buf;
1472         unsigned rx_count = 0;
1473         fr508_flags_t* flags = card->flags;
1474         char *ptr = &flags->iflag;
1475         int i, err;
1476
1477         if (frbuf->flag != 0x01) {
1478                 printk(KERN_INFO "%s: corrupted Rx buffer @ 0x%X!\n",
1479                        card->devname, (unsigned) frbuf);
1480                 printk(KERN_INFO "%s: ID Bytes = ",card->devname);
1481                 for(i = 0; i < 8; i ++)
1482                         printk(KERN_INFO "0x%02X ", *(ptr + 0x28 + i));
1483                 printk(KERN_INFO "\n");
1484
1485                 ++card->statistics.rx_intr_corrupt_rx_bfr;
1486                 return;
1487         }
1488
1489         do
1490         {
1491                 len  = frbuf->length;
1492                 dlci = frbuf->dlci;
1493                 offs = frbuf->offset;
1494
1495                 /* Find network interface for this packet */
1496                 dev = find_channel(card, dlci);
1497                 chan = dev->priv;
1498
1499                 if (dev == NULL)
1500                 {
1501                         /* Invalid channel, discard packet */
1502                         printk(KERN_INFO "%s: receiving on orphaned DLCI %d!\n"
1503                                 , card->devname, dlci);
1504                         ++card->statistics.rx_intr_on_orphaned_DLCI;
1505                 }
1506                 else
1507                 {
1508                         skb = dev_alloc_skb(len);
1509                         if (!dev->start || (skb == NULL))
1510                         {
1511                                 ++chan->ifstats.rx_dropped;
1512                                 if(dev->start)
1513                                 {
1514                                         printk(KERN_INFO
1515                                         "%s: no socket buffers available!\n",
1516                                         card->devname);
1517                                         ++chan->rx_intr_no_socket;
1518
1519                                 }
1520                                 else
1521                                         ++ chan->rx_intr_dev_not_started;
1522                         }
1523                         else
1524                         {
1525                                 /* Copy data to the socket buffer */
1526                                 if ((offs + len) > card->u.f.rx_top + 1)
1527                                 {
1528                                         unsigned tmp = card->u.f.rx_top -
1529                                                         offs + 1;
1530
1531                                         buf = skb_put(skb, tmp);
1532                                         sdla_peek(&card->hw, offs, buf, tmp);
1533                                         offs = card->u.f.rx_base;
1534                                         len -= tmp;
1535                                 }
1536
1537                                 buf = skb_put(skb, len);
1538                                 sdla_peek(&card->hw, offs, buf, len);
1539 #ifdef CONFIG_SANGOMA_MANAGER
1540                                 if (management_check(skb,card))
1541                                 {
1542                                         ++chan->rx_intr_DRVSTATS_request;
1543                                 }
1544                                 else
1545 #endif
1546                                 if (handle_IPXWAN(skb->data,card->devname, card->wandev.enable_IPX, card->wandev.network_number))
1547                                 {
1548                                         if (card->wandev.enable_IPX)
1549                                         {
1550                                                 fr508_send(card, dlci, 0, skb->len, skb->data);
1551                                         } else {
1552                                                 /* increment some statistic! */
1553                                         }
1554                                 }
1555                                 else
1556                                 {
1557                                         /* Decapsulate packet and pass it up the
1558                                            protocol stack */
1559                                         skb->dev = dev;
1560
1561                                         /* remove hardware header */
1562                                         buf = skb_pull(skb, 1);
1563
1564                                         if (!wan_type_trans(skb, dev))
1565                                         {
1566                                                 /* can't decapsulate packet */
1567                                                 dev_kfree_skb(skb, FREE_READ);
1568                                                 ++chan->rx_intr_bfr_not_passed_to_stack;
1569                                                 ++chan->ifstats.rx_errors;
1570                                                 ++card->wandev.stats.rx_errors;
1571                                         }
1572                                         else
1573                                         {
1574                                                 netif_rx(skb);
1575                                                 ++ chan->rx_intr_bfr_passed_to_stack;
1576                                                 ++ chan->ifstats.rx_packets;
1577                                                 ++ card->wandev.stats.rx_packets;
1578                                         }
1579                                 }
1580                         }
1581                 }
1582
1583                 /* Release buffer element and calculate a pointer to the next
1584                    one */
1585                 frbuf->flag = 0;
1586                 card->rxmb = ++frbuf;
1587
1588                 if ((void*)frbuf > card->u.f.rxmb_last)
1589                         card->rxmb = card->u.f.rxmb_base;
1590
1591                 /* The loop put in is temporary, that is why the break is
1592                  * placed here. (?????)
1593                  */
1594                 break;
1595
1596                 frbuf = card->rxmb;
1597
1598         } while (frbuf->flag && ((++ rx_count) < 4));
1599 }
1600
1601 /*============================================================================
1602  * Transmit interrupt handler.
1603  * o print a warning
1604  * o
1605  * If number of spurious interrupts exceeded some limit, then ???
1606  */
1607 static void tx_intr(sdla_t * card)
1608 {
1609         struct device *dev = card->wandev.dev;
1610
1611         if (card->intr_mode == BUFFER_INTR_MODE)
1612         {
1613                 for (; dev; dev = dev->slave)
1614                 {
1615                         if ( !dev || !dev->start )
1616                         {
1617                                 ++ card->statistics.tx_intr_dev_not_started;
1618                                 continue;
1619                         }
1620
1621                         dev->tbusy = 0;
1622                         dev_tint(dev);
1623                 }
1624         }
1625         else
1626         {
1627                 dev->tbusy = 0;
1628                 dev_tint(dev);
1629         }
1630 }
1631
1632 /*============================================================================
1633  * Spurious interrupt handler.
1634  * o print a warning
1635  * o
1636  * If number of spurious interrupts exceeded some limit, then ???
1637  */
1638 static void spur_intr(sdla_t * card)
1639 {
1640         printk(KERN_INFO "%s: spurious interrupt!\n", card->devname);
1641 }
1642
1643 /*
1644   Return 0 for non-IPXWAN packet
1645          1 for IPXWAN packet or IPX is not enabled!
1646
1647 */
1648
1649 static int handle_IPXWAN(unsigned char *sendpacket, char *devname, unsigned char enable_IPX, unsigned long network_number)
1650 {
1651         int i;
1652
1653         if( sendpacket[1] == 0x00 &&
1654             sendpacket[2] == 0x80 &&
1655             sendpacket[6] == 0x81 &&
1656             sendpacket[7] == 0x37) {
1657
1658                 if(!enable_IPX) {
1659                         return 1;
1660                 }
1661         } else {
1662                 return 0;
1663         }
1664
1665         if( sendpacket[24] == 0x90 &&
1666             sendpacket[25] == 0x04)
1667         {
1668                 if( sendpacket[10] == 0x02 &&
1669                     sendpacket[42] == 0x00)
1670                 {
1671                         printk(KERN_INFO "%s: Received IPXWAN Timer Request packet\n",devname);
1672
1673                         for(i = 49; sendpacket[i] == 0x00; i += 5)
1674                         {
1675                                 if( sendpacket[i + 4] != 0x02)
1676                                 {
1677                                         sendpacket[i + 1] = 0;
1678                                 }
1679                         }
1680
1681                         if( sendpacket[i] == 0x04 )
1682                         {
1683                                 i += 8;
1684                         }
1685
1686                         for(; sendpacket[i] == 0x80 ;)
1687                         {
1688                                 sendpacket[i + 1] = 0;
1689                                 i += (sendpacket[i + 2] << 8) + (sendpacket[i + 3]) + 4;
1690                         }
1691
1692                         sendpacket[42] = 0x01;
1693
1694                         printk(KERN_INFO "%s: Sending IPXWAN Timer Response\n",devname);
1695                 }
1696                 else if( sendpacket[42] == 0x02 )
1697                 {
1698                         printk(KERN_INFO "%s: Received IPXWAN Information Request packet\n",devname);
1699
1700                         sendpacket[42] = 0x03;
1701
1702                         sendpacket[59] = 'F';
1703                         sendpacket[60] = 'P';
1704                         sendpacket[61] = 'I';
1705                         sendpacket[62] = 'P';
1706                         sendpacket[63] = 'E';
1707                         sendpacket[64] = '-';
1708                         sendpacket[65] = CVHexToAscii(network_number >> 28);
1709                         sendpacket[66] = CVHexToAscii((network_number & 0x0F000000)>> 24);
1710                         sendpacket[67] = CVHexToAscii((network_number & 0x00F00000)>> 20);
1711                         sendpacket[68] = CVHexToAscii((network_number & 0x000F0000)>> 16);
1712                         sendpacket[69] = CVHexToAscii((network_number & 0x0000F000)>> 12);
1713                         sendpacket[70] = CVHexToAscii((network_number & 0x00000F00)>> 8);
1714                         sendpacket[71] = CVHexToAscii((network_number & 0x000000F0)>> 4);
1715                         sendpacket[72] = CVHexToAscii(network_number & 0x0000000F);
1716                         for(i = 73; i < 107; i+= 1)
1717                         {
1718                                 sendpacket[i] = 0;
1719                         }
1720
1721                         printk(KERN_INFO "%s: Sending IPXWAN Information Response packet\n",devname);
1722                 }
1723                 else
1724                 {
1725                         printk(KERN_INFO "%s: Unknown IPXWAN packet!\n",devname);
1726                         return 0;
1727                 }
1728
1729                 sendpacket[43] = (unsigned char)(network_number >> 24);
1730                 sendpacket[44] = (unsigned char)((network_number & 0x00FF0000) >> 16);
1731                 sendpacket[45] = (unsigned char)((network_number & 0x0000FF00) >> 8);
1732                 sendpacket[46] = (unsigned char)(network_number & 0x000000FF);
1733
1734                 return 1;
1735         }
1736
1737         switch_net_numbers(sendpacket, network_number ,1);
1738         return 0;
1739 }
1740
1741
1742 /****** Background Polling Routines  ****************************************/
1743
1744 /*============================================================================
1745  * Main polling routine.
1746  * This routine is repeatedly called by the WANPIPE 'thead' to allow for
1747  * time-dependent housekeeping work.
1748  *
1749  * o fetch asynchronous network events.
1750  *
1751  * Notes:
1752  * 1. This routine may be called on interrupt context with all interrupts
1753  *    enabled. Beware!
1754  */
1755
1756 static void wpf_poll(sdla_t * card)
1757 {
1758         fr508_flags_t *flags;
1759         unsigned long host_cpu_flags;
1760
1761         ++card->statistics.poll_entry;
1762
1763         if (((jiffies - card->state_tick) < HZ) ||
1764                                 (card->intr_mode == INTR_TEST_MODE))
1765                 return;
1766
1767         disable_irq(card->hw.irq);
1768         ++card->irq_dis_poll_count;
1769
1770         if (test_and_set_bit(0, (void *)&card->wandev.critical))
1771         {
1772                 ++ card->statistics.poll_already_critical;
1773                 save_flags(host_cpu_flags);
1774                 cli();
1775                 if ((!card->irq_dis_if_send_count) &&
1776                                 (!(--card->irq_dis_poll_count)))
1777                         enable_irq(card->hw.irq);
1778                 restore_flags(host_cpu_flags);
1779
1780                 return;
1781         }
1782
1783         card->wandev.critical = 0x11;
1784
1785         ++ card->statistics.poll_processed;
1786
1787         if (flags->event) {
1788                 fr_mbox_t* mbox = card->mbox;
1789                 int err;
1790
1791                 memset(&mbox->cmd, 0, sizeof(fr_cmd_t));
1792                 mbox->cmd.command = FR_READ_STATUS;
1793                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
1794                 if (err)
1795                         fr_event(card, err, mbox);
1796         }
1797
1798         card->wandev.critical = 0;
1799
1800         save_flags(host_cpu_flags);
1801         cli();
1802         if ((!card->irq_dis_if_send_count) && (!(--card->irq_dis_poll_count)))
1803                 enable_irq(card->hw.irq);
1804         restore_flags(host_cpu_flags);
1805
1806         card->state_tick = jiffies;
1807 }
1808
1809
1810 /****** Frame Relay Firmware-Specific Functions *****************************/
1811
1812 /*============================================================================
1813  * Read firmware code version.
1814  * o fill string str with firmware version info.
1815  */
1816 static int fr_read_version(sdla_t * card, char *str)
1817 {
1818         fr_mbox_t *mbox = card->mbox;
1819         int retry = MAX_CMD_RETRY;
1820         int err;
1821
1822         do {
1823                 memset(&mbox->cmd, 0, sizeof(fr_cmd_t));
1824                 mbox->cmd.command = FR_READ_CODE_VERSION;
1825                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
1826         }
1827         while (err && retry-- && fr_event(card, err, mbox));
1828         if (!err && str) {
1829                 int len = mbox->cmd.length;
1830
1831                 memcpy(str, mbox->data, len);
1832                 str[len] = '\0';
1833         }
1834         return err;
1835 }
1836
1837 /*============================================================================
1838  * Set global configuration.
1839  */
1840 static int fr_configure(sdla_t * card, fr_conf_t * conf)
1841 {
1842         fr_mbox_t *mbox = card->mbox;
1843         int retry = MAX_CMD_RETRY;
1844         int dlci_num = card->u.f.dlci_num;
1845         int err, i;
1846
1847         do {
1848                 memset(&mbox->cmd, 0, sizeof(fr_cmd_t));
1849                 memcpy(mbox->data, conf, sizeof(fr_conf_t));
1850
1851                 if (dlci_num) for (i = 0; i < dlci_num; ++i)
1852                         ((fr_conf_t*)mbox->data)->dlci[i] =
1853                                         card->u.f.node_dlci[i];
1854
1855                 mbox->cmd.command = FR_SET_CONFIG;
1856                 mbox->cmd.length =
1857                     sizeof(fr_conf_t) + dlci_num * sizeof(short);
1858                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
1859         }
1860         while (err && retry-- && fr_event(card, err, mbox));
1861         return err;
1862 }
1863
1864 /*============================================================================
1865  * Set DLCI configuration.
1866  */
1867 static int fr_dlci_configure (sdla_t* card, fr_dlc_conf_t *conf, unsigned dlci)
1868 {
1869         fr_mbox_t* mbox = card->mbox;
1870         int retry = MAX_CMD_RETRY;
1871         int err;
1872
1873         do
1874         {
1875                 memset(&mbox->cmd, 0, sizeof(fr_cmd_t));
1876                 memcpy(mbox->data, conf, sizeof(fr_dlc_conf_t));
1877                 mbox->cmd.dlci = (unsigned short) dlci;
1878                 mbox->cmd.command = FR_SET_CONFIG;
1879                 mbox->cmd.length = 0x0E;
1880
1881                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
1882
1883         } while (err && retry--);
1884
1885         return err;
1886 }
1887
1888 /*============================================================================
1889  * Set interrupt mode.
1890  */
1891 static int fr_set_intr_mode(sdla_t * card, unsigned mode, unsigned mtu)
1892 {
1893         fr_mbox_t *mbox = card->mbox;
1894         int retry = MAX_CMD_RETRY;
1895         int err;
1896
1897         do {
1898                 memset(&mbox->cmd, 0, sizeof(fr_cmd_t));
1899                 if (card->hw.fwid == SFID_FR502) {
1900                         fr502_intr_ctl_t *ictl = (void *) mbox->data;
1901
1902                         memset(ictl, 0, sizeof(fr502_intr_ctl_t));
1903                         ictl->mode = mode;
1904                         ictl->tx_len = mtu;
1905                         mbox->cmd.length = sizeof(fr502_intr_ctl_t);
1906                 } else {
1907                         fr508_intr_ctl_t *ictl = (void *) mbox->data;
1908
1909                         memset(ictl, 0, sizeof(fr508_intr_ctl_t));
1910                         ictl->mode = mode;
1911                         ictl->tx_len = mtu;
1912                         ictl->irq = card->hw.irq;
1913                         mbox->cmd.length = sizeof(fr508_intr_ctl_t);
1914                 }
1915                 mbox->cmd.command = FR_SET_INTR_MODE;
1916                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
1917         }
1918         while (err && retry-- && fr_event(card, err, mbox));
1919         return err;
1920 }
1921
1922 /*============================================================================
1923  * Enable communications.
1924  */
1925 static int fr_comm_enable(sdla_t * card)
1926 {
1927         fr_mbox_t *mbox = card->mbox;
1928         int retry = MAX_CMD_RETRY;
1929         int err;
1930
1931         do {
1932                 memset(&mbox->cmd, 0, sizeof(fr_cmd_t));
1933                 mbox->cmd.command = FR_COMM_ENABLE;
1934                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
1935         }
1936         while (err && retry-- && fr_event(card, err, mbox));
1937         return err;
1938 }
1939
1940 /*============================================================================
1941  * Disable communications.
1942  */
1943 static int fr_comm_disable(sdla_t * card)
1944 {
1945         fr_mbox_t *mbox = card->mbox;
1946         int retry = MAX_CMD_RETRY;
1947         int err;
1948
1949         do {
1950                 memset(&mbox->cmd, 0, sizeof(fr_cmd_t));
1951                 mbox->cmd.command = FR_COMM_DISABLE;
1952                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
1953         }
1954         while (err && retry-- && fr_event(card, err, mbox));
1955         return err;
1956 }
1957
1958 /*============================================================================
1959  * Get communications error statistics.
1960  */
1961 static int fr_get_err_stats(sdla_t * card)
1962 {
1963         fr_mbox_t *mbox = card->mbox;
1964         int retry = MAX_CMD_RETRY;
1965         int err;
1966
1967         do {
1968                 memset(&mbox->cmd, 0, sizeof(fr_cmd_t));
1969                 mbox->cmd.command = FR_READ_ERROR_STATS;
1970                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
1971         }
1972         while (err && retry-- && fr_event(card, err, mbox));
1973
1974         if (!err) {
1975                 fr_comm_stat_t* stats = (void*)mbox->data;
1976
1977                 card->wandev.stats.rx_over_errors    = stats->rx_overruns;
1978                 card->wandev.stats.rx_crc_errors     = stats->rx_bad_crc;
1979                 card->wandev.stats.rx_missed_errors  = stats->rx_aborts;
1980                 card->wandev.stats.rx_length_errors  = stats->rx_too_long;
1981                 card->wandev.stats.tx_aborted_errors = stats->tx_aborts;
1982         }
1983         return err;
1984 }
1985
1986 /*============================================================================
1987  * Get statistics.
1988  */
1989 static int fr_get_stats(sdla_t * card)
1990 {
1991         fr_mbox_t *mbox = card->mbox;
1992         int retry = MAX_CMD_RETRY;
1993         int err;
1994
1995         do {
1996                 memset(&mbox->cmd, 0, sizeof(fr_cmd_t));
1997                 mbox->cmd.command = FR_READ_STATISTICS;
1998                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
1999         }
2000         while (err && retry-- && fr_event(card, err, mbox));
2001
2002         if (!err) {
2003                 fr_link_stat_t *stats = (void *) mbox->data;
2004
2005                 card->wandev.stats.rx_frame_errors = stats->rx_bad_format;
2006                 card->wandev.stats.rx_dropped =
2007                     stats->rx_dropped + stats->rx_dropped2
2008                     ;
2009         }
2010         return err;
2011 }
2012
2013 /*============================================================================
2014  * Add DLCI(s) (Access Node only!).
2015  */
2016
2017 static int fr_add_dlci(sdla_t * card, int dlci, int num)
2018 {
2019         fr_mbox_t *mbox = card->mbox;
2020         int retry = MAX_CMD_RETRY;
2021         int err, i;
2022
2023         do {
2024                 unsigned short *dlci_list = (void *) mbox->data;
2025
2026                 memset(&mbox->cmd, 0, sizeof(fr_cmd_t));
2027                 for (i = 0; i < num; ++i)
2028                         dlci_list[i] = card->u.f.node_dlci[i];
2029
2030                 mbox->cmd.length = num * sizeof(short);
2031                 mbox->cmd.command = FR_ADD_DLCI;
2032                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2033         }
2034         while (err && retry-- && fr_event(card, err, mbox));
2035         return err;
2036 }
2037
2038 /*============================================================================
2039  * Activate DLCI(s) (Access Node only!).
2040  */
2041 static int fr_activate_dlci(sdla_t * card, int dlci, int num)
2042 {
2043         fr_mbox_t *mbox = card->mbox;
2044         int retry = MAX_CMD_RETRY;
2045         int err, i;
2046
2047         do {
2048                 unsigned short *dlci_list = (void *) mbox->data;
2049
2050                 memset(&mbox->cmd, 0, sizeof(fr_cmd_t));
2051                 for (i = 0; i < num; ++i)
2052                         dlci_list[i] = card->u.f.node_dlci[i];
2053
2054                 mbox->cmd.length = num * sizeof(short);
2055                 mbox->cmd.command = FR_ACTIVATE_DLCI;
2056                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2057         }
2058         while (err && retry-- && fr_event(card, err, mbox));
2059         return err;
2060 }
2061
2062 /*============================================================================
2063  * Issue in-channel signalling frame.
2064  */
2065 static int fr_issue_isf(sdla_t * card, int isf)
2066 {
2067         fr_mbox_t *mbox = card->mbox;
2068         int retry = MAX_CMD_RETRY;
2069         int err;
2070
2071         do {
2072                 memset(&mbox->cmd, 0, sizeof(fr_cmd_t));
2073                 mbox->data[0] = isf;
2074                 mbox->cmd.length = 1;
2075                 mbox->cmd.command = FR_ISSUE_IS_FRAME;
2076                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2077         }
2078         while (err && retry-- && fr_event(card, err, mbox));
2079         return err;
2080 }
2081
2082 /*============================================================================
2083  * Send a frame (S502 version).
2084  */
2085 static int fr502_send(sdla_t * card, int dlci, int attr, int len, void *buf)
2086 {
2087         fr_mbox_t *mbox = card->mbox;
2088         int retry = MAX_CMD_RETRY;
2089         int err;
2090
2091         do {
2092                 memset(&mbox->cmd, 0, sizeof(fr_cmd_t));
2093                 memcpy(mbox->data, buf, len);
2094                 mbox->cmd.dlci = dlci;
2095                 mbox->cmd.attr = attr;
2096                 mbox->cmd.length = len;
2097                 mbox->cmd.command = FR_WRITE;
2098                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2099         }
2100         while (err && retry-- && fr_event(card, err, mbox));
2101         return err;
2102 }
2103
2104 /*============================================================================
2105  * Send a frame (S508 version).
2106  */
2107 static int fr508_send(sdla_t * card, int dlci, int attr, int len, void *buf)
2108 {
2109         fr_mbox_t *mbox = card->mbox;
2110         int retry = MAX_CMD_RETRY;
2111         int err;
2112
2113         do {
2114                 memset(&mbox->cmd, 0, sizeof(fr_cmd_t));
2115                 mbox->cmd.dlci = dlci;
2116                 mbox->cmd.attr = attr;
2117                 mbox->cmd.length = len;
2118                 mbox->cmd.command = FR_WRITE;
2119                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2120         }
2121         while (err && retry-- && fr_event(card, err, mbox));
2122
2123         if (!err) {
2124                 fr_buf_ctl_t *frbuf = (void *) (*(unsigned long *) mbox->data -
2125                                         FR_MB_VECTOR + card->hw.dpmbase);
2126                 sdla_poke(&card->hw, frbuf->offset, buf, len);
2127                 frbuf->flag = 0x01;
2128         }
2129         return err;
2130 }
2131
2132 /****** Firmware Asynchronous Event Handlers ********************************/
2133
2134 /*============================================================================
2135  * Main asyncronous event/error handler.
2136  *      This routine is called whenever firmware command returns non-zero
2137  *      return code.
2138  *
2139  * Return zero if previous command has to be cancelled.
2140  */
2141 static int fr_event(sdla_t * card, int event, fr_mbox_t * mbox)
2142 {
2143         fr508_flags_t* flags = card->flags;
2144         char *ptr = &flags->iflag;
2145         int i;
2146
2147         switch (event)
2148         {
2149                 case FRRES_MODEM_FAILURE:
2150                         return fr_modem_failure(card, mbox);
2151
2152                 case FRRES_CHANNEL_DOWN:
2153                         wanpipe_set_state(card, WAN_DISCONNECTED);
2154                         return 1;
2155
2156                 case FRRES_CHANNEL_UP:
2157                         wanpipe_set_state(card, WAN_CONNECTED);
2158                         return 1;
2159
2160                 case FRRES_DLCI_CHANGE:
2161                         return fr_dlci_change(card, mbox);
2162
2163                 case FRRES_DLCI_MISMATCH:
2164                         printk(KERN_INFO "%s: DLCI list mismatch!\n", card->devname);
2165                         return 1;
2166
2167                 case CMD_TIMEOUT:
2168                         printk(KERN_ERR "%s: command 0x%02X timed out!\n",
2169                                card->devname, mbox->cmd.command);
2170                         printk(KERN_INFO "%s: ID Bytes = ",card->devname);
2171                         for(i = 0; i < 8; i ++)
2172                                 printk(KERN_INFO "0x%02X ", *(ptr + 0x28 + i));
2173                         printk(KERN_INFO "\n");
2174                         break;
2175
2176                 case FRRES_DLCI_INACTIVE:
2177                         printk(KERN_ERR "%s: DLCI %u is inactive!\n",
2178                                 card->devname, mbox->cmd.dlci);
2179                         break;
2180
2181                 case FRRES_CIR_OVERFLOW:
2182                         break;
2183                 case FRRES_BUFFER_OVERFLOW:
2184                         break;
2185                 default:
2186                         printk(KERN_INFO "%s: command 0x%02X returned 0x%02X!\n",
2187                                 card->devname, mbox->cmd.command, event);
2188         }
2189         return 0;
2190 }
2191
2192 /*============================================================================
2193  * Handle modem error.
2194  *
2195  * Return zero if previous command has to be cancelled.
2196  */
2197 static int fr_modem_failure(sdla_t * card, fr_mbox_t * mbox)
2198 {
2199         printk(KERN_INFO "%s: physical link down! (modem error 0x%02X)\n",
2200                card->devname, mbox->data[0]);
2201         switch (mbox->cmd.command)
2202         {
2203                 case FR_WRITE:
2204                 case FR_READ:
2205                         return 0;
2206         }
2207         return 1;
2208 }
2209
2210 /*============================================================================
2211  * Handle DLCI status change.
2212  *
2213  * Return zero if previous command has to be cancelled.
2214  */
2215 static int fr_dlci_change(sdla_t * card, fr_mbox_t * mbox)
2216 {
2217         dlci_status_t *status = (void *) mbox->data;
2218         int cnt = mbox->cmd.length / sizeof(dlci_status_t);
2219         fr_dlc_conf_t cfg;
2220         fr_channel_t *chan;
2221         struct device* dev2;
2222
2223         for (; cnt; --cnt, ++status) {
2224                 unsigned short dlci = status->dlci;
2225                 struct device *dev = find_channel(card, dlci);
2226
2227                 if (dev == NULL)
2228                 {
2229                         printk(KERN_INFO "%s: CPE contains unconfigured DLCI= %d\n",
2230                                 card->devname, dlci);
2231                 }
2232                 else
2233                 {
2234                         if (status->state & 0x01)
2235                         {
2236                                 printk(KERN_INFO
2237                                        "%s: DLCI %u has been deleted!\n",
2238                                        card->devname, dlci);
2239                                 if (dev && dev->start)
2240                                         set_chan_state(dev, WAN_DISCONNECTED);
2241                         }
2242                         else if (status->state & 0x02)
2243                         {
2244                                 printk(KERN_INFO
2245                                         "%s: DLCI %u becomes active!\n",
2246                                         card->devname, dlci);
2247                                 chan = dev->priv;
2248                                 /* This flag is used for configuring specific
2249                                    DLCI(s) when they become active.
2250                                 */
2251                                 chan->dlci_configured = DLCI_CONFIG_PENDING;
2252
2253                                 if (dev && dev->start)
2254                                         set_chan_state(dev, WAN_CONNECTED);
2255                         }
2256                 }
2257         }
2258
2259         for (dev2 =card->wandev.dev; dev2; dev2 = dev2->slave)
2260         {
2261                 chan = dev2->priv;
2262
2263                 if (chan->dlci_configured == DLCI_CONFIG_PENDING)
2264                 {
2265                         memset(&cfg, 0, sizeof(cfg));
2266
2267                         if ( chan->cir_status == CIR_DISABLED)
2268                         {
2269                                 cfg.cir_fwd = cfg.cir_bwd  = 16;
2270                                 cfg.bc_fwd = cfg.bc_bwd = 16;
2271                                 cfg.conf_flags = 0x0001;
2272                                 printk(KERN_INFO "%s: CIR Disabled for %s\n",
2273                                         card->devname, chan->name);
2274                         }
2275                         else if (chan->cir_status == CIR_ENABLED)
2276                         {
2277                                 cfg.cir_fwd = cfg.cir_bwd = chan->cir;
2278                                 cfg.bc_fwd  = cfg.bc_bwd  = chan->bc;
2279                                 cfg.be_fwd  = cfg.be_bwd  = chan->be;
2280                                 cfg.conf_flags = 0x0000;
2281                                 printk(KERN_INFO "%s: CIR Enabled for %s\n",
2282                                         card->devname, chan->name);
2283
2284                         }
2285
2286                         if (fr_dlci_configure( card, &cfg , chan->dlci))
2287                         {
2288                                 printk(KERN_INFO
2289                                         "%s: DLCI Configure failed for %d\n",
2290                                         card->devname, chan->dlci);
2291                                 return 1;
2292                         }
2293
2294                         chan->dlci_configured = DLCI_CONFIGURED;
2295
2296                         /*
2297                          *      Read the interface byte mapping into the channel
2298                          *      structure.
2299                          */
2300                         if (card->intr_mode == DLCI_LIST_INTR_MODE)
2301                                 read_DLCI_IB_mapping( card, chan );
2302                 }
2303         }
2304         return 1;
2305 }
2306
2307 /******* Miscellaneous ******************************************************/
2308
2309 /*============================================================================
2310  * Update channel state.
2311  */
2312 static int update_chan_state(struct device *dev)
2313 {
2314         fr_channel_t *chan = dev->priv;
2315         sdla_t *card = chan->card;
2316         fr_mbox_t *mbox = card->mbox;
2317         int retry = MAX_CMD_RETRY;
2318         int err;
2319         int dlci_found = 0;
2320
2321         do {
2322                 memset(&mbox->cmd, 0, sizeof(fr_cmd_t));
2323                 mbox->cmd.command = FR_LIST_ACTIVE_DLCI;
2324                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2325         }
2326         while (err && retry-- && fr_event(card, err, mbox));
2327
2328         if (!err) {
2329                 unsigned short *list = (void *) mbox->data;
2330                 int cnt = mbox->cmd.length / sizeof(short);
2331
2332                 for (; cnt; --cnt, ++list)
2333                 {
2334                         if (*list == chan->dlci)
2335                         {
2336                                 dlci_found = 1;
2337                                 set_chan_state(dev, WAN_CONNECTED);
2338                                 break;
2339                         }
2340                 }
2341
2342                 if(!dlci_found)
2343                         printk(KERN_INFO "%s: DLCI %u is inactive\n",
2344                                 card->devname, chan->dlci);
2345         }
2346         return err;
2347 }
2348
2349 /*============================================================================
2350  * Set channel state.
2351  */
2352 static void set_chan_state(struct device *dev, int state)
2353 {
2354         fr_channel_t *chan = dev->priv;
2355         sdla_t *card = chan->card;
2356         unsigned long flags;
2357
2358         save_flags(flags);
2359         cli();
2360
2361         if (chan->state != state)
2362         {
2363                 switch (state)
2364                 {
2365                         case WAN_CONNECTED:
2366                                 printk(KERN_INFO "%s: interface %s connected!\n"
2367                                         , card->devname, dev->name);
2368                                 break;
2369                         case WAN_CONNECTING:
2370                                 printk(KERN_INFO
2371                                         "%s: interface %s connecting...\n",
2372                                         card->devname, dev->name);
2373                                 break;
2374                         case WAN_DISCONNECTED:
2375                                 printk (KERN_INFO
2376                                         "%s: interface %s disconnected!\n",
2377                                         card->devname, dev->name);
2378                                 break;
2379                 }
2380                 chan->state = state;
2381         }
2382         chan->state_tick = jiffies;
2383         restore_flags(flags);
2384 }
2385
2386 /*============================================================================
2387  * Find network device by its channel number.
2388  */
2389 static struct device *find_channel(sdla_t * card, unsigned dlci)
2390 {
2391         struct device *dev;
2392
2393         for (dev = card->wandev.dev; dev; dev = dev->slave)
2394                 if (((fr_channel_t *) dev->priv)->dlci == dlci)
2395                         break
2396                             ;
2397         return dev;
2398 }
2399
2400 /*============================================================================
2401  * Check to see if a frame can be sent. If no transmit buffers available,
2402  * enable transmit interrupts.
2403  *
2404  * Return:      1 - Tx buffer(s) available
2405  *              0 - no buffers available
2406  */
2407
2408 static int is_tx_ready(sdla_t * card)
2409 {
2410         if (card->hw.fwid == SFID_FR508)
2411         {
2412                 unsigned char sb = inb(card->hw.port);
2413
2414                 if (sb & 0x02)
2415                         return 1;
2416         } else {
2417                 fr502_flags_t* flags = card->flags;
2418
2419                 if (flags->tx_ready)
2420                         return 1;
2421                 flags->imask |= 0x02;
2422         }
2423         return 0;
2424 }
2425
2426 /*============================================================================
2427  * Convert decimal string to unsigned integer.
2428  * If len != 0 then only 'len' characters of the string are converted.
2429  */
2430 static unsigned int dec_to_uint(unsigned char *str, int len)
2431 {
2432         unsigned val;
2433
2434         if (!len)
2435                 len = strlen(str);
2436         for (val = 0; len && is_digit(*str); ++str, --len)
2437                 val = (val * 10) + (*str - (unsigned) '0');
2438         return val;
2439 }
2440
2441 /*==============================================================================
2442  * Perform the Interrupt Test by running the READ_CODE_VERSION command MAX_INTR_
2443  * TEST_COUNTER times.
2444  */
2445 static int intr_test( sdla_t* card )
2446 {
2447         fr_mbox_t* mb = card->mbox;
2448         int err,i;
2449
2450         /*
2451          *       The critical flag is unset here because we want to get into the
2452          *      ISR without the flag already set. The If_open sets the flag.
2453          */
2454
2455         card->wandev.critical = 0;
2456
2457         err = fr_set_intr_mode( card, 0x08, card->wandev.mtu );
2458
2459         if (err == CMD_OK)
2460         {
2461                 for ( i = 0; i < MAX_INTR_TEST_COUNTER; i++ )
2462                 {
2463                         /* Run command READ_CODE_VERSION */
2464                         memset(&mb->cmd, 0, sizeof(fr_cmd_t));
2465                         mb->cmd.length  = 0;
2466                         mb->cmd.command = 0x40;
2467                         err = sdla_exec(mb) ? mb->cmd.result : CMD_TIMEOUT;
2468
2469                         if (err != CMD_OK)
2470                                 fr_event(card, err, mb);
2471                 }
2472         }
2473         else
2474                 return err;
2475
2476         err = fr_set_intr_mode( card, 0, card->wandev.mtu );
2477
2478         if( err != CMD_OK )
2479                 return err;
2480
2481         card->wandev.critical = 1;
2482         return 0;
2483 }
2484
2485 /*==============================================================================
2486  * Initializes the Statistics values in the Sdla_t structure.
2487  */
2488
2489 void init_global_statistics( sdla_t* card )
2490 {
2491         /* Intialize global statistics for a card */
2492         card->statistics.isr_entry                = 0;
2493         card->statistics.isr_already_critical     = 0;
2494         card->statistics.isr_rx                   = 0;
2495         card->statistics.isr_tx                   = 0;
2496         card->statistics.isr_intr_test            = 0;
2497         card->statistics.isr_spurious             = 0;
2498         card->statistics.isr_enable_tx_int        = 0;
2499         card->statistics.rx_intr_corrupt_rx_bfr   = 0;
2500         card->statistics.rx_intr_on_orphaned_DLCI = 0;
2501         card->statistics.tx_intr_dev_not_started  = 0;
2502         card->statistics.poll_entry               = 0;
2503         card->statistics.poll_already_critical    = 0;
2504         card->statistics.poll_processed           = 0;
2505 }
2506
2507 static void read_DLCI_IB_mapping( sdla_t* card, fr_channel_t* chan )
2508 {
2509         fr_mbox_t* mbox = card->mbox;
2510         int retry = MAX_CMD_RETRY;
2511         dlci_IB_mapping_t* result;
2512         int err, counter, found;
2513
2514         do {
2515                 memset(&mbox->cmd, 0, sizeof(fr_cmd_t));
2516                 mbox->cmd.command = FR_READ_DLCI_IB_MAPPING;
2517
2518                 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2519
2520         } while (err && retry-- && fr_event(card, err, mbox));
2521
2522         if( mbox->cmd.result != 0)
2523                 printk(KERN_INFO "%s: Read DLCI IB Mapping failed\n",
2524                         chan->name);
2525
2526         counter = mbox->cmd.length / sizeof(dlci_IB_mapping_t);
2527         result = (void *)mbox->data;
2528
2529         found = 0;
2530         for (; counter; --counter, ++result) {
2531                 if ( result->dlci == chan->dlci ) {
2532                         printk( KERN_INFO "%s: DLCI= %d, IB addr = %lx for %s\n"
2533                                 ,card->devname,result->dlci, result->addr_value
2534                                 ,chan->name);
2535                         chan->IB_addr = result->addr_value;
2536                         chan->dlci_int_interface = (void*)(card->hw.dpmbase +
2537                                         ( chan->IB_addr & 0x00001FFF));
2538                         found = 1;
2539                         break;
2540                 }
2541         }
2542         if (!found)
2543                 printk( KERN_INFO "%s: DLCI %d not found by IB MAPPING cmd\n",
2544                 card->devname, chan->dlci);
2545 }
2546
2547 /****** End *****************************************************************/