1 /*****************************************************************************
2 * sdla_fr.c WANPIPE(tm) Multiprotocol WAN Link Driver. Frame relay module.
4 * Author(s): Nenad Corbic <ncorbic@sangoma.com>
7 * Copyright: (c) 1995-2001 Sangoma Technologies Inc.
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version
12 * 2 of the License, or (at your option) any later version.
13 * ============================================================================
14 * Nov 23, 2000 Nenad Corbic o Added support for 2.4.X kernels
15 * Nov 15, 2000 David Rokavarg
16 * Nenad Corbic o Added frame relay bridging support.
17 * Original code from Mark Wells and Kristian Hoffmann has
18 * been integrated into the frame relay driver.
19 * Nov 13, 2000 Nenad Corbic o Added true interface type encoding option.
20 * Tcpdump doesn't support Frame Relay inteface
21 * types, to fix this true type option will set
22 * the interface type to RAW IP mode.
23 * Nov 07, 2000 Nenad Corbic o Added security features for UDP debugging:
24 * Deny all and specify allowed requests.
25 * Nov 06, 2000 Nenad Corbic o Wanpipe interfaces conform to raw packet interfaces.
26 * Moved the if_header into the if_send() routine.
27 * The if_header() was breaking the libpcap
28 * support. i.e. support for tcpdump, ethereal ...
29 * Oct 12. 2000 Nenad Corbic o Added error message in fr_configure
30 * Jul 31, 2000 Nenad Corbic o Fixed the Router UP Time.
31 * Apr 28, 2000 Nenad Corbic o Added the option to shutdown an interface
32 * when the channel gets disconnected.
33 * Apr 28, 2000 Nenad Corbic o Added M.Grants patch: disallow duplicate
35 * Apr 25, 2000 Nenad Corbic o Added M.Grants patch: dynamically add/remove
36 * new dlcis/interfaces.
37 * Mar 23, 2000 Nenad Corbic o Improved task queue, bh handling.
38 * Mar 16, 2000 Nenad Corbic o Added Inverse ARP support
39 * Mar 13, 2000 Nenad Corbic o Added new socket API support.
40 * Mar 06, 2000 Nenad Corbic o Bug Fix: corrupted mbox recovery.
41 * Feb 24, 2000 Nenad Corbic o Fixed up FT1 UDP debugging problem.
42 * Dev 15, 1999 Nenad Corbic o Fixed up header files for 2.0.X kernels
44 * Nov 08, 1999 Nenad Corbic o Combined all debug UDP calls into one function
45 * o Removed the ARP support. This has to be done
46 * in the next version.
47 * o Only a Node can implement NO signalling.
48 * Initialize DLCI during if_open() if NO
50 * o Took out IPX support, implement in next
52 * Sep 29, 1999 Nenad Corbic o Added SMP support and changed the update
53 * function to use timer interrupt.
54 * o Fixed the CIR bug: Set the value of BC
55 * to CIR when the CIR is enabled.
56 * o Updated comments, statistics and tracing.
57 * Jun 02, 1999 Gideon Hack o Updated for S514 support.
58 * Sep 18, 1998 Jaspreet Singh o Updated for 2.2.X kernels.
59 * Jul 31, 1998 Jaspreet Singh o Removed wpf_poll routine. The channel/DLCI
60 * status is received through an event interrupt.
61 * Jul 08, 1998 David Fong o Added inverse ARP support.
62 * Mar 26, 1997 Jaspreet Singh o Returning return codes for failed UDP cmds.
63 * Jan 28, 1997 Jaspreet Singh o Improved handling of inactive DLCIs.
64 * Dec 30, 1997 Jaspreet Singh o Replaced dev_tint() with mark_bh(NET_BH)
65 * Dec 16, 1997 Jaspreet Singh o Implemented Multiple IPX support.
66 * Nov 26, 1997 Jaspreet Singh o Improved load sharing with multiple boards
67 * o Added Cli() to protect enabling of interrupts
68 * while polling is called.
69 * Nov 24, 1997 Jaspreet Singh o Added counters to avoid enabling of interrupts
70 * when they have been disabled by another
71 * interface or routine (eg. wpf_poll).
72 * Nov 06, 1997 Jaspreet Singh o Added INTR_TEST_MODE to avoid polling
73 * routine disable interrupts during interrupt
75 * Oct 20, 1997 Jaspreet Singh o Added hooks in for Router UP time.
76 * Oct 16, 1997 Jaspreet Singh o The critical flag is used to maintain flow
77 * control by avoiding RACE conditions. The
78 * cli() and restore_flags() are taken out.
79 * The fr_channel structure is appended for
81 * Oct 15, 1997 Farhan Thawar o updated if_send() and receive for IPX
82 * Aug 29, 1997 Farhan Thawar o Removed most of the cli() and sti()
83 * o Abstracted the UDP management stuff
84 * o Now use tbusy and critical more intelligently
85 * Jul 21, 1997 Jaspreet Singh o Can configure T391, T392, N391, N392 & N393
86 * through router.conf.
87 * o Protected calls to sdla_peek() by adDing
88 * save_flags(), cli() and restore_flags().
89 * o Added error message for Inactive DLCIs in
90 * fr_event() and update_chan_state().
91 * o Fixed freeing up of buffers using kfree()
92 * when packets are received.
93 * Jul 07, 1997 Jaspreet Singh o Added configurable TTL for UDP packets
94 * o Added ability to discard multicast and
95 * broadcast source addressed packets
96 * Jun 27, 1997 Jaspreet Singh o Added FT1 monitor capabilities
97 * New case (0x44) statement in if_send routine
98 * Added a global variable rCount to keep track
99 * of FT1 status enabled on the board.
100 * May 29, 1997 Jaspreet Singh o Fixed major Flow Control Problem
101 * With multiple boards a problem was seen where
102 * the second board always stopped transmitting
103 * packet after running for a while. The code
104 * got into a stage where the interrupts were
105 * disabled and dev->tbusy was set to 1.
106 * This caused the If_send() routine to get into
107 * the if clause for it(0,dev->tbusy)
109 * The code got into this stage due to an
110 * interrupt occurring within the if clause for
111 * set_bit(0,dev->tbusy). Since an interrupt
112 * disables furhter transmit interrupt and
113 * makes dev->tbusy = 0, this effect was undone
114 * by making dev->tbusy = 1 in the if clause.
115 * The Fix checks to see if Transmit interrupts
116 * are disabled then do not make dev->tbusy = 1
117 * Introduced a global variable: int_occur and
118 * added tx_int_enabled in the wan_device
120 * May 21, 1997 Jaspreet Singh o Fixed UDP Management for multiple
123 * Apr 25, 1997 Farhan Thawar o added UDP Management stuff
124 * o fixed bug in if_send() and tx_intr() to
125 * sleep and wakeup all devices
126 * Mar 11, 1997 Farhan Thawar Version 3.1.1
127 * o fixed (+1) bug in fr508_rx_intr()
128 * o changed if_send() to return 0 if
129 * wandev.critical() is true
130 * o free socket buffer in if_send() if
132 * o added tx_intr() routine
133 * Jan 30, 1997 Gene Kozin Version 3.1.0
134 * o implemented exec() entry point
135 * o fixed a bug causing driver configured as
136 * a FR switch to be stuck in WAN_
138 * Jan 02, 1997 Gene Kozin Initial version.
139 *****************************************************************************/
141 #include <linux/module.h>
142 #include <linux/kernel.h> /* printk(), and other useful stuff */
143 #include <linux/stddef.h> /* offsetof(), etc. */
144 #include <linux/errno.h> /* return codes */
145 #include <linux/string.h> /* inline memset(), etc. */
146 #include <linux/slab.h> /* kmalloc(), kfree() */
147 #include <linux/wanrouter.h> /* WAN router definitions */
148 #include <linux/wanpipe.h> /* WANPIPE common user API definitions */
149 #include <linux/workqueue.h>
150 #include <linux/if_arp.h> /* ARPHRD_* defines */
151 #include <asm/byteorder.h> /* htons(), etc. */
152 #include <asm/io.h> /* for inb(), outb(), etc. */
153 #include <linux/time.h> /* for do_gettimeofday */
154 #include <linux/in.h> /* sockaddr_in */
155 #include <linux/jiffies.h> /* time_after() macro */
156 #include <asm/errno.h>
158 #include <linux/ip.h>
159 #include <linux/if.h>
161 #include <linux/if_wanpipe_common.h> /* Wanpipe Socket */
162 #include <linux/if_wanpipe.h>
164 #include <linux/sdla_fr.h> /* frame relay firmware API definitions */
166 #include <asm/uaccess.h>
167 #include <linux/inetdevice.h>
168 #include <linux/netdevice.h>
170 #include <net/route.h> /* Dynamic Route Creation */
171 #include <linux/etherdevice.h> /* eth_type_trans() used for bridging */
172 #include <linux/random.h>
174 /****** Defines & Macros ****************************************************/
176 #define MAX_CMD_RETRY 10 /* max number of firmware retries */
178 #define FR_HEADER_LEN 8 /* max encapsulation header size */
179 #define FR_CHANNEL_MTU 1500 /* unfragmented logical channel MTU */
181 /* Q.922 frame types */
182 #define Q922_UI 0x03 /* Unnumbered Info frame */
183 #define Q922_XID 0xAF
185 /* DLCI configured or not */
186 #define DLCI_NOT_CONFIGURED 0x00
187 #define DLCI_CONFIG_PENDING 0x01
188 #define DLCI_CONFIGURED 0x02
190 /* CIR enabled or not */
191 #define CIR_ENABLED 0x00
192 #define CIR_DISABLED 0x01
194 #define FRAME_RELAY_API 1
195 #define MAX_BH_BUFF 10
197 /* For handle_IPXWAN() */
198 #define CVHexToAscii(b) (((unsigned char)(b) > (unsigned char)9) ? ((unsigned char)'A' + ((unsigned char)(b) - (unsigned char)10)) : ((unsigned char)'0' + (unsigned char)(b)))
200 /****** Data Structures *****************************************************/
202 /* This is an extention of the 'struct device' we create for each network
203 * interface to keep the rest of channel-specific data.
205 typedef struct fr_channel
207 wanpipe_common_t common;
208 char name[WAN_IFNAME_SZ+1]; /* interface name, ASCIIZ */
209 unsigned dlci_configured ; /* check whether configured or not */
210 unsigned cir_status; /* check whether CIR enabled or not */
211 unsigned dlci; /* logical channel number */
212 unsigned cir; /* committed information rate */
213 unsigned bc; /* committed burst size */
214 unsigned be; /* excess burst size */
215 unsigned mc; /* multicast support on or off */
216 unsigned tx_int_status; /* Transmit Interrupt Status */
217 unsigned short pkt_length; /* Packet Length */
218 unsigned long router_start_time;/* Router start time in seconds */
219 unsigned long tick_counter; /* counter for transmit time out */
220 char dev_pending_devtint; /* interface pending dev_tint() */
221 void *dlci_int_interface; /* pointer to the DLCI Interface */
222 unsigned long IB_addr; /* physical address of Interface Byte */
223 unsigned long state_tick; /* time of the last state change */
224 unsigned char enable_IPX; /* Enable/Disable the use of IPX */
225 unsigned long network_number; /* Internal Network Number for IPX*/
226 sdla_t *card; /* -> owner */
227 unsigned route_flag; /* Add/Rem dest addr in route tables */
228 unsigned inarp; /* Inverse Arp Request status */
229 long inarp_ready; /* Ready to send requests */
230 int inarp_interval; /* Time between InArp Requests */
231 unsigned long inarp_tick; /* InArp jiffies tick counter */
232 long interface_down; /* Bring interface down on disconnect */
233 struct net_device_stats ifstats; /* interface statistics */
234 if_send_stat_t drvstats_if_send;
235 rx_intr_stat_t drvstats_rx_intr;
236 pipe_mgmt_stat_t drvstats_gen;
237 unsigned long router_up_time;
239 unsigned short transmit_length;
240 struct sk_buff *delay_skb;
242 bh_data_t *bh_head; /* Circular buffer for chdlc_bh */
243 unsigned long tq_working;
244 volatile int bh_write;
245 volatile int bh_read;
246 atomic_t bh_buff_used;
248 /* Polling task queue. Each interface
249 * has its own task queue, which is used
250 * to defer events from the interrupt */
251 struct work_struct fr_poll_work;
252 struct timer_list fr_arp_timer;
259 /* Whether this interface should be setup as a gateway.
260 * Used by dynamic route setup code */
263 /* True interface type */
265 u8 fr_header[FR_HEADER_LEN];
270 /* Route Flag options */
271 #define NO_ROUTE 0x00
272 #define ADD_ROUTE 0x01
273 #define ROUTE_ADDED 0x02
274 #define REMOVE_ROUTE 0x03
278 #define INARP_NONE 0x00
279 #define INARP_REQUEST 0x01
280 #define INARP_CONFIGURED 0x02
282 /* reasons for enabling the timer interrupt on the adapter */
283 #define TMR_INT_ENABLED_UDP 0x01
284 #define TMR_INT_ENABLED_UPDATE 0x02
285 #define TMR_INT_ENABLED_ARP 0x04
286 #define TMR_INT_ENABLED_UPDATE_STATE 0x08
287 #define TMR_INT_ENABLED_CONFIG 0x10
288 #define TMR_INT_ENABLED_UNCONFIG 0x20
291 typedef struct dlci_status
293 unsigned short dlci PACKED;
294 unsigned char state PACKED;
297 typedef struct dlci_IB_mapping
299 unsigned short dlci PACKED;
300 unsigned long addr_value PACKED;
303 /* This structure is used for DLCI list Tx interrupt mode. It is used to
304 enable interrupt bit and set the packet length for transmission
306 typedef struct fr_dlci_interface
308 unsigned char gen_interrupt PACKED;
309 unsigned short packet_length PACKED;
310 unsigned char reserved PACKED;
311 } fr_dlci_interface_t;
313 /* variable for keeping track of enabling/disabling FT1 monitor status */
314 static int rCount = 0;
316 extern void disable_irq(unsigned int);
317 extern void enable_irq(unsigned int);
319 /* variable for keeping track of number of interrupts generated during
320 * interrupt test routine
322 static int Intr_test_counter;
324 /****** Function Prototypes *************************************************/
326 /* WAN link driver entry points. These are called by the WAN router module. */
327 static int update(struct wan_device *wandev);
328 static int new_if(struct wan_device *wandev, struct net_device *dev,
330 static int del_if(struct wan_device *wandev, struct net_device *dev);
331 static void disable_comm (sdla_t *card);
333 /* WANPIPE-specific entry points */
334 static int wpf_exec(struct sdla *card, void *u_cmd, void *u_data);
336 /* Network device interface */
337 static int if_init(struct net_device *dev);
338 static int if_open(struct net_device *dev);
339 static int if_close(struct net_device *dev);
341 static void if_tx_timeout(struct net_device *dev);
343 static int if_rebuild_hdr (struct sk_buff *skb);
345 static int if_send(struct sk_buff *skb, struct net_device *dev);
346 static int chk_bcast_mcast_addr(sdla_t *card, struct net_device* dev,
347 struct sk_buff *skb);
348 static struct net_device_stats *if_stats(struct net_device *dev);
350 /* Interrupt handlers */
351 static void fr_isr(sdla_t *card);
352 static void rx_intr(sdla_t *card);
353 static void tx_intr(sdla_t *card);
354 static void timer_intr(sdla_t *card);
355 static void spur_intr(sdla_t *card);
357 /* Frame relay firmware interface functions */
358 static int fr_read_version(sdla_t *card, char *str);
359 static int fr_configure(sdla_t *card, fr_conf_t *conf);
360 static int fr_dlci_configure(sdla_t *card, fr_dlc_conf_t *conf, unsigned dlci);
361 static int fr_init_dlci (sdla_t *card, fr_channel_t *chan);
362 static int fr_set_intr_mode (sdla_t *card, unsigned mode, unsigned mtu, unsigned short timeout);
363 static int fr_comm_enable(sdla_t *card);
364 static void fr_comm_disable(sdla_t *card);
365 static int fr_get_err_stats(sdla_t *card);
366 static int fr_get_stats(sdla_t *card);
367 static int fr_add_dlci(sdla_t *card, int dlci);
368 static int fr_activate_dlci(sdla_t *card, int dlci);
369 static int fr_delete_dlci (sdla_t* card, int dlci);
370 static int fr_issue_isf(sdla_t *card, int isf);
371 static int fr_send(sdla_t *card, int dlci, unsigned char attr, int len,
373 static int fr_send_data_header(sdla_t *card, int dlci, unsigned char attr, int len,
374 void *buf,unsigned char hdr_len);
375 static unsigned int fr_send_hdr(sdla_t *card, int dlci, unsigned int offset);
377 static int check_dlci_config (sdla_t *card, fr_channel_t *chan);
378 static void initialize_rx_tx_buffers (sdla_t *card);
381 /* Firmware asynchronous event handlers */
382 static int fr_event(sdla_t *card, int event, fr_mbox_t *mbox);
383 static int fr_modem_failure(sdla_t *card, fr_mbox_t *mbox);
384 static int fr_dlci_change(sdla_t *card, fr_mbox_t *mbox);
386 /* Miscellaneous functions */
387 static int update_chan_state(struct net_device *dev);
388 static void set_chan_state(struct net_device *dev, int state);
389 static struct net_device *find_channel(sdla_t *card, unsigned dlci);
390 static int is_tx_ready(sdla_t *card, fr_channel_t *chan);
391 static unsigned int dec_to_uint(unsigned char *str, int len);
392 static int reply_udp( unsigned char *data, unsigned int mbox_len );
394 static int intr_test( sdla_t* card );
395 static void init_chan_statistics( fr_channel_t* chan );
396 static void init_global_statistics( sdla_t* card );
397 static void read_DLCI_IB_mapping( sdla_t* card, fr_channel_t* chan );
398 static int setup_for_delayed_transmit(struct net_device* dev,
399 struct sk_buff *skb);
401 struct net_device *move_dev_to_next(sdla_t *card, struct net_device *dev);
402 static int check_tx_status(sdla_t *card, struct net_device *dev);
404 /* Frame Relay Socket API */
405 static void trigger_fr_bh (fr_channel_t *);
406 static void fr_bh(struct net_device *dev);
407 static int fr_bh_cleanup(struct net_device *dev);
408 static int bh_enqueue(struct net_device *dev, struct sk_buff *skb);
410 static void trigger_fr_poll(struct net_device *dev);
411 static void fr_poll(struct net_device *dev);
412 //static void add_gateway(struct net_device *dev);
414 static void trigger_unconfig_fr(struct net_device *dev);
415 static void unconfig_fr (sdla_t *);
417 static void trigger_config_fr (sdla_t *);
418 static void config_fr (sdla_t *);
421 /* Inverse ARP and Dynamic routing functions */
422 int process_ARP(arphdr_1490_t *ArpPacket, sdla_t *card, struct net_device *dev);
423 int is_arp(void *buf);
424 int send_inarp_request(sdla_t *card, struct net_device *dev);
426 static void trigger_fr_arp(struct net_device *dev);
427 static void fr_arp (unsigned long data);
430 /* Udp management functions */
431 static int process_udp_mgmt_pkt(sdla_t *card);
432 static int udp_pkt_type( struct sk_buff *skb, sdla_t *card );
433 static int store_udp_mgmt_pkt(int udp_type, char udp_pkt_src, sdla_t* card,
434 struct sk_buff *skb, int dlci);
437 static void switch_net_numbers(unsigned char *sendpacket,
438 unsigned long network_number, unsigned char incoming);
440 static int handle_IPXWAN(unsigned char *sendpacket, char *devname,
441 unsigned char enable_IPX, unsigned long network_number);
443 /* Lock Functions: SMP supported */
444 void s508_s514_unlock(sdla_t *card, unsigned long *smp_flags);
445 void s508_s514_lock(sdla_t *card, unsigned long *smp_flags);
447 unsigned short calc_checksum (char *, int);
448 static int setup_fr_header(struct sk_buff** skb,
449 struct net_device* dev, char op_mode);
452 /****** Public Functions ****************************************************/
454 /*============================================================================
455 * Frame relay protocol initialization routine.
457 * This routine is called by the main WANPIPE module during setup. At this
458 * point adapter is completely initialized and firmware is running.
459 * o read firmware version (to make sure it's alive)
460 * o configure adapter
461 * o initialize protocol-specific fields of the adapter data space.
466 int wpf_init(sdla_t *card, wandev_conf_t *conf)
470 fr508_flags_t* flags;
478 fr_buf_info_t* buf_info;
482 printk(KERN_INFO "\n");
484 /* Verify configuration ID */
485 if (conf->config_id != WANCONFIG_FR) {
487 printk(KERN_INFO "%s: invalid configuration ID %u!\n",
488 card->devname, conf->config_id);
493 /* Initialize protocol-specific fields of adapter data space */
494 switch (card->hw.fwid) {
497 card->mbox = (void*)(card->hw.dpmbase +
499 card->flags = (void*)(card->hw.dpmbase +
501 if(card->hw.type == SDLA_S514) {
502 card->mbox += FR_MB_VECTOR;
503 card->flags += FR_MB_VECTOR;
514 /* Read firmware version. Note that when adapter initializes, it
515 * clears the mailbox, so it may appear that the first command was
516 * executed successfully when in fact it was merely erased. To work
517 * around this, we execute the first command twice.
520 if (fr_read_version(card, NULL) || fr_read_version(card, u.str))
523 printk(KERN_INFO "%s: running frame relay firmware v%s\n",
524 card->devname, u.str);
526 /* Adjust configuration */
527 conf->mtu += FR_HEADER_LEN;
528 conf->mtu = (conf->mtu >= MIN_LGTH_FR_DATA_CFG) ?
529 min_t(unsigned int, conf->mtu, FR_MAX_NO_DATA_BYTES_IN_FRAME) :
530 FR_CHANNEL_MTU + FR_HEADER_LEN;
532 conf->bps = min_t(unsigned int, conf->bps, 2048000);
534 /* Initialze the configuration structure sent to the board to zero */
535 memset(&u.cfg, 0, sizeof(u.cfg));
537 memset(card->u.f.dlci_to_dev_map, 0, sizeof(card->u.f.dlci_to_dev_map));
539 /* Configure adapter firmware */
541 u.cfg.mtu = conf->mtu;
542 u.cfg.kbps = conf->bps / 1000;
544 u.cfg.cir_fwd = u.cfg.cir_bwd = 16;
545 u.cfg.bc_fwd = u.cfg.bc_bwd = 16;
547 u.cfg.options = 0x0000;
548 printk(KERN_INFO "%s: Global CIR enabled by Default\n", card->devname);
550 switch (conf->u.fr.signalling) {
553 u.cfg.options = 0x0000;
557 u.cfg.options |= 0x0200;
561 u.cfg.options |= 0x0400;
565 u.cfg.options |= 0x0800;
568 printk(KERN_INFO "%s: Illegal Signalling option\n",
574 card->wandev.signalling = conf->u.fr.signalling;
576 if (conf->station == WANOPT_CPE) {
579 if (conf->u.fr.signalling == WANOPT_NO){
581 "%s: ERROR - For NO signalling, station must be set to Node!",
587 u.cfg.options |= 0x8000; /* auto config DLCI */
588 card->u.f.dlci_num = 0;
592 u.cfg.station = 1; /* switch emulation mode */
594 /* For switch emulation we have to create a list of dlci(s)
595 * that will be sent to be global SET_DLCI_CONFIGURATION
596 * command in fr_configure() routine.
599 card->u.f.dlci_num = min_t(unsigned int, max_t(unsigned int, conf->u.fr.dlci_num, 1), 100);
601 for ( i = 0; i < card->u.f.dlci_num; i++) {
603 card->u.f.node_dlci[i] = (unsigned short)
604 conf->u.fr.dlci[i] ? conf->u.fr.dlci[i] : 16;
609 if (conf->clocking == WANOPT_INTERNAL)
610 u.cfg.port |= 0x0001;
612 if (conf->interface == WANOPT_RS232)
613 u.cfg.port |= 0x0002;
616 u.cfg.t391 = min_t(unsigned int, conf->u.fr.t391, 30);
621 u.cfg.t392 = min_t(unsigned int, conf->u.fr.t392, 30);
626 u.cfg.n391 = min_t(unsigned int, conf->u.fr.n391, 255);
631 u.cfg.n392 = min_t(unsigned int, conf->u.fr.n392, 10);
636 u.cfg.n393 = min_t(unsigned int, conf->u.fr.n393, 10);
640 if (fr_configure(card, &u.cfg))
643 if (card->hw.type == SDLA_S514) {
645 buf_info = (void*)(card->hw.dpmbase + FR_MB_VECTOR +
648 card->rxmb = (void*)(buf_info->rse_next + card->hw.dpmbase);
650 card->u.f.rxmb_base =
651 (void*)(buf_info->rse_base + card->hw.dpmbase);
653 card->u.f.rxmb_last =
654 (void*)(buf_info->rse_base +
655 (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) +
658 buf_info = (void*)(card->hw.dpmbase + FR508_RXBC_OFFS);
660 card->rxmb = (void*)(buf_info->rse_next -
661 FR_MB_VECTOR + card->hw.dpmbase);
663 card->u.f.rxmb_base =
664 (void*)(buf_info->rse_base -
665 FR_MB_VECTOR + card->hw.dpmbase);
667 card->u.f.rxmb_last =
668 (void*)(buf_info->rse_base +
669 (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) -
670 FR_MB_VECTOR + card->hw.dpmbase);
673 card->u.f.rx_base = buf_info->buf_base;
674 card->u.f.rx_top = buf_info->buf_top;
676 card->u.f.tx_interrupts_pending = 0;
678 card->wandev.mtu = conf->mtu;
679 card->wandev.bps = conf->bps;
680 card->wandev.interface = conf->interface;
681 card->wandev.clocking = conf->clocking;
682 card->wandev.station = conf->station;
684 card->exec = &wpf_exec;
685 card->wandev.update = &update;
686 card->wandev.new_if = &new_if;
687 card->wandev.del_if = &del_if;
688 card->wandev.state = WAN_DISCONNECTED;
689 card->wandev.ttl = conf->ttl;
690 card->wandev.udp_port = conf->udp_port;
691 card->disable_comm = &disable_comm;
692 card->u.f.arp_dev = NULL;
694 /* Intialize global statistics for a card */
695 init_global_statistics( card );
697 card->TracingEnabled = 0;
700 Intr_test_counter = 0;
701 card->intr_mode = INTR_TEST_MODE;
702 err = intr_test( card );
704 printk(KERN_INFO "%s: End of Interrupt Test rc=0x%x count=%i\n",
705 card->devname,err,Intr_test_counter);
707 if (err || (Intr_test_counter < MAX_INTR_TEST_COUNTER)) {
708 printk(KERN_ERR "%s: Interrupt Test Failed, Counter: %i\n",
709 card->devname, Intr_test_counter);
710 printk(KERN_ERR "Please choose another interrupt\n");
715 printk(KERN_INFO "%s: Interrupt Test Passed, Counter: %i\n",
716 card->devname, Intr_test_counter);
719 /* Apr 28 2000. Nenad Corbic
720 * Enable commnunications here, not in if_open or new_if, since
721 * interfaces come down when the link is disconnected.
724 /* If you enable comms and then set ints, you get a Tx int as you
725 * perform the SET_INT_TRIGGERS command. So, we only set int
726 * triggers and then adjust the interrupt mask (to disable Tx ints)
727 * before enabling comms.
729 if (fr_set_intr_mode(card, (FR_INTR_RXRDY | FR_INTR_TXRDY |
730 FR_INTR_DLC | FR_INTR_TIMER | FR_INTR_TX_MULT_DLCIs) ,
731 card->wandev.mtu, 0)) {
735 flags->imask &= ~(FR_INTR_TXRDY | FR_INTR_TIMER);
737 if (fr_comm_enable(card)) {
740 wanpipe_set_state(card, WAN_CONNECTED);
741 spin_lock_init(&card->u.f.if_send_lock);
743 printk(KERN_INFO "\n");
748 /******* WAN Device Driver Entry Points *************************************/
750 /*============================================================================
751 * Update device status & statistics.
753 static int update(struct wan_device* wandev)
755 volatile sdla_t* card;
756 unsigned long timeout;
757 fr508_flags_t* flags;
760 if ((wandev == NULL) || (wandev->private == NULL))
763 if (wandev->state == WAN_UNCONFIGURED)
766 card = wandev->private;
770 card->u.f.update_comms_stats = 1;
771 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UPDATE;
772 flags->imask |= FR_INTR_TIMER;
775 if(card->u.f.update_comms_stats == 0)
777 if (time_after(jiffies, timeout + 1 * HZ)){
778 card->u.f.update_comms_stats = 0;
786 /*============================================================================
787 * Create new logical channel.
788 * This routine is called by the router when ROUTER_IFNEW IOCTL is being
790 * o parse media- and hardware-specific configuration
791 * o make sure that a new channel can be created
792 * o allocate resources, if necessary
793 * o prepare network device structure for registaration.
796 * < 0 failure (channel will not be created)
798 static int new_if(struct wan_device* wandev, struct net_device* dev,
801 sdla_t* card = wandev->private;
807 if ((conf->name[0] == '\0') || (strlen(conf->name) > WAN_IFNAME_SZ)) {
809 printk(KERN_INFO "%s: Invalid interface name!\n",
814 /* allocate and initialize private data */
815 chan = kmalloc(sizeof(fr_channel_t), GFP_KERNEL);
820 memset(chan, 0, sizeof(fr_channel_t));
821 strcpy(chan->name, conf->name);
824 /* verify media address */
825 if (is_digit(conf->addr[0])) {
827 dlci = dec_to_uint(conf->addr, 0);
829 if (dlci && (dlci <= HIGHEST_VALID_DLCI)) {
836 "%s: Invalid DLCI %u on interface %s!\n",
837 wandev->name, dlci, chan->name);
843 "%s: Invalid media address on interface %s!\n",
844 wandev->name, chan->name);
848 if ((chan->true_if_encoding = conf->true_if_encoding) == WANOPT_YES){
850 "%s: Enabling, true interface type encoding.\n",
856 /* Setup wanpipe as a router (WANPIPE) even if it is
857 * a bridged DLCI, or as an API
859 if (strcmp(conf->usedby, "WANPIPE") == 0 ||
860 strcmp(conf->usedby, "BRIDGE") == 0 ||
861 strcmp(conf->usedby, "BRIDGE_N") == 0){
863 if(strcmp(conf->usedby, "WANPIPE") == 0){
864 chan->common.usedby = WANPIPE;
866 printk(KERN_INFO "%s: Running in WANPIPE mode.\n",
869 }else if(strcmp(conf->usedby, "BRIDGE") == 0){
871 chan->common.usedby = BRIDGE;
873 printk(KERN_INFO "%s: Running in WANPIPE (BRIDGE) mode.\n",
875 }else if( strcmp(conf->usedby, "BRIDGE_N") == 0 ){
877 chan->common.usedby = BRIDGE_NODE;
879 printk(KERN_INFO "%s: Running in WANPIPE (BRIDGE_NODE) mode.\n",
884 /* Dynamic interface configuration option.
885 * On disconnect, if the options is selected,
886 * the interface will be brought down */
887 if (conf->if_down == WANOPT_YES){
888 set_bit(DYN_OPT_ON,&chan->interface_down);
890 "%s: Dynamic interface configuration enabled.\n",
895 } else if(strcmp(conf->usedby, "API") == 0){
897 chan->common.usedby = API;
898 printk(KERN_INFO "%s: Running in API mode.\n",
908 /* place cir,be,bc and other channel specific information into the
913 chan->cir = max_t(unsigned int, 1,
914 min_t(unsigned int, conf->cir, 512));
915 chan->cir_status = CIR_ENABLED;
918 /* If CIR is enabled, force BC to equal CIR
919 * this solves number of potential problems if CIR is
922 chan->bc = chan->cir;
925 chan->be = max_t(unsigned int,
926 0, min_t(unsigned int, conf->be, 511));
931 printk (KERN_INFO "%s: CIR enabled for DLCI %i \n",
932 wandev->name,chan->dlci);
933 printk (KERN_INFO "%s: CIR = %i ; BC = %i ; BE = %i\n",
934 wandev->name,chan->cir,chan->bc,chan->be);
938 chan->cir_status = CIR_DISABLED;
939 printk (KERN_INFO "%s: CIR disabled for DLCI %i\n",
940 wandev->name,chan->dlci);
945 if (conf->inarp == WANOPT_YES){
946 printk(KERN_INFO "%s: Inverse ARP Support Enabled\n",card->devname);
947 chan->inarp = conf->inarp ? INARP_REQUEST : INARP_NONE;
948 chan->inarp_interval = conf->inarp_interval ? conf->inarp_interval : 10;
950 printk(KERN_INFO "%s: Inverse ARP Support Disabled\n",card->devname);
951 chan->inarp = INARP_NONE;
952 chan->inarp_interval = 10;
956 chan->dlci_configured = DLCI_NOT_CONFIGURED;
959 /*FIXME: IPX disabled in this WANPIPE version */
960 if (conf->enable_IPX == WANOPT_YES){
961 printk(KERN_INFO "%s: ERROR - This version of WANPIPE doesn't support IPX\n",
966 chan->enable_IPX = WANOPT_NO;
969 if (conf->network_number){
970 chan->network_number = conf->network_number;
972 chan->network_number = 0xDEADBEEF;
975 chan->route_flag = NO_ROUTE;
977 init_chan_statistics(chan);
979 chan->transmit_length = 0;
981 /* prepare network device data space for registration */
982 strcpy(dev->name,chan->name);
984 dev->init = &if_init;
987 /* Initialize FR Polling Task Queue
988 * We need a poll routine for each network
991 INIT_WORK(&chan->fr_poll_work, (void *)fr_poll, dev);
993 init_timer(&chan->fr_arp_timer);
994 chan->fr_arp_timer.data=(unsigned long)dev;
995 chan->fr_arp_timer.function = fr_arp;
997 wandev->new_if_cnt++;
999 /* Tells us that if this interface is a
1001 if ((chan->gateway = conf->gateway) == WANOPT_YES){
1002 printk(KERN_INFO "%s: Interface %s is set as a gateway.\n",
1003 card->devname,dev->name);
1006 /* M. Grant Patch Apr 28 2000
1007 * Disallow duplicate dlci configurations. */
1008 if (card->u.f.dlci_to_dev_map[chan->dlci] != NULL) {
1013 /* Configure this dlci at a later date, when
1014 * the interface comes up. i.e. when if_open()
1016 set_bit(0,&chan->config_dlci);
1018 printk(KERN_INFO "\n");
1023 /*============================================================================
1024 * Delete logical channel.
1026 static int del_if(struct wan_device* wandev, struct net_device* dev)
1028 fr_channel_t* chan = dev->priv;
1029 unsigned long smp_flags=0;
1031 /* This interface is dead, make sure the
1032 * ARP timer is stopped */
1033 del_timer(&chan->fr_arp_timer);
1035 /* If we are a NODE, we must unconfigure this DLCI
1036 * Trigger an unconfigure command that will
1037 * be executed in timer interrupt. We must wait
1038 * for the command to complete. */
1039 trigger_unconfig_fr(dev);
1041 lock_adapter_irq(&wandev->lock, &smp_flags);
1042 wandev->new_if_cnt--;
1043 unlock_adapter_irq(&wandev->lock, &smp_flags);
1049 /*=====================================================================
1053 * Disable communications.
1054 * This code runs in shutdown (sdlamain.c)
1055 * under critical flag. Therefore it is not
1056 * necessary to set a critical flag here
1059 * Commnunications are disabled only on a card
1063 static void disable_comm (sdla_t *card)
1065 printk(KERN_INFO "%s: Disabling Communications!\n",
1067 fr_comm_disable(card);
1070 /****** WANPIPE-specific entry points ***************************************/
1072 /*============================================================================
1073 * Execute adapter interface command.
1075 static int wpf_exec (struct sdla* card, void* u_cmd, void* u_data)
1077 fr_mbox_t* mbox = card->mbox;
1078 int retry = MAX_CMD_RETRY;
1082 if(copy_from_user((void*)&cmd, u_cmd, sizeof(cmd)))
1085 /* execute command */
1088 memcpy(&mbox->cmd, &cmd, sizeof(cmd));
1091 if( copy_from_user((void*)&mbox->data, u_data, cmd.length))
1095 if (sdla_exec(mbox))
1096 err = mbox->cmd.result;
1100 } while (err && retry-- && fr_event(card, err, mbox));
1103 if (copy_to_user(u_cmd, (void*)&mbox->cmd, sizeof(fr_cmd_t)))
1106 len = mbox->cmd.length;
1108 if (len && u_data && !copy_to_user(u_data, (void*)&mbox->data, len))
1113 /****** Network Device Interface ********************************************/
1115 /*============================================================================
1116 * Initialize Linux network interface.
1118 * This routine is called only once for each interface, during Linux network
1119 * interface registration. Returning anything but zero will fail interface
1122 static int if_init(struct net_device* dev)
1124 fr_channel_t* chan = dev->priv;
1125 sdla_t* card = chan->card;
1126 struct wan_device* wandev = &card->wandev;
1128 /* Initialize device driver entry points */
1129 dev->open = &if_open;
1130 dev->stop = &if_close;
1131 dev->hard_header = NULL;
1132 dev->rebuild_header = &if_rebuild_hdr;
1133 dev->hard_start_xmit = &if_send;
1134 dev->get_stats = &if_stats;
1135 dev->tx_timeout = &if_tx_timeout;
1136 dev->watchdog_timeo = TX_TIMEOUT;
1138 if (chan->common.usedby == WANPIPE || chan->common.usedby == API){
1140 /* Initialize media-specific parameters */
1141 if (chan->true_if_encoding){
1142 dev->type = ARPHRD_DLCI; /* This breaks tcpdump */
1144 dev->type = ARPHRD_PPP; /* ARP h/w type */
1147 dev->flags |= IFF_POINTOPOINT;
1148 dev->flags |= IFF_NOARP;
1150 /* Enable Multicast addressing */
1151 if (chan->mc == WANOPT_YES){
1152 dev->flags |= IFF_MULTICAST;
1155 dev->mtu = wandev->mtu - FR_HEADER_LEN;
1156 /* For an API, the maximum number of bytes that the stack will pass
1157 to the driver is (dev->mtu + dev->hard_header_len). So, adjust the
1158 mtu so that a frame of maximum size can be transmitted by the API.
1160 if(chan->common.usedby == API) {
1161 dev->mtu += (sizeof(api_tx_hdr_t) - FR_HEADER_LEN);
1164 dev->hard_header_len = FR_HEADER_LEN;/* media header length */
1165 dev->addr_len = 2; /* hardware address length */
1166 *(unsigned short*)dev->dev_addr = htons(chan->dlci);
1168 /* Set transmit buffer queue length */
1169 dev->tx_queue_len = 100;
1173 /* Setup the interface for Bridging */
1177 /* Use a random number to generate the MAC address */
1178 memcpy(dev->dev_addr, "\xFE\xFC\x00\x00\x00\x00", 6);
1179 get_random_bytes(&hw_addr, sizeof(hw_addr));
1180 *(int *)(dev->dev_addr + 2) += hw_addr;
1183 /* Initialize hardware parameters (just for reference) */
1184 dev->irq = wandev->irq;
1185 dev->dma = wandev->dma;
1186 dev->base_addr = wandev->ioport;
1187 dev->mem_start = wandev->maddr;
1188 dev->mem_end = wandev->maddr + wandev->msize - 1;
1189 SET_MODULE_OWNER(dev);
1194 /*============================================================================
1195 * Open network interface.
1196 * o if this is the first open, then enable communications and interrupts.
1197 * o prevent module from unloading by incrementing use count
1199 * Return 0 if O.k. or errno.
1201 static int if_open(struct net_device* dev)
1203 fr_channel_t* chan = dev->priv;
1204 sdla_t* card = chan->card;
1208 if (netif_running(dev))
1211 /* Initialize the task queue */
1214 INIT_WORK(&chan->common.wanpipe_work, (void *)fr_bh, dev);
1216 /* Allocate and initialize BH circular buffer */
1217 chan->bh_head = kmalloc((sizeof(bh_data_t)*MAX_BH_BUFF),GFP_ATOMIC);
1218 memset(chan->bh_head,0,(sizeof(bh_data_t)*MAX_BH_BUFF));
1219 atomic_set(&chan->bh_buff_used, 0);
1221 netif_start_queue(dev);
1224 do_gettimeofday( &tv );
1225 chan->router_start_time = tv.tv_sec;
1227 if (test_bit(0,&chan->config_dlci)){
1228 trigger_config_fr (card);
1229 }else if (chan->inarp == INARP_REQUEST){
1230 trigger_fr_arp(dev);
1236 /*============================================================================
1237 * Close network interface.
1238 * o if this is the last open, then disable communications and interrupts.
1241 static int if_close(struct net_device* dev)
1243 fr_channel_t* chan = dev->priv;
1244 sdla_t* card = chan->card;
1246 if (chan->inarp == INARP_CONFIGURED) {
1247 chan->inarp = INARP_REQUEST;
1250 netif_stop_queue(dev);
1251 wanpipe_close(card);
1256 /*============================================================================
1257 * Re-build media header.
1259 * Return: 1 physical address resolved.
1260 * 0 physical address not resolved
1262 static int if_rebuild_hdr (struct sk_buff* skb)
1264 struct net_device *dev = skb->dev;
1265 fr_channel_t* chan = dev->priv;
1266 sdla_t* card = chan->card;
1268 printk(KERN_INFO "%s: rebuild_header() called for interface %s!\n",
1269 card->devname, dev->name);
1273 /*============================================================================
1274 * Handle transmit timeout event from netif watchdog
1276 static void if_tx_timeout(struct net_device *dev)
1278 fr_channel_t* chan = dev->priv;
1279 sdla_t *card = chan->card;
1281 /* If our device stays busy for at least 5 seconds then we will
1282 * kick start the device by making dev->tbusy = 0. We expect
1283 * that our device never stays busy more than 5 seconds. So this
1284 * is only used as a last resort.
1287 chan->drvstats_if_send.if_send_tbusy++;
1288 ++chan->ifstats.collisions;
1290 printk (KERN_INFO "%s: Transmit timed out on %s\n",
1291 card->devname, dev->name);
1292 chan->drvstats_if_send.if_send_tbusy_timeout++;
1293 netif_wake_queue (dev);
1298 /*============================================================================
1299 * Send a packet on a network interface.
1300 * o set tbusy flag (marks start of the transmission) to block a timer-based
1301 * transmit from overlapping.
1302 * o set critical flag when accessing board.
1303 * o check link state. If link is not up, then drop the packet.
1304 * o check channel status. If it's down then initiate a call.
1305 * o pass a packet to corresponding WAN device.
1306 * o free socket buffer
1308 * Return: 0 complete (socket buffer must be freed)
1309 * non-0 packet may be re-transmitted (tbusy must be set)
1312 * 1. This routine is called either by the protocol stack or by the "net
1313 * bottom half" (with interrupts enabled).
1315 * 2. Using netif_start_queue() and netif_stop_queue()
1316 * will inhibit further transmit requests from the protocol stack
1317 * and can be used for flow control with protocol layer.
1319 static int if_send(struct sk_buff* skb, struct net_device* dev)
1321 fr_channel_t* chan = dev->priv;
1322 sdla_t* card = chan->card;
1324 unsigned char *sendpacket;
1325 fr508_flags_t* adptr_flags = card->flags;
1327 long delay_tx_queued = 0;
1328 unsigned long smp_flags=0;
1329 unsigned char attr = 0;
1331 chan->drvstats_if_send.if_send_entry++;
1333 netif_stop_queue(dev);
1336 /* if we get here, some higher layer thinks we've missed an
1337 * tx-done interrupt.
1339 printk(KERN_INFO "%s: interface %s got kicked!\n",
1340 card->devname, dev->name);
1341 chan->drvstats_if_send.if_send_skb_null ++;
1343 netif_wake_queue(dev);
1347 /* If a peripheral task is running just drop packets */
1348 if (test_bit(PERI_CRIT, &card->wandev.critical)){
1350 printk(KERN_INFO "%s: Critical in if_send(): Peripheral running!\n",
1353 dev_kfree_skb_any(skb);
1354 netif_start_queue(dev);
1358 /* We must set the 'tbusy' flag if we already have a packet queued for
1359 transmission in the transmit interrupt handler. However, we must
1360 ensure that the transmit interrupt does not reset the 'tbusy' flag
1361 just before we set it, as this will result in a "transmit timeout".
1363 set_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical);
1364 if(chan->transmit_length) {
1365 netif_stop_queue(dev);
1366 chan->tick_counter = jiffies;
1367 clear_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical);
1370 clear_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical);
1372 /* Move the if_header() code to here. By inserting frame
1373 * relay header in if_header() we would break the
1374 * tcpdump and other packet sniffers */
1375 chan->fr_header_len = setup_fr_header(&skb,dev,chan->common.usedby);
1376 if (chan->fr_header_len < 0 ){
1377 ++chan->ifstats.tx_dropped;
1378 ++card->wandev.stats.tx_dropped;
1380 dev_kfree_skb_any(skb);
1381 netif_start_queue(dev);
1385 sendpacket = skb->data;
1387 udp_type = udp_pkt_type(skb, card);
1389 if(udp_type != UDP_INVALID_TYPE) {
1390 if(store_udp_mgmt_pkt(udp_type, UDP_PKT_FRM_STACK, card, skb,
1392 adptr_flags->imask |= FR_INTR_TIMER;
1393 if (udp_type == UDP_FPIPE_TYPE){
1394 chan->drvstats_if_send.
1395 if_send_PIPE_request ++;
1398 netif_start_queue(dev);
1402 //FIXME: can we do better than sendpacket[2]?
1403 if ((chan->common.usedby == WANPIPE) && (sendpacket[2] == 0x45)) {
1405 /* check to see if the source IP address is a broadcast or */
1406 /* multicast IP address */
1407 if(chk_bcast_mcast_addr(card, dev, skb)){
1408 ++chan->ifstats.tx_dropped;
1409 ++card->wandev.stats.tx_dropped;
1410 dev_kfree_skb_any(skb);
1411 netif_start_queue(dev);
1417 /* Lock the S514/S508 card: SMP Supported */
1418 s508_s514_lock(card,&smp_flags);
1420 if (test_and_set_bit(SEND_CRIT, (void*)&card->wandev.critical)) {
1422 chan->drvstats_if_send.if_send_critical_non_ISR ++;
1423 chan->ifstats.tx_dropped ++;
1424 printk(KERN_INFO "%s Critical in IF_SEND: if_send() already running!\n",
1426 goto if_send_start_and_exit;
1429 /* API packet check: minimum packet size must be greater than
1430 * 16 byte API header */
1431 if((chan->common.usedby == API) && (skb->len <= sizeof(api_tx_hdr_t))) {
1432 ++chan->ifstats.tx_dropped;
1433 ++card->wandev.stats.tx_dropped;
1436 goto if_send_start_and_exit;
1439 /* During API transmission, get rid of the API header */
1440 if (chan->common.usedby == API) {
1441 api_tx_hdr_t* api_tx_hdr;
1442 api_tx_hdr = (api_tx_hdr_t*)&skb->data[0x00];
1443 attr = api_tx_hdr->attr;
1444 skb_pull(skb,sizeof(api_tx_hdr_t));
1448 if (card->wandev.state != WAN_CONNECTED) {
1449 chan->drvstats_if_send.if_send_wan_disconnected ++;
1450 ++chan->ifstats.tx_dropped;
1451 ++card->wandev.stats.tx_dropped;
1453 } else if (chan->common.state != WAN_CONNECTED) {
1454 chan->drvstats_if_send.if_send_dlci_disconnected ++;
1456 /* Update the DLCI state in timer interrupt */
1457 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UPDATE_STATE;
1458 adptr_flags->imask |= FR_INTR_TIMER;
1460 ++chan->ifstats.tx_dropped;
1461 ++card->wandev.stats.tx_dropped;
1463 } else if (!is_tx_ready(card, chan)) {
1464 /* No tx buffers available, store for delayed transmit */
1465 if (!setup_for_delayed_transmit(dev, skb)){
1466 set_bit(1,&delay_tx_queued);
1468 chan->drvstats_if_send.if_send_no_bfrs++;
1470 } else if (!skb->protocol) {
1471 /* No protocols drop packet */
1472 chan->drvstats_if_send.if_send_protocol_error ++;
1473 ++card->wandev.stats.tx_errors;
1475 } else if (test_bit(ARP_CRIT,&card->wandev.critical)){
1476 /* We are trying to send an ARP Packet, block IP data until
1478 ++chan->ifstats.tx_dropped;
1479 ++card->wandev.stats.tx_dropped;
1482 //FIXME: IPX is not implemented in this version of Frame Relay ?
1483 if((chan->common.usedby == WANPIPE) &&
1484 sendpacket[1] == 0x00 &&
1485 sendpacket[2] == 0x80 &&
1486 sendpacket[6] == 0x81 &&
1487 sendpacket[7] == 0x37) {
1489 if( chan->enable_IPX ) {
1490 switch_net_numbers(sendpacket,
1491 chan->network_number, 0);
1493 //FIXME: Take this out when IPX is fixed
1495 "%s: WARNING: Unsupported IPX data in send, packet dropped\n",
1500 err = fr_send_data_header(card, chan->dlci, attr, skb->len, skb->data, chan->fr_header_len);
1503 case FRRES_CIR_OVERFLOW:
1504 case FRRES_BUFFER_OVERFLOW:
1505 if (!setup_for_delayed_transmit(dev, skb)){
1506 set_bit(1,&delay_tx_queued);
1508 chan->drvstats_if_send.
1509 if_send_adptr_bfrs_full ++;
1512 case FRRES_TOO_LONG:
1513 if (net_ratelimit()){
1515 "%s: Error: Frame too long, transmission failed %i\n",
1516 card->devname, (unsigned int)skb->len);
1518 /* Drop down to default */
1520 chan->drvstats_if_send.
1521 if_send_dlci_disconnected ++;
1522 ++chan->ifstats.tx_dropped;
1523 ++card->wandev.stats.tx_dropped;
1527 chan->drvstats_if_send.
1528 if_send_bfr_passed_to_adptr++;
1529 ++chan->ifstats.tx_packets;
1530 ++card->wandev.stats.tx_packets;
1532 chan->ifstats.tx_bytes += skb->len;
1533 card->wandev.stats.tx_bytes += skb->len;
1534 dev->trans_start = jiffies;
1539 if_send_start_and_exit:
1541 netif_start_queue(dev);
1543 /* If we queued the packet for transmission, we must not
1544 * deallocate it. The packet is unlinked from the IP stack
1545 * not copied. Therefore, we must keep the original packet */
1546 if (!test_bit(1,&delay_tx_queued)) {
1547 dev_kfree_skb_any(skb);
1549 adptr_flags->imask |= FR_INTR_TXRDY;
1550 card->u.f.tx_interrupts_pending ++;
1553 clear_bit(SEND_CRIT, (void*)&card->wandev.critical);
1555 s508_s514_unlock(card,&smp_flags);
1562 /*============================================================================
1563 * Setup so that a frame can be transmitted on the occurrence of a transmit
1566 static int setup_for_delayed_transmit(struct net_device* dev,
1567 struct sk_buff *skb)
1569 fr_channel_t* chan = dev->priv;
1570 sdla_t* card = chan->card;
1571 fr_dlci_interface_t* dlci_interface;
1574 /* Check that the dlci is properly configured,
1575 * before using tx interrupt */
1576 if (!chan->dlci_int_interface){
1577 if (net_ratelimit()){
1579 "%s: ERROR on DLCI %i: Not configured properly !\n",
1580 card->devname, chan->dlci);
1581 printk(KERN_INFO "%s: Please contact Sangoma Technologies\n",
1587 dlci_interface = chan->dlci_int_interface;
1589 if(chan->transmit_length) {
1590 printk(KERN_INFO "%s: Big mess in setup_for_del...\n",
1595 if(len > FR_MAX_NO_DATA_BYTES_IN_FRAME) {
1596 //FIXME: increment some statistic */
1602 chan->transmit_length = len;
1603 chan->delay_skb = skb;
1605 dlci_interface->gen_interrupt |= FR_INTR_TXRDY;
1606 dlci_interface->packet_length = len;
1608 /* Turn on TX interrupt at the end of if_send */
1613 /*============================================================================
1614 * Check to see if the packet to be transmitted contains a broadcast or
1615 * multicast source IP address.
1616 * Return 0 if not broadcast/multicast address, otherwise return 1.
1619 static int chk_bcast_mcast_addr(sdla_t *card, struct net_device* dev,
1620 struct sk_buff *skb)
1623 u32 broadcast_ip_addr = 0;
1624 struct in_device *in_dev;
1625 fr_channel_t* chan = dev->priv;
1627 /* read the IP source address from the outgoing packet */
1628 src_ip_addr = *(u32 *)(skb->data + 14);
1630 /* read the IP broadcast address for the device */
1631 in_dev = dev->ip_ptr;
1632 if(in_dev != NULL) {
1633 struct in_ifaddr *ifa= in_dev->ifa_list;
1635 broadcast_ip_addr = ifa->ifa_broadcast;
1640 /* check if the IP Source Address is a Broadcast address */
1641 if((dev->flags & IFF_BROADCAST) && (src_ip_addr == broadcast_ip_addr)) {
1643 "%s: Broadcast Source Address silently discarded\n",
1648 /* check if the IP Source Address is a Multicast address */
1649 if((chan->mc == WANOPT_NO) && (ntohl(src_ip_addr) >= 0xE0000001) &&
1650 (ntohl(src_ip_addr) <= 0xFFFFFFFE)) {
1652 "%s: Multicast Source Address silently discarded\n",
1660 /*============================================================================
1661 * Reply to UDP Management system.
1664 static int reply_udp( unsigned char *data, unsigned int mbox_len )
1666 unsigned short len, udp_length, temp, ip_length;
1667 unsigned long ip_temp;
1671 fr_udp_pkt_t *fr_udp_pkt = (fr_udp_pkt_t *)data;
1673 /* Set length of packet */
1674 len = //sizeof(fr_encap_hdr_t)+
1682 /* fill in UDP reply */
1683 fr_udp_pkt->wp_mgmt.request_reply = UDPMGMT_REPLY;
1685 /* fill in UDP length */
1686 udp_length = sizeof(udp_pkt_t)+
1692 /* put it on an even boundary */
1693 if ( udp_length & 0x0001 ) {
1699 temp = (udp_length<<8)|(udp_length>>8);
1700 fr_udp_pkt->udp_pkt.udp_length = temp;
1702 /* swap UDP ports */
1703 temp = fr_udp_pkt->udp_pkt.udp_src_port;
1704 fr_udp_pkt->udp_pkt.udp_src_port =
1705 fr_udp_pkt->udp_pkt.udp_dst_port;
1706 fr_udp_pkt->udp_pkt.udp_dst_port = temp;
1710 /* add UDP pseudo header */
1712 *((unsigned short *)
1713 (fr_udp_pkt->data+mbox_len+even_bound)) = temp;
1714 temp = (udp_length<<8)|(udp_length>>8);
1715 *((unsigned short *)
1716 (fr_udp_pkt->data+mbox_len+even_bound+2)) = temp;
1718 /* calculate UDP checksum */
1719 fr_udp_pkt->udp_pkt.udp_checksum = 0;
1721 fr_udp_pkt->udp_pkt.udp_checksum =
1722 calc_checksum(&data[UDP_OFFSET/*+sizeof(fr_encap_hdr_t)*/],
1723 udp_length+UDP_OFFSET);
1725 /* fill in IP length */
1726 ip_length = udp_length + sizeof(ip_pkt_t);
1727 temp = (ip_length<<8)|(ip_length>>8);
1728 fr_udp_pkt->ip_pkt.total_length = temp;
1730 /* swap IP addresses */
1731 ip_temp = fr_udp_pkt->ip_pkt.ip_src_address;
1732 fr_udp_pkt->ip_pkt.ip_src_address =
1733 fr_udp_pkt->ip_pkt.ip_dst_address;
1734 fr_udp_pkt->ip_pkt.ip_dst_address = ip_temp;
1737 /* fill in IP checksum */
1738 fr_udp_pkt->ip_pkt.hdr_checksum = 0;
1739 fr_udp_pkt->ip_pkt.hdr_checksum =
1740 calc_checksum(&data[/*sizeof(fr_encap_hdr_t)*/0],
1746 unsigned short calc_checksum (char *data, int len)
1748 unsigned short temp;
1749 unsigned long sum=0;
1752 for( i = 0; i <len; i+=2 ) {
1753 memcpy(&temp,&data[i],2);
1754 sum += (unsigned long)temp;
1757 while (sum >> 16 ) {
1758 sum = (sum & 0xffffUL) + (sum >> 16);
1761 temp = (unsigned short)sum;
1771 If incoming is 0 (outgoing)- if the net numbers is ours make it 0
1772 if incoming is 1 - if the net number is 0 make it ours
1775 static void switch_net_numbers(unsigned char *sendpacket, unsigned long network_number, unsigned char incoming)
1777 unsigned long pnetwork_number;
1779 pnetwork_number = (unsigned long)((sendpacket[14] << 24) +
1780 (sendpacket[15] << 16) + (sendpacket[16] << 8) +
1784 /* If the destination network number is ours, make it 0 */
1785 if( pnetwork_number == network_number) {
1786 sendpacket[14] = sendpacket[15] = sendpacket[16] =
1787 sendpacket[17] = 0x00;
1790 /* If the incoming network is 0, make it ours */
1791 if( pnetwork_number == 0) {
1792 sendpacket[14] = (unsigned char)(network_number >> 24);
1793 sendpacket[15] = (unsigned char)((network_number &
1795 sendpacket[16] = (unsigned char)((network_number &
1797 sendpacket[17] = (unsigned char)(network_number &
1803 pnetwork_number = (unsigned long)((sendpacket[26] << 24) +
1804 (sendpacket[27] << 16) + (sendpacket[28] << 8) +
1808 /* If the source network is ours, make it 0 */
1809 if( pnetwork_number == network_number) {
1810 sendpacket[26] = sendpacket[27] = sendpacket[28] =
1811 sendpacket[29] = 0x00;
1814 /* If the source network is 0, make it ours */
1815 if( pnetwork_number == 0 ) {
1816 sendpacket[26] = (unsigned char)(network_number >> 24);
1817 sendpacket[27] = (unsigned char)((network_number &
1819 sendpacket[28] = (unsigned char)((network_number &
1821 sendpacket[29] = (unsigned char)(network_number &
1825 } /* switch_net_numbers */
1827 /*============================================================================
1828 * Get ethernet-style interface statistics.
1829 * Return a pointer to struct enet_statistics.
1831 static struct net_device_stats *if_stats(struct net_device *dev)
1833 fr_channel_t* chan = dev->priv;
1838 return &chan->ifstats;
1841 /****** Interrupt Handlers **************************************************/
1843 /*============================================================================
1844 * fr_isr: S508 frame relay interrupt service routine.
1847 * Frame relay main interrupt service route. This
1848 * function check the interrupt type and takes
1849 * the appropriate action.
1851 static void fr_isr (sdla_t* card)
1853 fr508_flags_t* flags = card->flags;
1854 char *ptr = &flags->iflag;
1856 fr_mbox_t* mbox = card->mbox;
1858 /* This flag prevents nesting of interrupts. See sdla_isr() routine
1862 ++card->statistics.isr_entry;
1865 /* All peripheral (configuraiton, re-configuration) events
1866 * take presidence over the ISR. Thus, retrigger */
1867 if (test_bit(PERI_CRIT, (void*)&card->wandev.critical)) {
1868 ++card->statistics.isr_already_critical;
1872 if(card->hw.type != SDLA_S514) {
1873 if (test_bit(SEND_CRIT, (void*)&card->wandev.critical)) {
1874 printk(KERN_INFO "%s: Critical while in ISR: If Send Running!\n",
1876 ++card->statistics.isr_already_critical;
1881 switch (flags->iflag) {
1883 case FR_INTR_RXRDY: /* receive interrupt */
1884 ++card->statistics.isr_rx;
1889 case FR_INTR_TXRDY: /* transmit interrupt */
1890 ++ card->statistics.isr_tx;
1895 Intr_test_counter++;
1896 ++card->statistics.isr_intr_test;
1899 case FR_INTR_DLC: /* Event interrupt occurred */
1900 mbox->cmd.command = FR_READ_STATUS;
1901 mbox->cmd.length = 0;
1902 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
1904 fr_event(card, err, mbox);
1907 case FR_INTR_TIMER: /* Timer interrupt */
1912 ++card->statistics.isr_spurious;
1914 printk(KERN_INFO "%s: Interrupt Type 0x%02X!\n",
1915 card->devname, flags->iflag);
1917 printk(KERN_INFO "%s: ID Bytes = ",card->devname);
1918 for(i = 0; i < 8; i ++)
1919 printk(KERN_INFO "0x%02X ", *(ptr + 0x28 + i));
1920 printk(KERN_INFO "\n");
1934 /*===========================================================
1935 * rx_intr Receive interrupt handler.
1938 * Upon receiveing an interrupt:
1939 * 1. Check that the firmware is in sync with
1941 * 2. Find an appropriate network interface
1942 * based on the received dlci number.
1943 * 3. Check that the netowrk interface exists
1944 * and that it's setup properly.
1945 * 4. Copy the data into an skb buffer.
1946 * 5. Check the packet type and take
1947 * appropriate acton: UPD, API, ARP or Data.
1950 static void rx_intr (sdla_t* card)
1952 fr_rx_buf_ctl_t* frbuf = card->rxmb;
1953 fr508_flags_t* flags = card->flags;
1955 char *ptr = &flags->iflag;
1956 struct sk_buff* skb;
1957 struct net_device* dev;
1959 unsigned dlci, len, offs, len_incl_hdr;
1963 /* Check that firmware buffers are in sync */
1964 if (frbuf->flag != 0x01) {
1967 "%s: corrupted Rx buffer @ 0x%X, flag = 0x%02X!\n",
1968 card->devname, (unsigned)frbuf, frbuf->flag);
1970 printk(KERN_INFO "%s: ID Bytes = ",card->devname);
1971 for(i = 0; i < 8; i ++)
1972 printk(KERN_INFO "0x%02X ", *(ptr + 0x28 + i));
1973 printk(KERN_INFO "\n");
1975 ++card->statistics.rx_intr_corrupt_rx_bfr;
1977 /* Bug Fix: Mar 6 2000
1978 * If we get a corrupted mailbox, it means that driver
1979 * is out of sync with the firmware. There is no recovery.
1980 * If we don't turn off all interrupts for this card
1981 * the machine will crash.
1983 printk(KERN_INFO "%s: Critical router failure ...!!!\n", card->devname);
1984 printk(KERN_INFO "Please contact Sangoma Technologies !\n");
1985 fr_set_intr_mode(card, 0, 0, 0);
1989 len = frbuf->length;
1991 offs = frbuf->offset;
1993 /* Find the network interface for this packet */
1994 dev = find_channel(card, dlci);
1997 /* Check that the network interface is active and
2000 if( net_ratelimit()) {
2001 printk(KERN_INFO "%s: received data on unconfigured DLCI %d!\n",
2002 card->devname, dlci);
2004 ++card->statistics.rx_intr_on_orphaned_DLCI;
2005 ++card->wandev.stats.rx_dropped;
2009 if ((chan = dev->priv) == NULL){
2010 if( net_ratelimit()) {
2011 printk(KERN_INFO "%s: received data on unconfigured DLCI %d!\n",
2012 card->devname, dlci);
2014 ++card->statistics.rx_intr_on_orphaned_DLCI;
2015 ++card->wandev.stats.rx_dropped;
2019 skb = dev_alloc_skb(len);
2021 if (!netif_running(dev) || (skb == NULL)){
2023 ++chan->ifstats.rx_dropped;
2026 if (net_ratelimit()) {
2028 "%s: no socket buffers available!\n",
2031 chan->drvstats_rx_intr.rx_intr_no_socket ++;
2034 if (!netif_running(dev)){
2035 chan->drvstats_rx_intr.
2036 rx_intr_dev_not_started ++;
2038 dev_kfree_skb_any(skb);
2044 /* Copy data from the board into the socket buffer */
2045 if ((offs + len) > card->u.f.rx_top + 1) {
2046 unsigned tmp = card->u.f.rx_top - offs + 1;
2048 buf = skb_put(skb, tmp);
2049 sdla_peek(&card->hw, offs, buf, tmp);
2050 offs = card->u.f.rx_base;
2054 buf = skb_put(skb, len);
2055 sdla_peek(&card->hw, offs, buf, len);
2058 /* We got the packet from the bard.
2059 * Check the packet type and take appropriate action */
2061 udp_type = udp_pkt_type( skb, card );
2063 if(udp_type != UDP_INVALID_TYPE) {
2065 /* UDP Debug packet received, store the
2066 * packet and handle it in timer interrupt */
2069 if (wanrouter_type_trans(skb, dev)){
2070 if(store_udp_mgmt_pkt(udp_type,UDP_PKT_FRM_NETWORK,card,skb,dlci)){
2072 flags->imask |= FR_INTR_TIMER;
2074 if (udp_type == UDP_FPIPE_TYPE){
2075 ++chan->drvstats_rx_intr.rx_intr_PIPE_request;
2080 }else if (chan->common.usedby == API) {
2082 /* We are in API mode.
2083 * Add an API header to the RAW packet
2084 * and queue it into a circular buffer.
2085 * Then kick the fr_bh() bottom half handler */
2087 api_rx_hdr_t* api_rx_hdr;
2088 chan->drvstats_rx_intr.rx_intr_bfr_passed_to_stack ++;
2089 chan->ifstats.rx_packets ++;
2090 card->wandev.stats.rx_packets ++;
2092 chan->ifstats.rx_bytes += skb->len;
2093 card->wandev.stats.rx_bytes += skb->len;
2095 skb_push(skb, sizeof(api_rx_hdr_t));
2096 api_rx_hdr = (api_rx_hdr_t*)&skb->data[0x00];
2097 api_rx_hdr->attr = frbuf->attr;
2098 api_rx_hdr->time_stamp = frbuf->tmstamp;
2100 skb->protocol = htons(ETH_P_IP);
2101 skb->mac.raw = skb->data;
2103 skb->pkt_type = WAN_PACKET_DATA;
2105 bh_enqueue(dev, skb);
2107 trigger_fr_bh(chan);
2109 }else if (handle_IPXWAN(skb->data,chan->name,chan->enable_IPX, chan->network_number)){
2111 //FIXME: Frame Relay IPX is not supported, Yet !
2112 //if (chan->enable_IPX) {
2113 // fr_send(card, dlci, 0, skb->len,skb->data);
2115 dev_kfree_skb_any(skb);
2117 } else if (is_arp(skb->data)) {
2119 /* ARP support enabled Mar 16 2000
2120 * Process incoming ARP reply/request, setup
2121 * dynamic routes. */
2123 if (process_ARP((arphdr_1490_t *)skb->data, card, dev)) {
2124 if (net_ratelimit()){
2126 "%s: Error processing ARP Packet.\n",
2130 dev_kfree_skb_any(skb);
2132 } else if (skb->data[0] != 0x03) {
2134 if (net_ratelimit()) {
2135 printk(KERN_INFO "%s: Non IETF packet discarded.\n",
2138 dev_kfree_skb_any(skb);
2142 len_incl_hdr = skb->len;
2143 /* Decapsulate packet and pass it up the
2147 if (chan->common.usedby == BRIDGE || chan->common.usedby == BRIDGE_NODE){
2149 /* Make sure it's an Ethernet frame, otherwise drop it */
2150 if (!memcmp(skb->data, "\x03\x00\x80\x00\x80\xC2\x00\x07", 8)) {
2152 skb->protocol=eth_type_trans(skb,dev);
2154 ++chan->drvstats_rx_intr.rx_intr_bfr_not_passed_to_stack;
2155 ++chan->ifstats.rx_errors;
2156 ++card->wandev.stats.rx_errors;
2161 /* remove hardware header */
2162 buf = skb_pull(skb, 1);
2164 if (!wanrouter_type_trans(skb, dev)) {
2166 /* can't decapsulate packet */
2167 dev_kfree_skb_any(skb);
2169 ++chan->drvstats_rx_intr.rx_intr_bfr_not_passed_to_stack;
2170 ++chan->ifstats.rx_errors;
2171 ++card->wandev.stats.rx_errors;
2174 skb->mac.raw = skb->data;
2178 /* Send a packet up the IP stack */
2179 skb->dev->last_rx = jiffies;
2181 ++chan->drvstats_rx_intr.rx_intr_bfr_passed_to_stack;
2182 ++chan->ifstats.rx_packets;
2183 ++card->wandev.stats.rx_packets;
2185 chan->ifstats.rx_bytes += len_incl_hdr;
2186 card->wandev.stats.rx_bytes += len_incl_hdr;
2191 /* Release buffer element and calculate a pointer to the next one */
2193 card->rxmb = ++frbuf;
2194 if ((void*)frbuf > card->u.f.rxmb_last)
2195 card->rxmb = card->u.f.rxmb_base;
2199 /*==================================================================
2200 * tx_intr: Transmit interrupt handler.
2203 * If the board is busy transmitting, if_send() will
2204 * buffers a single packet and turn on
2205 * the tx interrupt. Tx interrupt will be called
2206 * by the board, once the firmware can send more
2207 * data. Thus, no polling is required.
2210 * Tx interrupt is called for each
2211 * configured dlci channel. Thus:
2212 * 1. Obtain the netowrk interface based on the
2214 * 2. Check that network interface is up and
2216 * 3. Check for a buffered packet.
2217 * 4. Transmit the packet.
2218 * 5. If we are in WANPIPE mode, mark the
2220 * 6. If we are in API mode, kick
2221 * the AF_WANPIPE socket for more data.
2224 static void tx_intr(sdla_t *card)
2226 fr508_flags_t* flags = card->flags;
2227 fr_tx_buf_ctl_t* bctl;
2228 struct net_device* dev;
2231 if(card->hw.type == SDLA_S514){
2232 bctl = (void*)(flags->tse_offs + card->hw.dpmbase);
2234 bctl = (void*)(flags->tse_offs - FR_MB_VECTOR +
2238 /* Find the structure and make it unbusy */
2239 dev = find_channel(card, flags->dlci);
2241 printk(KERN_INFO "NO DEV IN TX Interrupt\n");
2242 goto end_of_tx_intr;
2245 if ((chan = dev->priv) == NULL){
2246 printk(KERN_INFO "NO CHAN IN TX Interrupt\n");
2247 goto end_of_tx_intr;
2250 if(!chan->transmit_length || !chan->delay_skb) {
2251 printk(KERN_INFO "%s: tx int error - transmit length zero\n",
2253 goto end_of_tx_intr;
2256 /* If the 'if_send()' procedure is currently checking the 'tbusy'
2257 status, then we cannot transmit. Instead, we configure the microcode
2258 so as to re-issue this transmit interrupt at a later stage.
2260 if (test_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical)) {
2262 fr_dlci_interface_t* dlci_interface = chan->dlci_int_interface;
2264 dlci_interface->gen_interrupt |= FR_INTR_TXRDY;
2268 bctl->dlci = flags->dlci;
2269 bctl->length = chan->transmit_length+chan->fr_header_len;
2270 sdla_poke(&card->hw,
2271 fr_send_hdr(card,bctl->dlci,bctl->offset),
2272 chan->delay_skb->data,
2273 chan->delay_skb->len);
2276 ++chan->ifstats.tx_packets;
2277 ++card->wandev.stats.tx_packets;
2278 chan->ifstats.tx_bytes += chan->transmit_length;
2279 card->wandev.stats.tx_bytes += chan->transmit_length;
2281 /* We must free an sk buffer, which we used
2282 * for delayed transmission; Otherwise, the sock
2283 * will run out of memory */
2284 dev_kfree_skb_any(chan->delay_skb);
2286 chan->delay_skb = NULL;
2287 chan->transmit_length = 0;
2289 dev->trans_start = jiffies;
2291 if (netif_queue_stopped(dev)){
2292 /* If using API, than wakeup socket BH handler */
2293 if (chan->common.usedby == API){
2294 netif_start_queue(dev);
2297 netif_wake_queue(dev);
2304 /* if any other interfaces have transmit interrupts pending,
2305 * do not disable the global transmit interrupt */
2306 if(!(-- card->u.f.tx_interrupts_pending))
2307 flags->imask &= ~FR_INTR_TXRDY;
2313 /*============================================================================
2314 * timer_intr: Timer interrupt handler.
2317 * All commans must be executed within the timer
2318 * interrupt since no two commands should execute
2322 * The timer interrupt is used to:
2323 * 1. Processing udp calls from 'fpipemon'.
2324 * 2. Processing update calls from /proc file system
2325 * 3. Reading board-level statistics for
2326 * updating the proc file system.
2327 * 4. Sending inverse ARP request packets.
2328 * 5. Configure a dlci/channel.
2329 * 6. Unconfigure a dlci/channel. (Node only)
2332 static void timer_intr(sdla_t *card)
2334 fr508_flags_t* flags = card->flags;
2336 /* UDP Debuging: fpipemon call */
2337 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UDP) {
2338 if(card->u.f.udp_type == UDP_FPIPE_TYPE) {
2339 if(process_udp_mgmt_pkt(card)) {
2340 card->u.f.timer_int_enabled &=
2341 ~TMR_INT_ENABLED_UDP;
2346 /* /proc update call : triggered from update() */
2347 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UPDATE) {
2348 fr_get_err_stats(card);
2350 card->u.f.update_comms_stats = 0;
2351 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE;
2354 /* Update the channel state call. This is call is
2355 * triggered by if_send() function */
2356 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UPDATE_STATE){
2357 struct net_device *dev;
2358 if (card->wandev.state == WAN_CONNECTED){
2359 for (dev = card->wandev.dev; dev;
2360 dev = *((struct net_device **)dev->priv)){
2361 fr_channel_t *chan = dev->priv;
2362 if (chan->common.state != WAN_CONNECTED){
2363 update_chan_state(dev);
2367 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE_STATE;
2370 /* configure a dlci/channel */
2371 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_CONFIG){
2373 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_CONFIG;
2376 /* unconfigure a dlci/channel */
2377 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UNCONFIG){
2379 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UNCONFIG;
2383 /* Transmit ARP packets */
2384 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_ARP){
2386 struct net_device *dev;
2388 if (card->u.f.arp_dev == NULL)
2389 card->u.f.arp_dev = card->wandev.dev;
2391 dev = card->u.f.arp_dev;
2395 fr_channel_t *chan = dev->priv;
2397 /* If the interface is brought down cancel sending In-ARPs */
2398 if (!(dev->flags&IFF_UP)){
2399 clear_bit(0,&chan->inarp_ready);
2402 if (test_bit(0,&chan->inarp_ready)){
2404 if (check_tx_status(card,dev)){
2405 set_bit(ARP_CRIT,&card->wandev.critical);
2409 if (!send_inarp_request(card,dev)){
2410 trigger_fr_arp(dev);
2411 chan->inarp_tick = jiffies;
2414 clear_bit(0,&chan->inarp_ready);
2415 dev = move_dev_to_next(card,dev);
2418 dev = move_dev_to_next(card,dev);
2420 if (++i == card->wandev.new_if_cnt){
2421 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_ARP;
2425 card->u.f.arp_dev = dev;
2428 if(!card->u.f.timer_int_enabled)
2429 flags->imask &= ~FR_INTR_TIMER;
2433 /*============================================================================
2434 * spur_intr: Spurious interrupt handler.
2437 * We don't know this interrupt.
2441 static void spur_intr (sdla_t* card)
2443 if (net_ratelimit()){
2444 printk(KERN_INFO "%s: spurious interrupt!\n", card->devname);
2449 //FIXME: Fix the IPX in next version
2450 /*===========================================================================
2451 * Return 0 for non-IPXWAN packet
2452 * 1 for IPXWAN packet or IPX is not enabled!
2453 * FIXME: Use a IPX structure here not offsets
2455 static int handle_IPXWAN(unsigned char *sendpacket,
2456 char *devname, unsigned char enable_IPX,
2457 unsigned long network_number)
2461 if( sendpacket[1] == 0x00 && sendpacket[2] == 0x80 &&
2462 sendpacket[6] == 0x81 && sendpacket[7] == 0x37) {
2464 /* It's an IPX packet */
2466 /* Return 1 so we don't pass it up the stack. */
2467 //FIXME: Take this out when IPX is fixed
2468 if (net_ratelimit()){
2470 "%s: WARNING: Unsupported IPX packet received and dropped\n",
2476 /* It's not IPX so return and pass it up the stack. */
2480 if( sendpacket[24] == 0x90 && sendpacket[25] == 0x04){
2483 if( sendpacket[10] == 0x02 && sendpacket[42] == 0x00){
2485 /* It's a timer request packet */
2486 printk(KERN_INFO "%s: Received IPXWAN Timer Request packet\n",
2489 /* Go through the routing options and answer no to every
2490 * option except Unnumbered RIP/SAP
2492 for(i = 49; sendpacket[i] == 0x00; i += 5){
2493 /* 0x02 is the option for Unnumbered RIP/SAP */
2494 if( sendpacket[i + 4] != 0x02){
2495 sendpacket[i + 1] = 0;
2499 /* Skip over the extended Node ID option */
2500 if( sendpacket[i] == 0x04 ){
2504 /* We also want to turn off all header compression opt.
2506 for(; sendpacket[i] == 0x80 ;){
2507 sendpacket[i + 1] = 0;
2508 i += (sendpacket[i + 2] << 8) + (sendpacket[i + 3]) + 4;
2511 /* Set the packet type to timer response */
2512 sendpacket[42] = 0x01;
2514 printk(KERN_INFO "%s: Sending IPXWAN Timer Response\n",
2517 } else if( sendpacket[42] == 0x02 ){
2519 /* This is an information request packet */
2521 "%s: Received IPXWAN Information Request packet\n",
2524 /* Set the packet type to information response */
2525 sendpacket[42] = 0x03;
2527 /* Set the router name */
2528 sendpacket[59] = 'F';
2529 sendpacket[60] = 'P';
2530 sendpacket[61] = 'I';
2531 sendpacket[62] = 'P';
2532 sendpacket[63] = 'E';
2533 sendpacket[64] = '-';
2534 sendpacket[65] = CVHexToAscii(network_number >> 28);
2535 sendpacket[66] = CVHexToAscii((network_number & 0x0F000000)>> 24);
2536 sendpacket[67] = CVHexToAscii((network_number & 0x00F00000)>> 20);
2537 sendpacket[68] = CVHexToAscii((network_number & 0x000F0000)>> 16);
2538 sendpacket[69] = CVHexToAscii((network_number & 0x0000F000)>> 12);
2539 sendpacket[70] = CVHexToAscii((network_number & 0x00000F00)>> 8);
2540 sendpacket[71] = CVHexToAscii((network_number & 0x000000F0)>> 4);
2541 sendpacket[72] = CVHexToAscii(network_number & 0x0000000F);
2542 for(i = 73; i < 107; i+= 1)
2547 printk(KERN_INFO "%s: Sending IPXWAN Information Response packet\n",
2551 printk(KERN_INFO "%s: Unknown IPXWAN packet!\n",devname);
2555 /* Set the WNodeID to our network address */
2556 sendpacket[43] = (unsigned char)(network_number >> 24);
2557 sendpacket[44] = (unsigned char)((network_number & 0x00FF0000) >> 16);
2558 sendpacket[45] = (unsigned char)((network_number & 0x0000FF00) >> 8);
2559 sendpacket[46] = (unsigned char)(network_number & 0x000000FF);
2564 /* If we get here, it's an IPX-data packet so it'll get passed up the
2566 * switch the network numbers
2568 switch_net_numbers(sendpacket, network_number ,1);
2571 /*============================================================================
2575 * If the interface goes down, or we receive an ARP request,
2576 * we have to change the network interface ip addresses.
2577 * This cannot be done within the interrupt.
2581 * This routine is called as a polling routine to dynamically
2582 * add/delete routes negotiated by inverse ARP. It is in this
2583 * "task" because we don't want routes to be added while in
2584 * interrupt context.
2587 * This function is called by fr_poll() polling funtion.
2590 static void process_route(struct net_device *dev)
2592 fr_channel_t *chan = dev->priv;
2593 sdla_t *card = chan->card;
2595 struct ifreq if_info;
2596 struct sockaddr_in *if_data;
2597 mm_segment_t fs = get_fs();
2602 switch(chan->route_flag){
2606 /* Set remote addresses */
2607 memset(&if_info, 0, sizeof(if_info));
2608 strcpy(if_info.ifr_name, dev->name);
2610 set_fs(get_ds()); /* get user space block */
2612 if_data = (struct sockaddr_in *)&if_info.ifr_dstaddr;
2613 if_data->sin_addr.s_addr = chan->ip_remote;
2614 if_data->sin_family = AF_INET;
2615 err = devinet_ioctl( SIOCSIFDSTADDR, &if_info );
2617 set_fs(fs); /* restore old block */
2621 "%s: Route Add failed. Error: %d\n",
2623 printk(KERN_INFO "%s: Address: %u.%u.%u.%u\n",
2624 chan->name, NIPQUAD(chan->ip_remote));
2627 printk(KERN_INFO "%s: Route Added Successfully: %u.%u.%u.%u\n",
2628 card->devname,NIPQUAD(chan->ip_remote));
2629 chan->route_flag = ROUTE_ADDED;
2635 /* Set remote addresses */
2636 memset(&if_info, 0, sizeof(if_info));
2637 strcpy(if_info.ifr_name, dev->name);
2639 ip_tmp = get_ip_address(dev,WAN_POINTOPOINT_IP);
2641 set_fs(get_ds()); /* get user space block */
2643 if_data = (struct sockaddr_in *)&if_info.ifr_dstaddr;
2644 if_data->sin_addr.s_addr = 0;
2645 if_data->sin_family = AF_INET;
2646 err = devinet_ioctl( SIOCSIFDSTADDR, &if_info );
2652 "%s: Deleting of route failed. Error: %d\n",
2654 printk(KERN_INFO "%s: Address: %u.%u.%u.%u\n",
2655 dev->name,NIPQUAD(chan->ip_remote) );
2658 printk(KERN_INFO "%s: Route Removed Sucessfuly: %u.%u.%u.%u\n",
2659 card->devname,NIPQUAD(ip_tmp));
2660 chan->route_flag = NO_ROUTE;
2664 } /* Case Statement */
2670 /****** Frame Relay Firmware-Specific Functions *****************************/
2672 /*============================================================================
2673 * Read firmware code version.
2674 * o fill string str with firmware version info.
2676 static int fr_read_version (sdla_t* card, char* str)
2678 fr_mbox_t* mbox = card->mbox;
2679 int retry = MAX_CMD_RETRY;
2684 mbox->cmd.command = FR_READ_CODE_VERSION;
2685 mbox->cmd.length = 0;
2686 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2687 } while (err && retry-- && fr_event(card, err, mbox));
2690 int len = mbox->cmd.length;
2691 memcpy(str, mbox->data, len);
2697 /*============================================================================
2698 * Set global configuration.
2700 static int fr_configure (sdla_t* card, fr_conf_t *conf)
2702 fr_mbox_t* mbox = card->mbox;
2703 int retry = MAX_CMD_RETRY;
2704 int dlci_num = card->u.f.dlci_num;
2709 memcpy(mbox->data, conf, sizeof(fr_conf_t));
2711 if (dlci_num) for (i = 0; i < dlci_num; ++i)
2712 ((fr_conf_t*)mbox->data)->dlci[i] =
2713 card->u.f.node_dlci[i];
2715 mbox->cmd.command = FR_SET_CONFIG;
2717 sizeof(fr_conf_t) + dlci_num * sizeof(short);
2719 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2721 } while (err && retry-- && fr_event(card, err, mbox));
2725 printk(KERN_ERR "%s: Frame Relay Configuration Failed: rc=0x%x\n",
2732 /*============================================================================
2733 * Set DLCI configuration.
2735 static int fr_dlci_configure (sdla_t* card, fr_dlc_conf_t *conf, unsigned dlci)
2737 fr_mbox_t* mbox = card->mbox;
2738 int retry = MAX_CMD_RETRY;
2743 memcpy(mbox->data, conf, sizeof(fr_dlc_conf_t));
2744 mbox->cmd.dlci = (unsigned short) dlci;
2745 mbox->cmd.command = FR_SET_CONFIG;
2746 mbox->cmd.length = sizeof(fr_dlc_conf_t);
2747 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2748 } while (err && retry--);
2752 /*============================================================================
2753 * Set interrupt mode.
2755 static int fr_set_intr_mode (sdla_t* card, unsigned mode, unsigned mtu,
2756 unsigned short timeout)
2758 fr_mbox_t* mbox = card->mbox;
2759 fr508_intr_ctl_t* ictl = (void*)mbox->data;
2760 int retry = MAX_CMD_RETRY;
2765 memset(ictl, 0, sizeof(fr508_intr_ctl_t));
2768 ictl->irq = card->hw.irq;
2770 /* indicate timeout on timer */
2771 if (mode & 0x20) ictl->timeout = timeout;
2773 mbox->cmd.length = sizeof(fr508_intr_ctl_t);
2774 mbox->cmd.command = FR_SET_INTR_MODE;
2775 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2777 } while (err && retry-- && fr_event(card, err, mbox));
2782 /*============================================================================
2783 * Enable communications.
2785 static int fr_comm_enable (sdla_t* card)
2787 fr_mbox_t* mbox = card->mbox;
2788 int retry = MAX_CMD_RETRY;
2793 mbox->cmd.command = FR_COMM_ENABLE;
2794 mbox->cmd.length = 0;
2795 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2796 } while (err && retry-- && fr_event(card, err, mbox));
2801 /*============================================================================
2804 * Warning: This functin is called by the shutdown() procedure. It is void
2805 * since dev->priv are has already been deallocated and no
2806 * error checking is possible using fr_event() function.
2808 static void fr_comm_disable (sdla_t* card)
2810 fr_mbox_t* mbox = card->mbox;
2811 int retry = MAX_CMD_RETRY;
2815 mbox->cmd.command = FR_SET_MODEM_STATUS;
2816 mbox->cmd.length = 1;
2818 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2819 } while (err && retry--);
2821 retry = MAX_CMD_RETRY;
2825 mbox->cmd.command = FR_COMM_DISABLE;
2826 mbox->cmd.length = 0;
2827 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2828 } while (err && retry--);
2835 /*============================================================================
2836 * Get communications error statistics.
2838 static int fr_get_err_stats (sdla_t* card)
2840 fr_mbox_t* mbox = card->mbox;
2841 int retry = MAX_CMD_RETRY;
2847 mbox->cmd.command = FR_READ_ERROR_STATS;
2848 mbox->cmd.length = 0;
2850 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2851 } while (err && retry-- && fr_event(card, err, mbox));
2854 fr_comm_stat_t* stats = (void*)mbox->data;
2855 card->wandev.stats.rx_over_errors = stats->rx_overruns;
2856 card->wandev.stats.rx_crc_errors = stats->rx_bad_crc;
2857 card->wandev.stats.rx_missed_errors = stats->rx_aborts;
2858 card->wandev.stats.rx_length_errors = stats->rx_too_long;
2859 card->wandev.stats.tx_aborted_errors = stats->tx_aborts;
2866 /*============================================================================
2869 static int fr_get_stats (sdla_t* card)
2871 fr_mbox_t* mbox = card->mbox;
2872 int retry = MAX_CMD_RETRY;
2878 mbox->cmd.command = FR_READ_STATISTICS;
2879 mbox->cmd.length = 0;
2881 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2882 } while (err && retry-- && fr_event(card, err, mbox));
2885 fr_link_stat_t* stats = (void*)mbox->data;
2886 card->wandev.stats.rx_frame_errors = stats->rx_bad_format;
2887 card->wandev.stats.rx_dropped =
2888 stats->rx_dropped + stats->rx_dropped2;
2894 /*============================================================================
2895 * Add DLCI(s) (Access Node only!).
2896 * This routine will perform the ADD_DLCIs command for the specified DLCI.
2898 static int fr_add_dlci (sdla_t* card, int dlci)
2900 fr_mbox_t* mbox = card->mbox;
2901 int retry = MAX_CMD_RETRY;
2906 unsigned short* dlci_list = (void*)mbox->data;
2908 mbox->cmd.length = sizeof(short);
2909 dlci_list[0] = dlci;
2910 mbox->cmd.command = FR_ADD_DLCI;
2911 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2913 } while (err && retry-- && fr_event(card, err, mbox));
2918 /*============================================================================
2919 * Activate DLCI(s) (Access Node only!).
2920 * This routine will perform the ACTIVATE_DLCIs command with a DLCI number.
2922 static int fr_activate_dlci (sdla_t* card, int dlci)
2924 fr_mbox_t* mbox = card->mbox;
2925 int retry = MAX_CMD_RETRY;
2930 unsigned short* dlci_list = (void*)mbox->data;
2932 mbox->cmd.length = sizeof(short);
2933 dlci_list[0] = dlci;
2934 mbox->cmd.command = FR_ACTIVATE_DLCI;
2935 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2937 } while (err && retry-- && fr_event(card, err, mbox));
2942 /*============================================================================
2943 * Delete DLCI(s) (Access Node only!).
2944 * This routine will perform the DELETE_DLCIs command with a DLCI number.
2946 static int fr_delete_dlci (sdla_t* card, int dlci)
2948 fr_mbox_t* mbox = card->mbox;
2949 int retry = MAX_CMD_RETRY;
2954 unsigned short* dlci_list = (void*)mbox->data;
2956 mbox->cmd.length = sizeof(short);
2957 dlci_list[0] = dlci;
2958 mbox->cmd.command = FR_DELETE_DLCI;
2959 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2961 } while (err && retry-- && fr_event(card, err, mbox));
2968 /*============================================================================
2969 * Issue in-channel signalling frame.
2971 static int fr_issue_isf (sdla_t* card, int isf)
2973 fr_mbox_t* mbox = card->mbox;
2974 int retry = MAX_CMD_RETRY;
2979 mbox->data[0] = isf;
2980 mbox->cmd.length = 1;
2981 mbox->cmd.command = FR_ISSUE_IS_FRAME;
2982 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2983 } while (err && retry-- && fr_event(card, err, mbox));
2989 static unsigned int fr_send_hdr (sdla_t*card, int dlci, unsigned int offset)
2991 struct net_device *dev = find_channel(card,dlci);
2994 if (!dev || !(chan=dev->priv))
2997 if (chan->fr_header_len){
2998 sdla_poke(&card->hw, offset, chan->fr_header, chan->fr_header_len);
3001 return offset+chan->fr_header_len;
3004 /*============================================================================
3005 * Send a frame on a selected DLCI.
3007 static int fr_send_data_header (sdla_t* card, int dlci, unsigned char attr, int len,
3008 void *buf, unsigned char hdr_len)
3010 fr_mbox_t* mbox = card->mbox + 0x800;
3011 int retry = MAX_CMD_RETRY;
3016 mbox->cmd.dlci = dlci;
3017 mbox->cmd.attr = attr;
3018 mbox->cmd.length = len+hdr_len;
3019 mbox->cmd.command = FR_WRITE;
3020 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3021 } while (err && retry-- && fr_event(card, err, mbox));
3024 fr_tx_buf_ctl_t* frbuf;
3026 if(card->hw.type == SDLA_S514)
3027 frbuf = (void*)(*(unsigned long*)mbox->data +
3030 frbuf = (void*)(*(unsigned long*)mbox->data -
3031 FR_MB_VECTOR + card->hw.dpmbase);
3033 sdla_poke(&card->hw, fr_send_hdr(card,dlci,frbuf->offset), buf, len);
3040 static int fr_send (sdla_t* card, int dlci, unsigned char attr, int len,
3043 fr_mbox_t* mbox = card->mbox + 0x800;
3044 int retry = MAX_CMD_RETRY;
3049 mbox->cmd.dlci = dlci;
3050 mbox->cmd.attr = attr;
3051 mbox->cmd.length = len;
3052 mbox->cmd.command = FR_WRITE;
3053 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3054 } while (err && retry-- && fr_event(card, err, mbox));
3057 fr_tx_buf_ctl_t* frbuf;
3059 if(card->hw.type == SDLA_S514)
3060 frbuf = (void*)(*(unsigned long*)mbox->data +
3063 frbuf = (void*)(*(unsigned long*)mbox->data -
3064 FR_MB_VECTOR + card->hw.dpmbase);
3066 sdla_poke(&card->hw, frbuf->offset, buf, len);
3074 /****** Firmware Asynchronous Event Handlers ********************************/
3076 /*============================================================================
3077 * Main asyncronous event/error handler.
3078 * This routine is called whenever firmware command returns non-zero
3081 * Return zero if previous command has to be cancelled.
3083 static int fr_event (sdla_t *card, int event, fr_mbox_t* mbox)
3085 fr508_flags_t* flags = card->flags;
3086 char *ptr = &flags->iflag;
3091 case FRRES_MODEM_FAILURE:
3092 return fr_modem_failure(card, mbox);
3094 case FRRES_CHANNEL_DOWN: {
3095 struct net_device *dev;
3097 /* Remove all routes from associated DLCI's */
3098 for (dev = card->wandev.dev; dev;
3099 dev = *((struct net_device **)dev->priv)) {
3100 fr_channel_t *chan = dev->priv;
3101 if (chan->route_flag == ROUTE_ADDED) {
3102 chan->route_flag = REMOVE_ROUTE;
3105 if (chan->inarp == INARP_CONFIGURED) {
3106 chan->inarp = INARP_REQUEST;
3109 /* If the link becomes disconnected then,
3110 * all channels will be disconnected
3113 set_chan_state(dev,WAN_DISCONNECTED);
3116 wanpipe_set_state(card, WAN_DISCONNECTED);
3120 case FRRES_CHANNEL_UP: {
3121 struct net_device *dev;
3123 /* FIXME: Only startup devices that are on the list */
3125 for (dev = card->wandev.dev; dev;
3126 dev = *((struct net_device **)dev->priv)) {
3128 set_chan_state(dev,WAN_CONNECTED);
3131 wanpipe_set_state(card, WAN_CONNECTED);
3135 case FRRES_DLCI_CHANGE:
3136 return fr_dlci_change(card, mbox);
3138 case FRRES_DLCI_MISMATCH:
3139 printk(KERN_INFO "%s: DLCI list mismatch!\n",
3144 printk(KERN_ERR "%s: command 0x%02X timed out!\n",
3145 card->devname, mbox->cmd.command);
3146 printk(KERN_INFO "%s: ID Bytes = ",card->devname);
3147 for(i = 0; i < 8; i ++)
3148 printk(KERN_INFO "0x%02X ", *(ptr + 0x18 + i));
3149 printk(KERN_INFO "\n");
3153 case FRRES_DLCI_INACTIVE:
3156 case FRRES_CIR_OVERFLOW:
3159 case FRRES_BUFFER_OVERFLOW:
3163 printk(KERN_INFO "%s: command 0x%02X returned 0x%02X!\n"
3164 , card->devname, mbox->cmd.command, event);
3170 /*============================================================================
3171 * Handle modem error.
3173 * Return zero if previous command has to be cancelled.
3175 static int fr_modem_failure (sdla_t *card, fr_mbox_t* mbox)
3177 printk(KERN_INFO "%s: physical link down! (modem error 0x%02X)\n",
3178 card->devname, mbox->data[0]);
3180 switch (mbox->cmd.command){
3190 /*============================================================================
3191 * Handle DLCI status change.
3193 * Return zero if previous command has to be cancelled.
3195 static int fr_dlci_change (sdla_t *card, fr_mbox_t* mbox)
3197 dlci_status_t* status = (void*)mbox->data;
3198 int cnt = mbox->cmd.length / sizeof(dlci_status_t);
3200 struct net_device* dev2;
3203 for (; cnt; --cnt, ++status) {
3205 unsigned short dlci= status->dlci;
3206 struct net_device* dev = find_channel(card, dlci);
3210 "%s: CPE contains unconfigured DLCI= %d\n",
3211 card->devname, dlci);
3214 "%s: unconfigured DLCI %d reported by network\n"
3215 , card->devname, dlci);
3218 if (status->state == FR_LINK_INOPER) {
3220 "%s: DLCI %u is inactive!\n",
3221 card->devname, dlci);
3223 if (dev && netif_running(dev))
3224 set_chan_state(dev, WAN_DISCONNECTED);
3227 if (status->state & FR_DLCI_DELETED) {
3230 "%s: DLCI %u has been deleted!\n",
3231 card->devname, dlci);
3233 if (dev && netif_running(dev)){
3235 fr_channel_t *chan = dev->priv;
3237 if (chan->route_flag == ROUTE_ADDED) {
3238 chan->route_flag = REMOVE_ROUTE;
3239 /* The state change will trigger
3240 * the fr polling routine */
3243 if (chan->inarp == INARP_CONFIGURED) {
3244 chan->inarp = INARP_REQUEST;
3247 set_chan_state(dev, WAN_DISCONNECTED);
3250 } else if (status->state & FR_DLCI_ACTIVE) {
3254 /* This flag is used for configuring specific
3255 DLCI(s) when they become active.
3257 chan->dlci_configured = DLCI_CONFIG_PENDING;
3259 set_chan_state(dev, WAN_CONNECTED);
3265 for (dev2 = card->wandev.dev; dev2;
3266 dev2 = *((struct net_device **)dev2->priv)){
3270 if (chan->dlci_configured == DLCI_CONFIG_PENDING) {
3271 if (fr_init_dlci(card, chan)){
3281 static int fr_init_dlci (sdla_t *card, fr_channel_t *chan)
3285 memset(&cfg, 0, sizeof(cfg));
3287 if ( chan->cir_status == CIR_DISABLED) {
3289 cfg.cir_fwd = cfg.cir_bwd = 16;
3290 cfg.bc_fwd = cfg.bc_bwd = 16;
3291 cfg.conf_flags = 0x0001;
3293 }else if (chan->cir_status == CIR_ENABLED) {
3295 cfg.cir_fwd = cfg.cir_bwd = chan->cir;
3296 cfg.bc_fwd = cfg.bc_bwd = chan->bc;
3297 cfg.be_fwd = cfg.be_bwd = chan->be;
3298 cfg.conf_flags = 0x0000;
3301 if (fr_dlci_configure( card, &cfg , chan->dlci)){
3303 "%s: DLCI Configure failed for %d\n",
3304 card->devname, chan->dlci);
3308 chan->dlci_configured = DLCI_CONFIGURED;
3310 /* Read the interface byte mapping into the channel
3313 read_DLCI_IB_mapping( card, chan );
3317 /******* Miscellaneous ******************************************************/
3319 /*============================================================================
3320 * Update channel state.
3322 static int update_chan_state(struct net_device* dev)
3324 fr_channel_t* chan = dev->priv;
3325 sdla_t* card = chan->card;
3326 fr_mbox_t* mbox = card->mbox;
3327 int retry = MAX_CMD_RETRY;
3332 mbox->cmd.command = FR_LIST_ACTIVE_DLCI;
3333 mbox->cmd.length = 0;
3334 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3335 } while (err && retry-- && fr_event(card, err, mbox));
3339 unsigned short* list = (void*)mbox->data;
3340 int cnt = mbox->cmd.length / sizeof(short);
3344 for (; cnt; --cnt, ++list) {
3346 if (*list == chan->dlci) {
3347 set_chan_state(dev, WAN_CONNECTED);
3351 * When a dlci is added or restarted,
3352 * the dlci_int_interface pointer must
3353 * be reinitialized. */
3354 if (!chan->dlci_int_interface){
3355 err=fr_init_dlci (card,chan);
3365 /*============================================================================
3366 * Set channel state.
3368 static void set_chan_state(struct net_device* dev, int state)
3370 fr_channel_t* chan = dev->priv;
3371 sdla_t* card = chan->card;
3373 if (chan->common.state != state) {
3379 "%s: Interface %s: DLCI %d connected\n",
3380 card->devname, dev->name, chan->dlci);
3382 /* If the interface was previoulsy down,
3383 * bring it up, since the channel is active */
3385 trigger_fr_poll (dev);
3386 trigger_fr_arp (dev);
3389 case WAN_CONNECTING:
3391 "%s: Interface %s: DLCI %d connecting\n",
3392 card->devname, dev->name, chan->dlci);
3395 case WAN_DISCONNECTED:
3397 "%s: Interface %s: DLCI %d disconnected!\n",
3398 card->devname, dev->name, chan->dlci);
3400 /* If the interface is up, bring it down,
3401 * since the channel is now disconnected */
3402 trigger_fr_poll (dev);
3406 chan->common.state = state;
3409 chan->state_tick = jiffies;
3412 /*============================================================================
3413 * Find network device by its channel number.
3415 * We need this critical flag because we change
3416 * the dlci_to_dev_map outside the interrupt.
3418 * NOTE: del_if() functions updates this array, it uses
3419 * the spin locks to avoid corruption.
3421 static struct net_device* find_channel(sdla_t* card, unsigned dlci)
3423 if(dlci > HIGHEST_VALID_DLCI)
3426 return(card->u.f.dlci_to_dev_map[dlci]);
3429 /*============================================================================
3430 * Check to see if a frame can be sent. If no transmit buffers available,
3431 * enable transmit interrupts.
3433 * Return: 1 - Tx buffer(s) available
3434 * 0 - no buffers available
3436 static int is_tx_ready (sdla_t* card, fr_channel_t* chan)
3440 if(card->hw.type == SDLA_S514)
3443 sb = inb(card->hw.port);
3450 /*============================================================================
3451 * Convert decimal string to unsigned integer.
3452 * If len != 0 then only 'len' characters of the string are converted.
3454 static unsigned int dec_to_uint (unsigned char* str, int len)
3461 for (val = 0; len && is_digit(*str); ++str, --len)
3462 val = (val * 10) + (*str - (unsigned)'0');
3469 /*=============================================================================
3470 * Store a UDP management packet for later processing.
3473 static int store_udp_mgmt_pkt(int udp_type, char udp_pkt_src, sdla_t* card,
3474 struct sk_buff *skb, int dlci)
3476 int udp_pkt_stored = 0;
3478 struct net_device *dev = find_channel(card, dlci);
3481 if (!dev || !(chan=dev->priv))
3484 if(!card->u.f.udp_pkt_lgth && (skb->len <= MAX_LGTH_UDP_MGNT_PKT)){
3485 card->u.f.udp_pkt_lgth = skb->len + chan->fr_header_len;
3486 card->u.f.udp_type = udp_type;
3487 card->u.f.udp_pkt_src = udp_pkt_src;
3488 card->u.f.udp_dlci = dlci;
3489 memcpy(card->u.f.udp_pkt_data, skb->data, skb->len);
3490 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UDP;
3494 printk(KERN_INFO "ERROR: UDP packet not stored for DLCI %d\n",
3498 if(udp_pkt_src == UDP_PKT_FRM_STACK){
3499 dev_kfree_skb_any(skb);
3501 dev_kfree_skb_any(skb);
3504 return(udp_pkt_stored);
3508 /*==============================================================================
3509 * Process UDP call of type FPIPE8ND
3511 static int process_udp_mgmt_pkt(sdla_t* card)
3514 int c_retry = MAX_CMD_RETRY;
3516 unsigned char frames;
3518 unsigned short buffer_length;
3519 struct sk_buff *new_skb;
3520 fr_mbox_t* mbox = card->mbox;
3523 int udp_mgmt_req_valid = 1;
3524 struct net_device* dev;
3526 fr_udp_pkt_t *fr_udp_pkt;
3527 unsigned short num_trc_els;
3528 fr_trc_el_t* ptr_trc_el;
3530 fpipemon_trc_t* fpipemon_trc;
3532 char udp_pkt_src = card->u.f.udp_pkt_src;
3533 int dlci = card->u.f.udp_dlci;
3535 /* Find network interface for this packet */
3536 dev = find_channel(card, dlci);
3538 card->u.f.udp_pkt_lgth = 0;
3541 if ((chan = dev->priv) == NULL){
3542 card->u.f.udp_pkt_lgth = 0;
3546 /* If the UDP packet is from the network, we are going to have to
3547 transmit a response. Before doing so, we must check to see that
3548 we are not currently transmitting a frame (in 'if_send()') and
3549 that we are not already in a 'delayed transmit' state.
3551 if(udp_pkt_src == UDP_PKT_FRM_NETWORK) {
3552 if (check_tx_status(card,dev)){
3553 card->u.f.udp_pkt_lgth = 0;
3558 fr_udp_pkt = (fr_udp_pkt_t *)card->u.f.udp_pkt_data;
3560 if(udp_pkt_src == UDP_PKT_FRM_NETWORK) {
3562 switch(fr_udp_pkt->cblock.command) {
3564 case FR_READ_MODEM_STATUS:
3565 case FR_READ_STATUS:
3566 case FPIPE_ROUTER_UP_TIME:
3567 case FR_READ_ERROR_STATS:
3568 case FPIPE_DRIVER_STAT_GEN:
3569 case FR_READ_STATISTICS:
3570 case FR_READ_ADD_DLC_STATS:
3571 case FR_READ_CONFIG:
3572 case FR_READ_CODE_VERSION:
3573 udp_mgmt_req_valid = 1;
3576 udp_mgmt_req_valid = 0;
3581 if(!udp_mgmt_req_valid) {
3582 /* set length to 0 */
3583 fr_udp_pkt->cblock.length = 0;
3584 /* set return code */
3585 fr_udp_pkt->cblock.result = 0xCD;
3587 chan->drvstats_gen.UDP_PIPE_mgmt_direction_err ++;
3589 if (net_ratelimit()){
3591 "%s: Warning, Illegal UDP command attempted from network: %x\n",
3592 card->devname,fr_udp_pkt->cblock.command);
3597 switch(fr_udp_pkt->cblock.command) {
3599 case FPIPE_ENABLE_TRACING:
3600 if(!card->TracingEnabled) {
3602 mbox->cmd.command = FR_SET_TRACE_CONFIG;
3603 mbox->cmd.length = 1;
3604 mbox->cmd.dlci = 0x00;
3605 mbox->data[0] = fr_udp_pkt->data[0] |
3607 err = sdla_exec(mbox) ?
3608 mbox->cmd.result : CMD_TIMEOUT;
3609 } while (err && c_retry-- && fr_event(card, err,
3613 card->TracingEnabled = 0;
3614 /* set the return code */
3615 fr_udp_pkt->cblock.result =
3617 mbox->cmd.length = 0;
3621 sdla_peek(&card->hw, NO_TRC_ELEMENTS_OFF,
3623 sdla_peek(&card->hw, BASE_TRC_ELEMENTS_OFF,
3624 &card->u.f.trc_el_base, 4);
3625 card->u.f.curr_trc_el = card->u.f.trc_el_base;
3626 card->u.f.trc_el_last = card->u.f.curr_trc_el +
3627 ((num_trc_els - 1) *
3628 sizeof(fr_trc_el_t));
3630 /* Calculate the maximum trace data area in */
3631 /* the UDP packet */
3632 card->u.f.trc_bfr_space=(MAX_LGTH_UDP_MGNT_PKT -
3633 //sizeof(fr_encap_hdr_t) -
3639 /* set return code */
3640 fr_udp_pkt->cblock.result = 0;
3643 /* set return code to line trace already
3645 fr_udp_pkt->cblock.result = 1;
3648 mbox->cmd.length = 0;
3649 card->TracingEnabled = 1;
3653 case FPIPE_DISABLE_TRACING:
3654 if(card->TracingEnabled) {
3657 mbox->cmd.command = FR_SET_TRACE_CONFIG;
3658 mbox->cmd.length = 1;
3659 mbox->cmd.dlci = 0x00;
3660 mbox->data[0] = ~ACTIVATE_TRC;
3661 err = sdla_exec(mbox) ?
3662 mbox->cmd.result : CMD_TIMEOUT;
3663 } while (err && c_retry-- && fr_event(card, err, mbox));
3666 /* set return code */
3667 fr_udp_pkt->cblock.result = 0;
3668 mbox->cmd.length = 0;
3669 card->TracingEnabled = 0;
3672 case FPIPE_GET_TRACE_INFO:
3674 /* Line trace cannot be performed on the 502 */
3675 if(!card->TracingEnabled) {
3676 /* set return code */
3677 fr_udp_pkt->cblock.result = 1;
3678 mbox->cmd.length = 0;
3682 ptr_trc_el = (void *)card->u.f.curr_trc_el;
3685 fr_udp_pkt->data[0x00] = 0x00;
3687 for(frames = 0; frames < MAX_FRMS_TRACED; frames ++) {
3689 sdla_peek(&card->hw, (unsigned long)ptr_trc_el,
3690 (void *)&trc_el.flag,
3691 sizeof(fr_trc_el_t));
3692 if(trc_el.flag == 0x00) {
3695 if((card->u.f.trc_bfr_space - buffer_length)
3696 < sizeof(fpipemon_trc_hdr_t)) {
3697 fr_udp_pkt->data[0x00] |= MORE_TRC_DATA;
3702 (fpipemon_trc_t *)&fr_udp_pkt->data[buffer_length];
3703 fpipemon_trc->fpipemon_trc_hdr.status =
3705 fpipemon_trc->fpipemon_trc_hdr.tmstamp =
3707 fpipemon_trc->fpipemon_trc_hdr.length =
3710 if(!trc_el.offset || !trc_el.length) {
3712 fpipemon_trc->fpipemon_trc_hdr.data_passed = 0x00;
3714 }else if((trc_el.length + sizeof(fpipemon_trc_hdr_t) + 1) >
3715 (card->u.f.trc_bfr_space - buffer_length)){
3717 fpipemon_trc->fpipemon_trc_hdr.data_passed = 0x00;
3718 fr_udp_pkt->data[0x00] |= MORE_TRC_DATA;
3721 fpipemon_trc->fpipemon_trc_hdr.data_passed = 0x01;
3722 sdla_peek(&card->hw, trc_el.offset,
3728 sdla_poke(&card->hw, (unsigned long)ptr_trc_el,
3732 if((void *)ptr_trc_el > card->u.f.trc_el_last)
3733 ptr_trc_el = (void*)card->u.f.trc_el_base;
3735 buffer_length += sizeof(fpipemon_trc_hdr_t);
3736 if(fpipemon_trc->fpipemon_trc_hdr.data_passed) {
3737 buffer_length += trc_el.length;
3740 if(fr_udp_pkt->data[0x00] & MORE_TRC_DATA) {
3745 if(frames == MAX_FRMS_TRACED) {
3746 fr_udp_pkt->data[0x00] |= MORE_TRC_DATA;
3749 card->u.f.curr_trc_el = (void *)ptr_trc_el;
3751 /* set the total number of frames passed */
3752 fr_udp_pkt->data[0x00] |=
3753 ((frames << 1) & (MAX_FRMS_TRACED << 1));
3755 /* set the data length and return code */
3756 fr_udp_pkt->cblock.length = mbox->cmd.length = buffer_length;
3757 fr_udp_pkt->cblock.result = 0;
3760 case FPIPE_FT1_READ_STATUS:
3761 sdla_peek(&card->hw, 0xF020,
3762 &fr_udp_pkt->data[0x00] , 2);
3763 fr_udp_pkt->cblock.length = mbox->cmd.length = 2;
3764 fr_udp_pkt->cblock.result = 0;
3767 case FPIPE_FLUSH_DRIVER_STATS:
3768 init_chan_statistics(chan);
3769 init_global_statistics(card);
3770 mbox->cmd.length = 0;
3773 case FPIPE_ROUTER_UP_TIME:
3774 do_gettimeofday(&tv);
3775 chan->router_up_time = tv.tv_sec -
3776 chan->router_start_time;
3777 *(unsigned long *)&fr_udp_pkt->data =
3778 chan->router_up_time;
3779 mbox->cmd.length = fr_udp_pkt->cblock.length = 4;
3780 fr_udp_pkt->cblock.result = 0;
3783 case FPIPE_DRIVER_STAT_IFSEND:
3784 memcpy(fr_udp_pkt->data,
3785 &chan->drvstats_if_send.if_send_entry,
3786 sizeof(if_send_stat_t));
3787 mbox->cmd.length = fr_udp_pkt->cblock.length =sizeof(if_send_stat_t);
3788 fr_udp_pkt->cblock.result = 0;
3791 case FPIPE_DRIVER_STAT_INTR:
3793 memcpy(fr_udp_pkt->data,
3794 &card->statistics.isr_entry,
3795 sizeof(global_stats_t));
3797 memcpy(&fr_udp_pkt->data[sizeof(global_stats_t)],
3798 &chan->drvstats_rx_intr.rx_intr_no_socket,
3799 sizeof(rx_intr_stat_t));
3801 mbox->cmd.length = fr_udp_pkt->cblock.length =
3802 sizeof(global_stats_t) +
3803 sizeof(rx_intr_stat_t);
3804 fr_udp_pkt->cblock.result = 0;
3807 case FPIPE_DRIVER_STAT_GEN:
3808 memcpy(fr_udp_pkt->data,
3809 &chan->drvstats_gen.UDP_PIPE_mgmt_kmalloc_err,
3810 sizeof(pipe_mgmt_stat_t));
3812 memcpy(&fr_udp_pkt->data[sizeof(pipe_mgmt_stat_t)],
3813 &card->statistics, sizeof(global_stats_t));
3815 mbox->cmd.length = fr_udp_pkt->cblock.length = sizeof(global_stats_t)+
3816 sizeof(rx_intr_stat_t);
3817 fr_udp_pkt->cblock.result = 0;
3821 case FR_FT1_STATUS_CTRL:
3822 if(fr_udp_pkt->data[0] == 1) {
3824 fr_udp_pkt->cblock.result = 0;
3825 mbox->cmd.length = 1;
3830 /* Disable FT1 MONITOR STATUS */
3831 if(fr_udp_pkt->data[0] == 0) {
3832 if( --rCount != 0) {
3833 fr_udp_pkt->cblock.result = 0;
3834 mbox->cmd.length = 1;
3845 &fr_udp_pkt->cblock.command,
3847 if(mbox->cmd.length) {
3849 (char *)fr_udp_pkt->data,
3853 err = sdla_exec(mbox) ? mbox->cmd.result :
3855 } while (err && c_retry-- && fr_event(card, err, mbox));
3859 UDP_PIPE_mgmt_adptr_cmnd_OK ++;
3862 UDP_PIPE_mgmt_adptr_cmnd_timeout ++;
3864 /* copy the result back to our buffer */
3865 memcpy(&fr_udp_pkt->cblock.command,
3866 &mbox->cmd, sizeof(fr_cmd_t));
3868 if(mbox->cmd.length) {
3869 memcpy(&fr_udp_pkt->data,
3870 &mbox->data, mbox->cmd.length);
3876 fr_udp_pkt->ip_pkt.ttl = card->wandev.ttl;
3877 len = reply_udp(card->u.f.udp_pkt_data, mbox->cmd.length);
3879 if(udp_pkt_src == UDP_PKT_FRM_NETWORK) {
3881 chan->fr_header_len=2;
3882 chan->fr_header[0]=Q922_UI;
3883 chan->fr_header[1]=NLPID_IP;
3885 err = fr_send_data_header(card, dlci, 0, len,
3886 card->u.f.udp_pkt_data,chan->fr_header_len);
3888 chan->drvstats_gen.UDP_PIPE_mgmt_adptr_send_passed ++;
3890 chan->drvstats_gen.UDP_PIPE_mgmt_adptr_send_failed ++;
3894 /* Allocate socket buffer */
3895 if((new_skb = dev_alloc_skb(len)) != NULL) {
3897 /* copy data into new_skb */
3898 buf = skb_put(new_skb, len);
3899 memcpy(buf, card->u.f.udp_pkt_data, len);
3902 UDP_PIPE_mgmt_passed_to_stack ++;
3904 new_skb->protocol = htons(ETH_P_IP);
3905 new_skb->mac.raw = new_skb->data;
3909 chan->drvstats_gen.UDP_PIPE_mgmt_no_socket ++;
3911 "%s: UDP mgmt cmnd, no socket buffers available!\n",
3916 card->u.f.udp_pkt_lgth = 0;
3921 /*==============================================================================
3922 * Send Inverse ARP Request
3925 int send_inarp_request(sdla_t *card, struct net_device *dev)
3929 arphdr_1490_t *ArpPacket;
3930 arphdr_fr_t *arphdr;
3931 fr_channel_t *chan = dev->priv;
3932 struct in_device *in_dev;
3934 in_dev = dev->ip_ptr;
3936 if(in_dev != NULL ) {
3938 ArpPacket = kmalloc(sizeof(arphdr_1490_t) + sizeof(arphdr_fr_t), GFP_ATOMIC);
3939 /* SNAP Header indicating ARP */
3940 ArpPacket->control = 0x03;
3941 ArpPacket->pad = 0x00;
3942 ArpPacket->NLPID = 0x80;
3943 ArpPacket->OUI[0] = 0;
3944 ArpPacket->OUI[1] = 0;
3945 ArpPacket->OUI[2] = 0;
3946 ArpPacket->PID = 0x0608;
3948 arphdr = (arphdr_fr_t *)(ArpPacket + 1); // Go to ARP Packet
3951 arphdr->ar_hrd = 0x0F00; /* Frame Relay HW type */
3952 arphdr->ar_pro = 0x0008; /* IP Protocol */
3953 arphdr->ar_hln = 2; /* HW addr length */
3954 arphdr->ar_pln = 4; /* IP addr length */
3955 arphdr->ar_op = htons(0x08); /* InARP Request */
3956 arphdr->ar_sha = 0; /* src HW DLCI - Doesn't matter */
3957 if(in_dev->ifa_list != NULL)
3958 arphdr->ar_sip = in_dev->ifa_list->ifa_local; /* Local Address */else
3960 arphdr->ar_tha = 0; /* dst HW DLCI - Doesn't matter */
3961 arphdr->ar_tip = 0; /* Remote Address -- what we want */
3963 err = fr_send(card, chan->dlci, 0, sizeof(arphdr_1490_t) + sizeof(arphdr_fr_t),
3967 printk(KERN_INFO "\n%s: Sending InARP request on DLCI %d.\n",
3968 card->devname, chan->dlci);
3969 clear_bit(ARP_CRIT,&card->wandev.critical);
3974 printk(KERN_INFO "%s: INARP ERROR: %s doesn't have a local IP address!\n",
3975 card->devname,dev->name);
3983 /*==============================================================================
3984 * Check packet for ARP Type
3987 int is_arp(void *buf)
3989 arphdr_1490_t *arphdr = (arphdr_1490_t *)buf;
3991 if (arphdr->pad == 0x00 &&
3992 arphdr->NLPID == 0x80 &&
3993 arphdr->PID == 0x0608)
3998 /*==============================================================================
3999 * Process ARP Packet Type
4002 int process_ARP(arphdr_1490_t *ArpPacket, sdla_t *card, struct net_device* dev)
4006 arphdr_fr_t *arphdr = (arphdr_fr_t *)(ArpPacket + 1); /* Skip header */
4007 fr_rx_buf_ctl_t* frbuf = card->rxmb;
4008 struct in_device *in_dev;
4009 fr_channel_t *chan = dev->priv;
4011 /* Before we transmit ARP packet, we must check
4012 * to see that we are not currently transmitting a
4013 * frame (in 'if_send()') and that we are not
4014 * already in a 'delayed transmit' state. */
4015 if (check_tx_status(card,dev)){
4016 if (net_ratelimit()){
4017 printk(KERN_INFO "%s: Disabling comminication to process ARP\n",
4020 set_bit(ARP_CRIT,&card->wandev.critical);
4024 in_dev = dev->ip_ptr;
4026 /* Check that IP addresses exist for our network address */
4027 if (in_dev == NULL || in_dev->ifa_list == NULL)
4030 switch (ntohs(arphdr->ar_op)) {
4032 case 0x08: // Inverse ARP request -- Send Reply, add route.
4034 /* Check for valid Address */
4035 printk(KERN_INFO "%s: Recvd PtP addr -InArp Req: %u.%u.%u.%u\n",
4036 card->devname, NIPQUAD(arphdr->ar_sip));
4039 /* Check that the network address is the same as ours, only
4040 * if the netowrk mask is not 255.255.255.255. Otherwise
4041 * this check would not make sense */
4043 if (in_dev->ifa_list->ifa_mask != 0xFFFFFFFF &&
4044 (in_dev->ifa_list->ifa_mask & arphdr->ar_sip) !=
4045 (in_dev->ifa_list->ifa_mask & in_dev->ifa_list->ifa_local)){
4047 "%s: Invalid PtP address. %u.%u.%u.%u InARP ignored.\n",
4048 card->devname,NIPQUAD(arphdr->ar_sip));
4050 printk(KERN_INFO "%s: mask %u.%u.%u.%u\n",
4051 card->devname, NIPQUAD(in_dev->ifa_list->ifa_mask));
4052 printk(KERN_INFO "%s: local %u.%u.%u.%u\n",
4053 card->devname,NIPQUAD(in_dev->ifa_list->ifa_local));
4057 if (in_dev->ifa_list->ifa_local == arphdr->ar_sip){
4059 "%s: Local addr = PtP addr. InARP ignored.\n",
4064 arphdr->ar_op = htons(0x09); /* InARP Reply */
4067 arphdr->ar_tip = arphdr->ar_sip;
4068 arphdr->ar_sip = in_dev->ifa_list->ifa_local;
4070 chan->ip_local = in_dev->ifa_list->ifa_local;
4071 chan->ip_remote = arphdr->ar_sip;
4073 fr_send(card, frbuf->dlci, 0, frbuf->length, (void *)ArpPacket);
4075 if (test_bit(ARP_CRIT,&card->wandev.critical)){
4076 if (net_ratelimit()){
4077 printk(KERN_INFO "%s: ARP Processed Enabling Communication!\n",
4081 clear_bit(ARP_CRIT,&card->wandev.critical);
4083 chan->ip_local = in_dev->ifa_list->ifa_local;
4084 chan->ip_remote = arphdr->ar_sip;
4086 /* Add Route Flag */
4087 /* The route will be added in the polling routine so
4088 that it is not interrupt context. */
4090 chan->route_flag = ADD_ROUTE;
4091 trigger_fr_poll (dev);
4095 case 0x09: // Inverse ARP reply
4097 /* Check for valid Address */
4098 printk(KERN_INFO "%s: Recvd PtP addr %u.%u.%u.%u -InArp Reply\n",
4099 card->devname, NIPQUAD(arphdr->ar_sip));
4102 /* Compare network addresses, only if network mask
4103 * is not 255.255.255.255 It would not make sense
4104 * to perform this test if the mask was all 1's */
4106 if (in_dev->ifa_list->ifa_mask != 0xffffffff &&
4107 (in_dev->ifa_list->ifa_mask & arphdr->ar_sip) !=
4108 (in_dev->ifa_list->ifa_mask & in_dev->ifa_list->ifa_local)) {
4110 printk(KERN_INFO "%s: Invalid PtP address. InARP ignored.\n",
4115 /* Make sure that the received IP address is not
4116 * the same as our own local address */
4117 if (in_dev->ifa_list->ifa_local == arphdr->ar_sip) {
4118 printk(KERN_INFO "%s: Local addr = PtP addr. InARP ignored.\n",
4123 chan->ip_local = in_dev->ifa_list->ifa_local;
4124 chan->ip_remote = arphdr->ar_sip;
4126 /* Add Route Flag */
4127 /* The route will be added in the polling routine so
4128 that it is not interrupt context. */
4130 chan->route_flag = ADD_ROUTE;
4131 chan->inarp = INARP_CONFIGURED;
4132 trigger_fr_poll(dev);
4136 break; // ARP's and RARP's -- Shouldn't happen.
4143 /*============================================================
4147 * Add an fr_arp() task into a arp
4148 * timer handler for a specific dlci/interface.
4149 * This will kick the fr_arp() routine
4150 * within the specified time interval.
4153 * This timer is used to send ARP requests at
4154 * certain time intervals.
4155 * Called by an interrupt to request an action
4159 static void trigger_fr_arp(struct net_device *dev)
4161 fr_channel_t* chan = dev->priv;
4163 mod_timer(&chan->fr_arp_timer, jiffies + chan->inarp_interval * HZ);
4169 /*==============================================================================
4170 * ARP Request Action
4172 * This funciton is called by timer interrupt to send an arp request
4173 * to the remote end.
4176 static void fr_arp (unsigned long data)
4178 struct net_device *dev = (struct net_device *)data;
4179 fr_channel_t *chan = dev->priv;
4180 volatile sdla_t *card = chan->card;
4181 fr508_flags_t* flags = card->flags;
4183 /* Send ARP packets for all devs' until
4184 * ARP state changes to CONFIGURED */
4186 if (chan->inarp == INARP_REQUEST &&
4187 chan->common.state == WAN_CONNECTED &&
4188 card->wandev.state == WAN_CONNECTED){
4189 set_bit(0,&chan->inarp_ready);
4190 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_ARP;
4191 flags->imask |= FR_INTR_TIMER;
4198 /*==============================================================================
4199 * Perform the Interrupt Test by running the READ_CODE_VERSION command MAX_INTR_
4200 * TEST_COUNTER times.
4202 static int intr_test( sdla_t* card )
4204 fr_mbox_t* mb = card->mbox;
4207 err = fr_set_intr_mode(card, FR_INTR_READY, card->wandev.mtu, 0 );
4209 if (err == CMD_OK) {
4211 for ( i = 0; i < MAX_INTR_TEST_COUNTER; i++ ) {
4212 /* Run command READ_CODE_VERSION */
4214 mb->cmd.command = FR_READ_CODE_VERSION;
4215 err = sdla_exec(mb) ? mb->cmd.result : CMD_TIMEOUT;
4217 fr_event(card, err, mb);
4224 err = fr_set_intr_mode( card, 0, card->wandev.mtu, 0 );
4232 /*==============================================================================
4233 * Determine what type of UDP call it is. FPIPE8ND ?
4235 static int udp_pkt_type( struct sk_buff *skb, sdla_t* card )
4237 fr_udp_pkt_t *fr_udp_pkt = (fr_udp_pkt_t *)skb->data;
4242 if((fr_udp_pkt->ip_pkt.protocol == UDPMGMT_UDP_PROTOCOL) &&
4243 (fr_udp_pkt->ip_pkt.ver_inet_hdr_length == 0x45) &&
4244 (fr_udp_pkt->udp_pkt.udp_dst_port ==
4245 ntohs(card->wandev.udp_port)) &&
4246 (fr_udp_pkt->wp_mgmt.request_reply ==
4248 if(!strncmp(fr_udp_pkt->wp_mgmt.signature,
4249 UDPMGMT_FPIPE_SIGNATURE, 8)){
4250 return UDP_FPIPE_TYPE;
4253 return UDP_INVALID_TYPE;
4257 /*==============================================================================
4258 * Initializes the Statistics values in the fr_channel structure.
4260 void init_chan_statistics( fr_channel_t* chan)
4262 memset(&chan->drvstats_if_send.if_send_entry, 0,
4263 sizeof(if_send_stat_t));
4264 memset(&chan->drvstats_rx_intr.rx_intr_no_socket, 0,
4265 sizeof(rx_intr_stat_t));
4266 memset(&chan->drvstats_gen.UDP_PIPE_mgmt_kmalloc_err, 0,
4267 sizeof(pipe_mgmt_stat_t));
4270 /*==============================================================================
4271 * Initializes the Statistics values in the Sdla_t structure.
4273 void init_global_statistics( sdla_t* card )
4275 /* Intialize global statistics for a card */
4276 memset(&card->statistics.isr_entry, 0, sizeof(global_stats_t));
4279 static void read_DLCI_IB_mapping( sdla_t* card, fr_channel_t* chan )
4281 fr_mbox_t* mbox = card->mbox;
4282 int retry = MAX_CMD_RETRY;
4283 dlci_IB_mapping_t* result;
4284 int err, counter, found;
4287 mbox->cmd.command = FR_READ_DLCI_IB_MAPPING;
4288 mbox->cmd.length = 0;
4289 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4290 } while (err && retry-- && fr_event(card, err, mbox));
4292 if( mbox->cmd.result != 0){
4293 printk(KERN_INFO "%s: Read DLCI IB Mapping failed\n",
4297 counter = mbox->cmd.length / sizeof(dlci_IB_mapping_t);
4298 result = (void *)mbox->data;
4301 for (; counter; --counter, ++result) {
4302 if ( result->dlci == chan->dlci ) {
4303 chan->IB_addr = result->addr_value;
4304 if(card->hw.type == SDLA_S514){
4305 chan->dlci_int_interface =
4306 (void*)(card->hw.dpmbase +
4309 chan->dlci_int_interface =
4310 (void*)(card->hw.dpmbase +
4311 (chan->IB_addr & 0x00001FFF));
4319 printk( KERN_INFO "%s: DLCI %d not found by IB MAPPING cmd\n",
4320 card->devname, chan->dlci);
4325 void s508_s514_lock(sdla_t *card, unsigned long *smp_flags)
4327 if (card->hw.type != SDLA_S514){
4329 spin_lock_irqsave(&card->wandev.lock, *smp_flags);
4331 spin_lock(&card->u.f.if_send_lock);
4337 void s508_s514_unlock(sdla_t *card, unsigned long *smp_flags)
4339 if (card->hw.type != SDLA_S514){
4341 spin_unlock_irqrestore (&card->wandev.lock, *smp_flags);
4343 spin_unlock(&card->u.f.if_send_lock);
4350 /*----------------------------------------------------------------------
4351 RECEIVE INTERRUPT: BOTTOM HALF HANDLERS
4352 ----------------------------------------------------------------------*/
4355 /*========================================================
4359 * Insert a received packet into a circular
4360 * rx queue. This packet will be picked up
4361 * by fr_bh() and sent up the stack to the
4365 * This function is called by rx interrupt,
4370 static int bh_enqueue(struct net_device *dev, struct sk_buff *skb)
4372 /* Check for full */
4373 fr_channel_t* chan = dev->priv;
4374 sdla_t *card = chan->card;
4377 if (atomic_read(&chan->bh_buff_used) == MAX_BH_BUFF){
4378 ++card->wandev.stats.rx_dropped;
4379 dev_kfree_skb_any(skb);
4383 ((bh_data_t *)&chan->bh_head[chan->bh_write])->skb = skb;
4385 if (chan->bh_write == (MAX_BH_BUFF-1)){
4391 atomic_inc(&chan->bh_buff_used);
4397 /*========================================================
4401 * Kick the fr_bh() handler
4404 * rx interrupt calls this function during
4408 static void trigger_fr_bh (fr_channel_t *chan)
4410 if (!test_and_set_bit(0,&chan->tq_working)){
4411 wanpipe_queue_work(&chan->common.wanpipe_work);
4416 /*========================================================
4420 * Frame relay receive BH handler.
4421 * Dequeue data from the BH circular
4422 * buffer and pass it up the API sock.
4425 * This fuction is used to offload the
4426 * rx_interrupt during API operation mode.
4427 * The fr_bh() function executes for each
4430 * Once receive interrupt copies data from the
4431 * card into an skb buffer, the skb buffer
4432 * is appended to a circular BH buffer.
4433 * Then the interrupt kicks fr_bh() to finish the
4434 * job at a later time (not within the interrupt).
4437 * Interrupts use this to defer a task to
4438 * a polling routine.
4442 static void fr_bh(struct net_device * dev)
4444 fr_channel_t* chan = dev->priv;
4445 sdla_t *card = chan->card;
4446 struct sk_buff *skb;
4448 if (atomic_read(&chan->bh_buff_used) == 0){
4449 clear_bit(0, &chan->tq_working);
4453 while (atomic_read(&chan->bh_buff_used)){
4455 if (chan->common.sk == NULL || chan->common.func == NULL){
4456 clear_bit(0, &chan->tq_working);
4460 skb = ((bh_data_t *)&chan->bh_head[chan->bh_read])->skb;
4464 if (chan->common.sk == NULL || chan->common.func == NULL){
4465 ++card->wandev.stats.rx_dropped;
4466 ++chan->ifstats.rx_dropped;
4467 dev_kfree_skb_any(skb);
4472 if (chan->common.func(skb,dev,chan->common.sk) != 0){
4473 /* Sock full cannot send, queue us for
4475 atomic_set(&chan->common.receive_block,1);
4484 clear_bit(0, &chan->tq_working);
4489 static int fr_bh_cleanup(struct net_device *dev)
4491 fr_channel_t* chan = dev->priv;
4493 ((bh_data_t *)&chan->bh_head[chan->bh_read])->skb = NULL;
4495 if (chan->bh_read == (MAX_BH_BUFF-1)){
4501 atomic_dec(&chan->bh_buff_used);
4506 /*----------------------------------------------------------------------
4507 POLL BH HANDLERS AND KICK ROUTINES
4508 ----------------------------------------------------------------------*/
4510 /*============================================================
4514 * Add a fr_poll() task into a tq_scheduler bh handler
4515 * for a specific dlci/interface. This will kick
4516 * the fr_poll() routine at a later time.
4519 * Interrupts use this to defer a taks to
4520 * a polling routine.
4523 static void trigger_fr_poll(struct net_device *dev)
4525 fr_channel_t* chan = dev->priv;
4526 schedule_work(&chan->fr_poll_work);
4531 /*============================================================
4535 * We cannot manipulate the routing tables, or
4536 * ip addresses withing the interrupt. Therefore
4537 * we must perform such actons outside an interrupt
4541 * Frame relay polling routine, responsible for
4542 * shutting down interfaces upon disconnect
4543 * and adding/removing routes.
4546 * This function is executed for each frame relay
4547 * dlci/interface through a tq_schedule bottom half.
4549 * trigger_fr_poll() function is used to kick
4550 * the fr_poll routine.
4553 static void fr_poll(struct net_device *dev)
4560 if (!dev || (chan = dev->priv) == NULL)
4565 /* (Re)Configuraiton is in progress, stop what you are
4566 * doing and get out */
4567 if (test_bit(PERI_CRIT,&card->wandev.critical)){
4571 switch (chan->common.state){
4573 case WAN_DISCONNECTED:
4575 if (test_bit(DYN_OPT_ON,&chan->interface_down) &&
4576 !test_bit(DEV_DOWN, &chan->interface_down) &&
4579 printk(KERN_INFO "%s: Interface %s is Down.\n",
4580 card->devname,dev->name);
4581 change_dev_flags(dev,dev->flags&~IFF_UP);
4582 set_bit(DEV_DOWN, &chan->interface_down);
4583 chan->route_flag = NO_ROUTE;
4586 if (chan->inarp != INARP_NONE)
4593 if (test_bit(DYN_OPT_ON,&chan->interface_down) &&
4594 test_bit(DEV_DOWN, &chan->interface_down) &&
4595 !(dev->flags&IFF_UP)){
4597 printk(KERN_INFO "%s: Interface %s is Up.\n",
4598 card->devname,dev->name);
4600 change_dev_flags(dev,dev->flags|IFF_UP);
4601 clear_bit(DEV_DOWN, &chan->interface_down);
4605 if (chan->inarp != INARP_NONE){
4610 if (chan->gateway && check_gateway)
4611 add_gateway(card,dev);
4620 /*==============================================================
4624 * We cannot transmit from an interrupt while
4625 * the if_send is transmitting data. Therefore,
4626 * we must check whether the tx buffers are
4627 * begin used, before we transmit from an
4631 * Checks whether it's safe to use the transmit
4635 * ARP and UDP handling routines use this function
4636 * because, they need to transmit data during
4640 static int check_tx_status(sdla_t *card, struct net_device *dev)
4643 if (card->hw.type == SDLA_S514){
4644 if (test_bit(SEND_CRIT, (void*)&card->wandev.critical) ||
4645 test_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical)) {
4650 if (netif_queue_stopped(dev) || (card->u.f.tx_interrupts_pending))
4656 /*===============================================================
4660 * Move the dev pointer to the next location in the
4661 * link list. Check if we are at the end of the
4662 * list, if so start from the begining.
4665 * Timer interrupt uses this function to efficiently
4666 * step through the devices that need to send ARP data.
4670 struct net_device *move_dev_to_next(sdla_t *card, struct net_device *dev)
4672 if (card->wandev.new_if_cnt != 1){
4673 if (!*((struct net_device **)dev->priv))
4674 return card->wandev.dev;
4676 return *((struct net_device **)dev->priv);
4681 /*==============================================================
4685 * All commands must be performed inside of a
4689 * Kick the config_fr() routine throught the
4694 static void trigger_config_fr (sdla_t *card)
4696 fr508_flags_t* flags = card->flags;
4698 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_CONFIG;
4699 flags->imask |= FR_INTR_TIMER;
4703 /*==============================================================
4707 * All commands must be performed inside of a
4711 * Configure a DLCI. This function is executed
4712 * by a timer_interrupt. The if_open() function
4716 * new_if() collects all data necessary to
4717 * configure the DLCI. It sets the chan->dlci_ready
4718 * bit. When the if_open() function is executed
4719 * it checks this bit, and if its set it triggers
4720 * the timer interrupt to execute the config_fr()
4724 static void config_fr (sdla_t *card)
4726 struct net_device *dev;
4729 for (dev = card->wandev.dev; dev;
4730 dev = *((struct net_device **)dev->priv)) {
4732 if ((chan=dev->priv) == NULL)
4735 if (!test_bit(0,&chan->config_dlci))
4738 clear_bit(0,&chan->config_dlci);
4740 /* If signalling is set to NO, then setup
4741 * DLCI addresses right away. Don't have to wait for
4744 if (card->wandev.signalling == WANOPT_NO){
4745 printk(KERN_INFO "%s: Signalling set to NO: Mapping DLCI's\n",
4747 if (fr_init_dlci(card,chan)){
4748 printk(KERN_INFO "%s: ERROR: Failed to configure DLCI %i !\n",
4749 card->devname, chan->dlci);
4754 if (card->wandev.station == WANOPT_CPE) {
4756 update_chan_state(dev);
4758 /* CPE: issue full status enquiry */
4759 fr_issue_isf(card, FR_ISF_FSE);
4762 /* FR switch: activate DLCI(s) */
4764 /* For Switch emulation we have to ADD and ACTIVATE
4765 * the DLCI(s) that were configured with the SET_DLCI_
4766 * CONFIGURATION command. Add and Activate will fail if
4767 * DLCI specified is not included in the list.
4769 * Also If_open is called once for each interface. But
4770 * it does not get in here for all the interface. So
4771 * we have to pass the entire list of DLCI(s) to add
4772 * activate routines.
4775 if (!check_dlci_config (card, chan)){
4776 fr_add_dlci(card, chan->dlci);
4777 fr_activate_dlci(card, chan->dlci);
4781 card->u.f.dlci_to_dev_map[chan->dlci] = dev;
4787 /*==============================================================
4791 * All commands must be executed during an interrupt.
4794 * Trigger uncofig_fr() function through
4795 * the timer interrupt.
4799 static void trigger_unconfig_fr(struct net_device *dev)
4801 fr_channel_t *chan = dev->priv;
4802 volatile sdla_t *card = chan->card;
4803 unsigned long timeout;
4804 fr508_flags_t* flags = card->flags;
4805 int reset_critical=0;
4807 if (test_bit(PERI_CRIT,(void*)&card->wandev.critical)){
4808 clear_bit(PERI_CRIT,(void*)&card->wandev.critical);
4812 /* run unconfig_dlci() function
4813 * throught the timer interrupt */
4814 set_bit(0,(void*)&chan->unconfig_dlci);
4815 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UNCONFIG;
4816 flags->imask |= FR_INTR_TIMER;
4818 /* Wait for the command to complete */
4822 if(!(card->u.f.timer_int_enabled & TMR_INT_ENABLED_UNCONFIG))
4825 if (time_after(jiffies, timeout + 1 * HZ)){
4826 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UNCONFIG;
4827 printk(KERN_INFO "%s: Failed to delete DLCI %i\n",
4828 card->devname,chan->dlci);
4833 if (reset_critical){
4834 set_bit(PERI_CRIT,(void*)&card->wandev.critical);
4838 /*==============================================================
4842 * All commands must be executed during an interrupt.
4845 * Remove the dlci from firmware.
4846 * This funciton is used in NODE shutdown.
4849 static void unconfig_fr (sdla_t *card)
4851 struct net_device *dev;
4854 for (dev = card->wandev.dev; dev;
4855 dev = *((struct net_device **)dev->priv)){
4857 if ((chan=dev->priv) == NULL)
4860 if (!test_bit(0,&chan->unconfig_dlci))
4863 clear_bit(0,&chan->unconfig_dlci);
4865 if (card->wandev.station == WANOPT_NODE){
4866 printk(KERN_INFO "%s: Unconfiguring DLCI %i\n",
4867 card->devname,chan->dlci);
4868 fr_delete_dlci(card,chan->dlci);
4870 card->u.f.dlci_to_dev_map[chan->dlci] = NULL;
4874 static int setup_fr_header(struct sk_buff **skb_orig, struct net_device* dev,
4877 struct sk_buff *skb = *skb_orig;
4878 fr_channel_t *chan=dev->priv;
4880 if (op_mode == WANPIPE){
4882 chan->fr_header[0]=Q922_UI;
4884 switch (htons(skb->protocol)){
4887 chan->fr_header[1]=NLPID_IP;
4896 /* If we are in bridging mode, we must apply
4897 * an Ethernet header */
4898 if (op_mode == BRIDGE || op_mode == BRIDGE_NODE){
4901 /* Encapsulate the packet as a bridged Ethernet frame. */
4903 printk(KERN_INFO "%s: encapsulating skb for frame relay\n",
4907 chan->fr_header[0] = 0x03;
4908 chan->fr_header[1] = 0x00;
4909 chan->fr_header[2] = 0x80;
4910 chan->fr_header[3] = 0x00;
4911 chan->fr_header[4] = 0x80;
4912 chan->fr_header[5] = 0xC2;
4913 chan->fr_header[6] = 0x00;
4914 chan->fr_header[7] = 0x07;
4917 skb->protocol = ETH_P_802_3;
4926 static int check_dlci_config (sdla_t *card, fr_channel_t *chan)
4928 fr_mbox_t* mbox = card->mbox;
4930 fr_conf_t *conf=NULL;
4931 unsigned short dlci_num = chan->dlci;
4933 struct net_device *dev = NULL;
4935 mbox->cmd.command = FR_READ_CONFIG;
4936 mbox->cmd.length = 0;
4937 mbox->cmd.dlci = dlci_num;
4939 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4945 for (dev = card->wandev.dev; dev;
4946 dev=*((struct net_device **)dev->priv))
4947 set_chan_state(dev,WAN_DISCONNECTED);
4949 printk(KERN_INFO "DLCI %i Not configured, configuring\n",dlci_num);
4951 mbox->cmd.command = FR_COMM_DISABLE;
4952 mbox->cmd.length = 0;
4953 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4955 fr_event(card, err, mbox);
4959 printk(KERN_INFO "Disabled Communications \n");
4961 mbox->cmd.command = FR_READ_CONFIG;
4962 mbox->cmd.length = 0;
4965 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4968 fr_event(card, err, mbox);
4972 conf = (fr_conf_t *)mbox->data;
4975 for (dev = card->wandev.dev; dev;
4976 dev = *((struct net_device **)dev->priv)) {
4977 fr_channel_t *chan_tmp = dev->priv;
4978 conf->dlci[dlci_offset] = chan_tmp->dlci;
4982 printk(KERN_INFO "Got Fr configuration Buffer Length is %x Dlci %i Dlci Off %i\n",
4984 mbox->cmd.length > 0x20 ? conf->dlci[0] : -1,
4987 mbox->cmd.length = 0x20 + dlci_offset*2;
4989 mbox->cmd.command = FR_SET_CONFIG;
4992 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4995 fr_event(card, err, mbox);
4999 initialize_rx_tx_buffers (card);
5002 printk(KERN_INFO "Configuraiton Succeded for new DLCI %i\n",dlci_num);
5004 if (fr_comm_enable (card)){
5008 printk(KERN_INFO "Enabling Communications \n");
5010 for (dev = card->wandev.dev; dev;
5011 dev = *((struct net_device **)dev->priv)) {
5012 fr_channel_t *chan_tmp = dev->priv;
5013 fr_init_dlci(card,chan_tmp);
5014 fr_add_dlci(card, chan_tmp->dlci);
5015 fr_activate_dlci(card, chan_tmp->dlci);
5018 printk(KERN_INFO "END OF CONFIGURAITON %i\n",dlci_num);
5023 static void initialize_rx_tx_buffers (sdla_t *card)
5025 fr_buf_info_t* buf_info;
5027 if (card->hw.type == SDLA_S514) {
5029 buf_info = (void*)(card->hw.dpmbase + FR_MB_VECTOR +
5032 card->rxmb = (void*)(buf_info->rse_next + card->hw.dpmbase);
5034 card->u.f.rxmb_base =
5035 (void*)(buf_info->rse_base + card->hw.dpmbase);
5037 card->u.f.rxmb_last =
5038 (void*)(buf_info->rse_base +
5039 (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) +
5042 buf_info = (void*)(card->hw.dpmbase + FR508_RXBC_OFFS);
5044 card->rxmb = (void*)(buf_info->rse_next -
5045 FR_MB_VECTOR + card->hw.dpmbase);
5047 card->u.f.rxmb_base =
5048 (void*)(buf_info->rse_base -
5049 FR_MB_VECTOR + card->hw.dpmbase);
5051 card->u.f.rxmb_last =
5052 (void*)(buf_info->rse_base +
5053 (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) -
5054 FR_MB_VECTOR + card->hw.dpmbase);
5057 card->u.f.rx_base = buf_info->buf_base;
5058 card->u.f.rx_top = buf_info->buf_top;
5060 card->u.f.tx_interrupts_pending = 0;
5067 MODULE_LICENSE("GPL");
5069 /****** End *****************************************************************/
projects / linux-2.6 / blob