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 <asm/errno.h>
157 #include <linux/ip.h>
158 #include <linux/if.h>
160 #include <linux/if_wanpipe_common.h> /* Wanpipe Socket */
161 #include <linux/if_wanpipe.h>
163 #include <linux/sdla_fr.h> /* frame relay firmware API definitions */
165 #include <asm/uaccess.h>
166 #include <linux/inetdevice.h>
167 #include <linux/netdevice.h>
169 #include <net/route.h> /* Dynamic Route Creation */
170 #include <linux/etherdevice.h> /* eth_type_trans() used for bridging */
171 #include <linux/random.h>
173 /****** Defines & Macros ****************************************************/
175 #define MAX_CMD_RETRY 10 /* max number of firmware retries */
177 #define FR_HEADER_LEN 8 /* max encapsulation header size */
178 #define FR_CHANNEL_MTU 1500 /* unfragmented logical channel MTU */
180 /* Q.922 frame types */
181 #define Q922_UI 0x03 /* Unnumbered Info frame */
182 #define Q922_XID 0xAF
184 /* DLCI configured or not */
185 #define DLCI_NOT_CONFIGURED 0x00
186 #define DLCI_CONFIG_PENDING 0x01
187 #define DLCI_CONFIGURED 0x02
189 /* CIR enabled or not */
190 #define CIR_ENABLED 0x00
191 #define CIR_DISABLED 0x01
193 #define FRAME_RELAY_API 1
194 #define MAX_BH_BUFF 10
196 /* For handle_IPXWAN() */
197 #define CVHexToAscii(b) (((unsigned char)(b) > (unsigned char)9) ? ((unsigned char)'A' + ((unsigned char)(b) - (unsigned char)10)) : ((unsigned char)'0' + (unsigned char)(b)))
199 /****** Data Structures *****************************************************/
201 /* This is an extention of the 'struct device' we create for each network
202 * interface to keep the rest of channel-specific data.
204 typedef struct fr_channel
206 wanpipe_common_t common;
207 char name[WAN_IFNAME_SZ+1]; /* interface name, ASCIIZ */
208 unsigned dlci_configured ; /* check whether configured or not */
209 unsigned cir_status; /* check whether CIR enabled or not */
210 unsigned dlci; /* logical channel number */
211 unsigned cir; /* committed information rate */
212 unsigned bc; /* committed burst size */
213 unsigned be; /* excess burst size */
214 unsigned mc; /* multicast support on or off */
215 unsigned tx_int_status; /* Transmit Interrupt Status */
216 unsigned short pkt_length; /* Packet Length */
217 unsigned long router_start_time;/* Router start time in seconds */
218 unsigned long tick_counter; /* counter for transmit time out */
219 char dev_pending_devtint; /* interface pending dev_tint() */
220 void *dlci_int_interface; /* pointer to the DLCI Interface */
221 unsigned long IB_addr; /* physical address of Interface Byte */
222 unsigned long state_tick; /* time of the last state change */
223 unsigned char enable_IPX; /* Enable/Disable the use of IPX */
224 unsigned long network_number; /* Internal Network Number for IPX*/
225 sdla_t *card; /* -> owner */
226 unsigned route_flag; /* Add/Rem dest addr in route tables */
227 unsigned inarp; /* Inverse Arp Request status */
228 long inarp_ready; /* Ready to send requests */
229 int inarp_interval; /* Time between InArp Requests */
230 unsigned long inarp_tick; /* InArp jiffies tick counter */
231 long interface_down; /* Bring interface down on disconnect */
232 struct net_device_stats ifstats; /* interface statistics */
233 if_send_stat_t drvstats_if_send;
234 rx_intr_stat_t drvstats_rx_intr;
235 pipe_mgmt_stat_t drvstats_gen;
236 unsigned long router_up_time;
238 unsigned short transmit_length;
239 struct sk_buff *delay_skb;
241 bh_data_t *bh_head; /* Circular buffer for chdlc_bh */
242 unsigned long tq_working;
243 volatile int bh_write;
244 volatile int bh_read;
245 atomic_t bh_buff_used;
247 /* Polling task queue. Each interface
248 * has its own task queue, which is used
249 * to defer events from the interrupt */
250 struct work_struct fr_poll_work;
251 struct timer_list fr_arp_timer;
258 /* Whether this interface should be setup as a gateway.
259 * Used by dynamic route setup code */
262 /* True interface type */
264 u8 fr_header[FR_HEADER_LEN];
269 /* Route Flag options */
270 #define NO_ROUTE 0x00
271 #define ADD_ROUTE 0x01
272 #define ROUTE_ADDED 0x02
273 #define REMOVE_ROUTE 0x03
277 #define INARP_NONE 0x00
278 #define INARP_REQUEST 0x01
279 #define INARP_CONFIGURED 0x02
281 /* reasons for enabling the timer interrupt on the adapter */
282 #define TMR_INT_ENABLED_UDP 0x01
283 #define TMR_INT_ENABLED_UPDATE 0x02
284 #define TMR_INT_ENABLED_ARP 0x04
285 #define TMR_INT_ENABLED_UPDATE_STATE 0x08
286 #define TMR_INT_ENABLED_CONFIG 0x10
287 #define TMR_INT_ENABLED_UNCONFIG 0x20
290 typedef struct dlci_status
292 unsigned short dlci PACKED;
293 unsigned char state PACKED;
296 typedef struct dlci_IB_mapping
298 unsigned short dlci PACKED;
299 unsigned long addr_value PACKED;
302 /* This structure is used for DLCI list Tx interrupt mode. It is used to
303 enable interrupt bit and set the packet length for transmission
305 typedef struct fr_dlci_interface
307 unsigned char gen_interrupt PACKED;
308 unsigned short packet_length PACKED;
309 unsigned char reserved PACKED;
310 } fr_dlci_interface_t;
312 /* variable for keeping track of enabling/disabling FT1 monitor status */
313 static int rCount = 0;
315 extern void disable_irq(unsigned int);
316 extern void enable_irq(unsigned int);
318 /* variable for keeping track of number of interrupts generated during
319 * interrupt test routine
321 static int Intr_test_counter;
323 /****** Function Prototypes *************************************************/
325 /* WAN link driver entry points. These are called by the WAN router module. */
326 static int update(struct wan_device *wandev);
327 static int new_if(struct wan_device *wandev, struct net_device *dev,
329 static int del_if(struct wan_device *wandev, struct net_device *dev);
330 static void disable_comm (sdla_t *card);
332 /* WANPIPE-specific entry points */
333 static int wpf_exec(struct sdla *card, void *u_cmd, void *u_data);
335 /* Network device interface */
336 static int if_init(struct net_device *dev);
337 static int if_open(struct net_device *dev);
338 static int if_close(struct net_device *dev);
340 static void if_tx_timeout(struct net_device *dev);
342 static int if_rebuild_hdr (struct sk_buff *skb);
344 static int if_send(struct sk_buff *skb, struct net_device *dev);
345 static int chk_bcast_mcast_addr(sdla_t *card, struct net_device* dev,
346 struct sk_buff *skb);
347 static struct net_device_stats *if_stats(struct net_device *dev);
349 /* Interrupt handlers */
350 static void fr_isr(sdla_t *card);
351 static void rx_intr(sdla_t *card);
352 static void tx_intr(sdla_t *card);
353 static void timer_intr(sdla_t *card);
354 static void spur_intr(sdla_t *card);
356 /* Frame relay firmware interface functions */
357 static int fr_read_version(sdla_t *card, char *str);
358 static int fr_configure(sdla_t *card, fr_conf_t *conf);
359 static int fr_dlci_configure(sdla_t *card, fr_dlc_conf_t *conf, unsigned dlci);
360 static int fr_init_dlci (sdla_t *card, fr_channel_t *chan);
361 static int fr_set_intr_mode (sdla_t *card, unsigned mode, unsigned mtu, unsigned short timeout);
362 static int fr_comm_enable(sdla_t *card);
363 static void fr_comm_disable(sdla_t *card);
364 static int fr_get_err_stats(sdla_t *card);
365 static int fr_get_stats(sdla_t *card);
366 static int fr_add_dlci(sdla_t *card, int dlci);
367 static int fr_activate_dlci(sdla_t *card, int dlci);
368 static int fr_delete_dlci (sdla_t* card, int dlci);
369 static int fr_issue_isf(sdla_t *card, int isf);
370 static int fr_send(sdla_t *card, int dlci, unsigned char attr, int len,
372 static int fr_send_data_header(sdla_t *card, int dlci, unsigned char attr, int len,
373 void *buf,unsigned char hdr_len);
374 static unsigned int fr_send_hdr(sdla_t *card, int dlci, unsigned int offset);
376 static int check_dlci_config (sdla_t *card, fr_channel_t *chan);
377 static void initialize_rx_tx_buffers (sdla_t *card);
380 /* Firmware asynchronous event handlers */
381 static int fr_event(sdla_t *card, int event, fr_mbox_t *mbox);
382 static int fr_modem_failure(sdla_t *card, fr_mbox_t *mbox);
383 static int fr_dlci_change(sdla_t *card, fr_mbox_t *mbox);
385 /* Miscellaneous functions */
386 static int update_chan_state(struct net_device *dev);
387 static void set_chan_state(struct net_device *dev, int state);
388 static struct net_device *find_channel(sdla_t *card, unsigned dlci);
389 static int is_tx_ready(sdla_t *card, fr_channel_t *chan);
390 static unsigned int dec_to_uint(unsigned char *str, int len);
391 static int reply_udp( unsigned char *data, unsigned int mbox_len );
393 static int intr_test( sdla_t* card );
394 static void init_chan_statistics( fr_channel_t* chan );
395 static void init_global_statistics( sdla_t* card );
396 static void read_DLCI_IB_mapping( sdla_t* card, fr_channel_t* chan );
397 static int setup_for_delayed_transmit(struct net_device* dev,
398 struct sk_buff *skb);
400 struct net_device *move_dev_to_next(sdla_t *card, struct net_device *dev);
401 static int check_tx_status(sdla_t *card, struct net_device *dev);
403 /* Frame Relay Socket API */
404 static void trigger_fr_bh (fr_channel_t *);
405 static void fr_bh(struct net_device *dev);
406 static int fr_bh_cleanup(struct net_device *dev);
407 static int bh_enqueue(struct net_device *dev, struct sk_buff *skb);
409 static void trigger_fr_poll(struct net_device *dev);
410 static void fr_poll(struct net_device *dev);
411 //static void add_gateway(struct net_device *dev);
413 static void trigger_unconfig_fr(struct net_device *dev);
414 static void unconfig_fr (sdla_t *);
416 static void trigger_config_fr (sdla_t *);
417 static void config_fr (sdla_t *);
420 /* Inverse ARP and Dynamic routing functions */
421 int process_ARP(arphdr_1490_t *ArpPacket, sdla_t *card, struct net_device *dev);
422 int is_arp(void *buf);
423 int send_inarp_request(sdla_t *card, struct net_device *dev);
425 static void trigger_fr_arp(struct net_device *dev);
426 static void fr_arp (unsigned long data);
429 /* Udp management functions */
430 static int process_udp_mgmt_pkt(sdla_t *card);
431 static int udp_pkt_type( struct sk_buff *skb, sdla_t *card );
432 static int store_udp_mgmt_pkt(int udp_type, char udp_pkt_src, sdla_t* card,
433 struct sk_buff *skb, int dlci);
436 static void switch_net_numbers(unsigned char *sendpacket,
437 unsigned long network_number, unsigned char incoming);
439 static int handle_IPXWAN(unsigned char *sendpacket, char *devname,
440 unsigned char enable_IPX, unsigned long network_number);
442 /* Lock Functions: SMP supported */
443 void s508_s514_unlock(sdla_t *card, unsigned long *smp_flags);
444 void s508_s514_lock(sdla_t *card, unsigned long *smp_flags);
446 unsigned short calc_checksum (char *, int);
447 static int setup_fr_header(struct sk_buff** skb,
448 struct net_device* dev, char op_mode);
451 /****** Public Functions ****************************************************/
453 /*============================================================================
454 * Frame relay protocol initialization routine.
456 * This routine is called by the main WANPIPE module during setup. At this
457 * point adapter is completely initialized and firmware is running.
458 * o read firmware version (to make sure it's alive)
459 * o configure adapter
460 * o initialize protocol-specific fields of the adapter data space.
465 int wpf_init(sdla_t *card, wandev_conf_t *conf)
469 fr508_flags_t* flags;
477 fr_buf_info_t* buf_info;
481 printk(KERN_INFO "\n");
483 /* Verify configuration ID */
484 if (conf->config_id != WANCONFIG_FR) {
486 printk(KERN_INFO "%s: invalid configuration ID %u!\n",
487 card->devname, conf->config_id);
492 /* Initialize protocol-specific fields of adapter data space */
493 switch (card->hw.fwid) {
496 card->mbox = (void*)(card->hw.dpmbase +
498 card->flags = (void*)(card->hw.dpmbase +
500 if(card->hw.type == SDLA_S514) {
501 card->mbox += FR_MB_VECTOR;
502 card->flags += FR_MB_VECTOR;
513 /* Read firmware version. Note that when adapter initializes, it
514 * clears the mailbox, so it may appear that the first command was
515 * executed successfully when in fact it was merely erased. To work
516 * around this, we execute the first command twice.
519 if (fr_read_version(card, NULL) || fr_read_version(card, u.str))
522 printk(KERN_INFO "%s: running frame relay firmware v%s\n",
523 card->devname, u.str);
525 /* Adjust configuration */
526 conf->mtu += FR_HEADER_LEN;
527 conf->mtu = (conf->mtu >= MIN_LGTH_FR_DATA_CFG) ?
528 min_t(unsigned int, conf->mtu, FR_MAX_NO_DATA_BYTES_IN_FRAME) :
529 FR_CHANNEL_MTU + FR_HEADER_LEN;
531 conf->bps = min_t(unsigned int, conf->bps, 2048000);
533 /* Initialze the configuration structure sent to the board to zero */
534 memset(&u.cfg, 0, sizeof(u.cfg));
536 memset(card->u.f.dlci_to_dev_map, 0, sizeof(card->u.f.dlci_to_dev_map));
538 /* Configure adapter firmware */
540 u.cfg.mtu = conf->mtu;
541 u.cfg.kbps = conf->bps / 1000;
543 u.cfg.cir_fwd = u.cfg.cir_bwd = 16;
544 u.cfg.bc_fwd = u.cfg.bc_bwd = 16;
546 u.cfg.options = 0x0000;
547 printk(KERN_INFO "%s: Global CIR enabled by Default\n", card->devname);
549 switch (conf->u.fr.signalling) {
552 u.cfg.options = 0x0000;
556 u.cfg.options |= 0x0200;
560 u.cfg.options |= 0x0400;
564 u.cfg.options |= 0x0800;
567 printk(KERN_INFO "%s: Illegal Signalling option\n",
573 card->wandev.signalling = conf->u.fr.signalling;
575 if (conf->station == WANOPT_CPE) {
578 if (conf->u.fr.signalling == WANOPT_NO){
580 "%s: ERROR - For NO signalling, station must be set to Node!",
586 u.cfg.options |= 0x8000; /* auto config DLCI */
587 card->u.f.dlci_num = 0;
591 u.cfg.station = 1; /* switch emulation mode */
593 /* For switch emulation we have to create a list of dlci(s)
594 * that will be sent to be global SET_DLCI_CONFIGURATION
595 * command in fr_configure() routine.
598 card->u.f.dlci_num = min_t(unsigned int, max_t(unsigned int, conf->u.fr.dlci_num, 1), 100);
600 for ( i = 0; i < card->u.f.dlci_num; i++) {
602 card->u.f.node_dlci[i] = (unsigned short)
603 conf->u.fr.dlci[i] ? conf->u.fr.dlci[i] : 16;
608 if (conf->clocking == WANOPT_INTERNAL)
609 u.cfg.port |= 0x0001;
611 if (conf->interface == WANOPT_RS232)
612 u.cfg.port |= 0x0002;
615 u.cfg.t391 = min_t(unsigned int, conf->u.fr.t391, 30);
620 u.cfg.t392 = min_t(unsigned int, conf->u.fr.t392, 30);
625 u.cfg.n391 = min_t(unsigned int, conf->u.fr.n391, 255);
630 u.cfg.n392 = min_t(unsigned int, conf->u.fr.n392, 10);
635 u.cfg.n393 = min_t(unsigned int, conf->u.fr.n393, 10);
639 if (fr_configure(card, &u.cfg))
642 if (card->hw.type == SDLA_S514) {
644 buf_info = (void*)(card->hw.dpmbase + FR_MB_VECTOR +
647 card->rxmb = (void*)(buf_info->rse_next + card->hw.dpmbase);
649 card->u.f.rxmb_base =
650 (void*)(buf_info->rse_base + card->hw.dpmbase);
652 card->u.f.rxmb_last =
653 (void*)(buf_info->rse_base +
654 (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) +
657 buf_info = (void*)(card->hw.dpmbase + FR508_RXBC_OFFS);
659 card->rxmb = (void*)(buf_info->rse_next -
660 FR_MB_VECTOR + card->hw.dpmbase);
662 card->u.f.rxmb_base =
663 (void*)(buf_info->rse_base -
664 FR_MB_VECTOR + card->hw.dpmbase);
666 card->u.f.rxmb_last =
667 (void*)(buf_info->rse_base +
668 (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) -
669 FR_MB_VECTOR + card->hw.dpmbase);
672 card->u.f.rx_base = buf_info->buf_base;
673 card->u.f.rx_top = buf_info->buf_top;
675 card->u.f.tx_interrupts_pending = 0;
677 card->wandev.mtu = conf->mtu;
678 card->wandev.bps = conf->bps;
679 card->wandev.interface = conf->interface;
680 card->wandev.clocking = conf->clocking;
681 card->wandev.station = conf->station;
683 card->exec = &wpf_exec;
684 card->wandev.update = &update;
685 card->wandev.new_if = &new_if;
686 card->wandev.del_if = &del_if;
687 card->wandev.state = WAN_DISCONNECTED;
688 card->wandev.ttl = conf->ttl;
689 card->wandev.udp_port = conf->udp_port;
690 card->disable_comm = &disable_comm;
691 card->u.f.arp_dev = NULL;
693 /* Intialize global statistics for a card */
694 init_global_statistics( card );
696 card->TracingEnabled = 0;
699 Intr_test_counter = 0;
700 card->intr_mode = INTR_TEST_MODE;
701 err = intr_test( card );
703 printk(KERN_INFO "%s: End of Interrupt Test rc=0x%x count=%i\n",
704 card->devname,err,Intr_test_counter);
706 if (err || (Intr_test_counter < MAX_INTR_TEST_COUNTER)) {
707 printk(KERN_ERR "%s: Interrupt Test Failed, Counter: %i\n",
708 card->devname, Intr_test_counter);
709 printk(KERN_ERR "Please choose another interrupt\n");
714 printk(KERN_INFO "%s: Interrupt Test Passed, Counter: %i\n",
715 card->devname, Intr_test_counter);
718 /* Apr 28 2000. Nenad Corbic
719 * Enable commnunications here, not in if_open or new_if, since
720 * interfaces come down when the link is disconnected.
723 /* If you enable comms and then set ints, you get a Tx int as you
724 * perform the SET_INT_TRIGGERS command. So, we only set int
725 * triggers and then adjust the interrupt mask (to disable Tx ints)
726 * before enabling comms.
728 if (fr_set_intr_mode(card, (FR_INTR_RXRDY | FR_INTR_TXRDY |
729 FR_INTR_DLC | FR_INTR_TIMER | FR_INTR_TX_MULT_DLCIs) ,
730 card->wandev.mtu, 0)) {
734 flags->imask &= ~(FR_INTR_TXRDY | FR_INTR_TIMER);
736 if (fr_comm_enable(card)) {
739 wanpipe_set_state(card, WAN_CONNECTED);
740 spin_lock_init(&card->u.f.if_send_lock);
742 printk(KERN_INFO "\n");
747 /******* WAN Device Driver Entry Points *************************************/
749 /*============================================================================
750 * Update device status & statistics.
752 static int update(struct wan_device* wandev)
754 volatile sdla_t* card;
755 unsigned long timeout;
756 fr508_flags_t* flags;
759 if ((wandev == NULL) || (wandev->private == NULL))
762 if (wandev->state == WAN_UNCONFIGURED)
765 card = wandev->private;
769 card->u.f.update_comms_stats = 1;
770 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UPDATE;
771 flags->imask |= FR_INTR_TIMER;
774 if(card->u.f.update_comms_stats == 0)
776 if ((jiffies - timeout) > (1 * HZ)){
777 card->u.f.update_comms_stats = 0;
785 /*============================================================================
786 * Create new logical channel.
787 * This routine is called by the router when ROUTER_IFNEW IOCTL is being
789 * o parse media- and hardware-specific configuration
790 * o make sure that a new channel can be created
791 * o allocate resources, if necessary
792 * o prepare network device structure for registaration.
795 * < 0 failure (channel will not be created)
797 static int new_if(struct wan_device* wandev, struct net_device* dev,
800 sdla_t* card = wandev->private;
806 if ((conf->name[0] == '\0') || (strlen(conf->name) > WAN_IFNAME_SZ)) {
808 printk(KERN_INFO "%s: Invalid interface name!\n",
813 /* allocate and initialize private data */
814 chan = kmalloc(sizeof(fr_channel_t), GFP_KERNEL);
819 memset(chan, 0, sizeof(fr_channel_t));
820 strcpy(chan->name, conf->name);
823 /* verify media address */
824 if (is_digit(conf->addr[0])) {
826 dlci = dec_to_uint(conf->addr, 0);
828 if (dlci && (dlci <= HIGHEST_VALID_DLCI)) {
835 "%s: Invalid DLCI %u on interface %s!\n",
836 wandev->name, dlci, chan->name);
842 "%s: Invalid media address on interface %s!\n",
843 wandev->name, chan->name);
847 if ((chan->true_if_encoding = conf->true_if_encoding) == WANOPT_YES){
849 "%s: Enabling, true interface type encoding.\n",
855 /* Setup wanpipe as a router (WANPIPE) even if it is
856 * a bridged DLCI, or as an API
858 if (strcmp(conf->usedby, "WANPIPE") == 0 ||
859 strcmp(conf->usedby, "BRIDGE") == 0 ||
860 strcmp(conf->usedby, "BRIDGE_N") == 0){
862 if(strcmp(conf->usedby, "WANPIPE") == 0){
863 chan->common.usedby = WANPIPE;
865 printk(KERN_INFO "%s: Running in WANPIPE mode.\n",
868 }else if(strcmp(conf->usedby, "BRIDGE") == 0){
870 chan->common.usedby = BRIDGE;
872 printk(KERN_INFO "%s: Running in WANPIPE (BRIDGE) mode.\n",
874 }else if( strcmp(conf->usedby, "BRIDGE_N") == 0 ){
876 chan->common.usedby = BRIDGE_NODE;
878 printk(KERN_INFO "%s: Running in WANPIPE (BRIDGE_NODE) mode.\n",
883 /* Dynamic interface configuration option.
884 * On disconnect, if the options is selected,
885 * the interface will be brought down */
886 if (conf->if_down == WANOPT_YES){
887 set_bit(DYN_OPT_ON,&chan->interface_down);
889 "%s: Dynamic interface configuration enabled.\n",
894 } else if(strcmp(conf->usedby, "API") == 0){
896 chan->common.usedby = API;
897 printk(KERN_INFO "%s: Running in API mode.\n",
907 /* place cir,be,bc and other channel specific information into the
912 chan->cir = max_t(unsigned int, 1,
913 min_t(unsigned int, conf->cir, 512));
914 chan->cir_status = CIR_ENABLED;
917 /* If CIR is enabled, force BC to equal CIR
918 * this solves number of potential problems if CIR is
921 chan->bc = chan->cir;
924 chan->be = max_t(unsigned int,
925 0, min_t(unsigned int, conf->be, 511));
930 printk (KERN_INFO "%s: CIR enabled for DLCI %i \n",
931 wandev->name,chan->dlci);
932 printk (KERN_INFO "%s: CIR = %i ; BC = %i ; BE = %i\n",
933 wandev->name,chan->cir,chan->bc,chan->be);
937 chan->cir_status = CIR_DISABLED;
938 printk (KERN_INFO "%s: CIR disabled for DLCI %i\n",
939 wandev->name,chan->dlci);
944 if (conf->inarp == WANOPT_YES){
945 printk(KERN_INFO "%s: Inverse ARP Support Enabled\n",card->devname);
946 chan->inarp = conf->inarp ? INARP_REQUEST : INARP_NONE;
947 chan->inarp_interval = conf->inarp_interval ? conf->inarp_interval : 10;
949 printk(KERN_INFO "%s: Inverse ARP Support Disabled\n",card->devname);
950 chan->inarp = INARP_NONE;
951 chan->inarp_interval = 10;
955 chan->dlci_configured = DLCI_NOT_CONFIGURED;
958 /*FIXME: IPX disabled in this WANPIPE version */
959 if (conf->enable_IPX == WANOPT_YES){
960 printk(KERN_INFO "%s: ERROR - This version of WANPIPE doesn't support IPX\n",
965 chan->enable_IPX = WANOPT_NO;
968 if (conf->network_number){
969 chan->network_number = conf->network_number;
971 chan->network_number = 0xDEADBEEF;
974 chan->route_flag = NO_ROUTE;
976 init_chan_statistics(chan);
978 chan->transmit_length = 0;
980 /* prepare network device data space for registration */
981 strcpy(dev->name,chan->name);
983 dev->init = &if_init;
986 /* Initialize FR Polling Task Queue
987 * We need a poll routine for each network
990 INIT_WORK(&chan->fr_poll_work, (void *)fr_poll, dev);
992 init_timer(&chan->fr_arp_timer);
993 chan->fr_arp_timer.data=(unsigned long)dev;
994 chan->fr_arp_timer.function = fr_arp;
996 wandev->new_if_cnt++;
998 /* Tells us that if this interface is a
1000 if ((chan->gateway = conf->gateway) == WANOPT_YES){
1001 printk(KERN_INFO "%s: Interface %s is set as a gateway.\n",
1002 card->devname,dev->name);
1005 /* M. Grant Patch Apr 28 2000
1006 * Disallow duplicate dlci configurations. */
1007 if (card->u.f.dlci_to_dev_map[chan->dlci] != NULL) {
1012 /* Configure this dlci at a later date, when
1013 * the interface comes up. i.e. when if_open()
1015 set_bit(0,&chan->config_dlci);
1017 printk(KERN_INFO "\n");
1022 /*============================================================================
1023 * Delete logical channel.
1025 static int del_if(struct wan_device* wandev, struct net_device* dev)
1027 fr_channel_t* chan = dev->priv;
1028 unsigned long smp_flags=0;
1030 /* This interface is dead, make sure the
1031 * ARP timer is stopped */
1032 del_timer(&chan->fr_arp_timer);
1034 /* If we are a NODE, we must unconfigure this DLCI
1035 * Trigger an unconfigure command that will
1036 * be executed in timer interrupt. We must wait
1037 * for the command to complete. */
1038 trigger_unconfig_fr(dev);
1040 lock_adapter_irq(&wandev->lock, &smp_flags);
1041 wandev->new_if_cnt--;
1042 unlock_adapter_irq(&wandev->lock, &smp_flags);
1048 /*=====================================================================
1052 * Disable communications.
1053 * This code runs in shutdown (sdlamain.c)
1054 * under critical flag. Therefore it is not
1055 * necessary to set a critical flag here
1058 * Commnunications are disabled only on a card
1062 static void disable_comm (sdla_t *card)
1064 printk(KERN_INFO "%s: Disabling Communications!\n",
1066 fr_comm_disable(card);
1069 /****** WANPIPE-specific entry points ***************************************/
1071 /*============================================================================
1072 * Execute adapter interface command.
1074 static int wpf_exec (struct sdla* card, void* u_cmd, void* u_data)
1076 fr_mbox_t* mbox = card->mbox;
1077 int retry = MAX_CMD_RETRY;
1081 if(copy_from_user((void*)&cmd, u_cmd, sizeof(cmd)))
1084 /* execute command */
1087 memcpy(&mbox->cmd, &cmd, sizeof(cmd));
1090 if( copy_from_user((void*)&mbox->data, u_data, cmd.length))
1094 if (sdla_exec(mbox))
1095 err = mbox->cmd.result;
1099 } while (err && retry-- && fr_event(card, err, mbox));
1102 if (copy_to_user(u_cmd, (void*)&mbox->cmd, sizeof(fr_cmd_t)))
1105 len = mbox->cmd.length;
1107 if (len && u_data && !copy_to_user(u_data, (void*)&mbox->data, len))
1112 /****** Network Device Interface ********************************************/
1114 /*============================================================================
1115 * Initialize Linux network interface.
1117 * This routine is called only once for each interface, during Linux network
1118 * interface registration. Returning anything but zero will fail interface
1121 static int if_init(struct net_device* dev)
1123 fr_channel_t* chan = dev->priv;
1124 sdla_t* card = chan->card;
1125 struct wan_device* wandev = &card->wandev;
1127 /* Initialize device driver entry points */
1128 dev->open = &if_open;
1129 dev->stop = &if_close;
1130 dev->hard_header = NULL;
1131 dev->rebuild_header = &if_rebuild_hdr;
1132 dev->hard_start_xmit = &if_send;
1133 dev->get_stats = &if_stats;
1134 dev->tx_timeout = &if_tx_timeout;
1135 dev->watchdog_timeo = TX_TIMEOUT;
1137 if (chan->common.usedby == WANPIPE || chan->common.usedby == API){
1139 /* Initialize media-specific parameters */
1140 if (chan->true_if_encoding){
1141 dev->type = ARPHRD_DLCI; /* This breaks tcpdump */
1143 dev->type = ARPHRD_PPP; /* ARP h/w type */
1146 dev->flags |= IFF_POINTOPOINT;
1147 dev->flags |= IFF_NOARP;
1149 /* Enable Multicast addressing */
1150 if (chan->mc == WANOPT_YES){
1151 dev->flags |= IFF_MULTICAST;
1154 dev->mtu = wandev->mtu - FR_HEADER_LEN;
1155 /* For an API, the maximum number of bytes that the stack will pass
1156 to the driver is (dev->mtu + dev->hard_header_len). So, adjust the
1157 mtu so that a frame of maximum size can be transmitted by the API.
1159 if(chan->common.usedby == API) {
1160 dev->mtu += (sizeof(api_tx_hdr_t) - FR_HEADER_LEN);
1163 dev->hard_header_len = FR_HEADER_LEN;/* media header length */
1164 dev->addr_len = 2; /* hardware address length */
1165 *(unsigned short*)dev->dev_addr = htons(chan->dlci);
1167 /* Set transmit buffer queue length */
1168 dev->tx_queue_len = 100;
1172 /* Setup the interface for Bridging */
1176 /* Use a random number to generate the MAC address */
1177 memcpy(dev->dev_addr, "\xFE\xFC\x00\x00\x00\x00", 6);
1178 get_random_bytes(&hw_addr, sizeof(hw_addr));
1179 *(int *)(dev->dev_addr + 2) += hw_addr;
1182 /* Initialize hardware parameters (just for reference) */
1183 dev->irq = wandev->irq;
1184 dev->dma = wandev->dma;
1185 dev->base_addr = wandev->ioport;
1186 dev->mem_start = wandev->maddr;
1187 dev->mem_end = wandev->maddr + wandev->msize - 1;
1188 SET_MODULE_OWNER(dev);
1193 /*============================================================================
1194 * Open network interface.
1195 * o if this is the first open, then enable communications and interrupts.
1196 * o prevent module from unloading by incrementing use count
1198 * Return 0 if O.k. or errno.
1200 static int if_open(struct net_device* dev)
1202 fr_channel_t* chan = dev->priv;
1203 sdla_t* card = chan->card;
1207 if (netif_running(dev))
1210 /* Initialize the task queue */
1213 INIT_WORK(&chan->common.wanpipe_work, (void *)fr_bh, dev);
1215 /* Allocate and initialize BH circular buffer */
1216 chan->bh_head = kmalloc((sizeof(bh_data_t)*MAX_BH_BUFF),GFP_ATOMIC);
1217 memset(chan->bh_head,0,(sizeof(bh_data_t)*MAX_BH_BUFF));
1218 atomic_set(&chan->bh_buff_used, 0);
1220 netif_start_queue(dev);
1223 do_gettimeofday( &tv );
1224 chan->router_start_time = tv.tv_sec;
1226 if (test_bit(0,&chan->config_dlci)){
1227 trigger_config_fr (card);
1228 }else if (chan->inarp == INARP_REQUEST){
1229 trigger_fr_arp(dev);
1235 /*============================================================================
1236 * Close network interface.
1237 * o if this is the last open, then disable communications and interrupts.
1240 static int if_close(struct net_device* dev)
1242 fr_channel_t* chan = dev->priv;
1243 sdla_t* card = chan->card;
1245 if (chan->inarp == INARP_CONFIGURED) {
1246 chan->inarp = INARP_REQUEST;
1249 netif_stop_queue(dev);
1250 wanpipe_close(card);
1255 /*============================================================================
1256 * Re-build media header.
1258 * Return: 1 physical address resolved.
1259 * 0 physical address not resolved
1261 static int if_rebuild_hdr (struct sk_buff* skb)
1263 struct net_device *dev = skb->dev;
1264 fr_channel_t* chan = dev->priv;
1265 sdla_t* card = chan->card;
1267 printk(KERN_INFO "%s: rebuild_header() called for interface %s!\n",
1268 card->devname, dev->name);
1272 /*============================================================================
1273 * Handle transmit timeout event from netif watchdog
1275 static void if_tx_timeout(struct net_device *dev)
1277 fr_channel_t* chan = dev->priv;
1278 sdla_t *card = chan->card;
1280 /* If our device stays busy for at least 5 seconds then we will
1281 * kick start the device by making dev->tbusy = 0. We expect
1282 * that our device never stays busy more than 5 seconds. So this
1283 * is only used as a last resort.
1286 chan->drvstats_if_send.if_send_tbusy++;
1287 ++chan->ifstats.collisions;
1289 printk (KERN_INFO "%s: Transmit timed out on %s\n",
1290 card->devname, dev->name);
1291 chan->drvstats_if_send.if_send_tbusy_timeout++;
1292 netif_wake_queue (dev);
1297 /*============================================================================
1298 * Send a packet on a network interface.
1299 * o set tbusy flag (marks start of the transmission) to block a timer-based
1300 * transmit from overlapping.
1301 * o set critical flag when accessing board.
1302 * o check link state. If link is not up, then drop the packet.
1303 * o check channel status. If it's down then initiate a call.
1304 * o pass a packet to corresponding WAN device.
1305 * o free socket buffer
1307 * Return: 0 complete (socket buffer must be freed)
1308 * non-0 packet may be re-transmitted (tbusy must be set)
1311 * 1. This routine is called either by the protocol stack or by the "net
1312 * bottom half" (with interrupts enabled).
1314 * 2. Using netif_start_queue() and netif_stop_queue()
1315 * will inhibit further transmit requests from the protocol stack
1316 * and can be used for flow control with protocol layer.
1318 static int if_send(struct sk_buff* skb, struct net_device* dev)
1320 fr_channel_t* chan = dev->priv;
1321 sdla_t* card = chan->card;
1323 unsigned char *sendpacket;
1324 fr508_flags_t* adptr_flags = card->flags;
1326 long delay_tx_queued = 0;
1327 unsigned long smp_flags=0;
1328 unsigned char attr = 0;
1330 chan->drvstats_if_send.if_send_entry++;
1332 netif_stop_queue(dev);
1335 /* if we get here, some higher layer thinks we've missed an
1336 * tx-done interrupt.
1338 printk(KERN_INFO "%s: interface %s got kicked!\n",
1339 card->devname, dev->name);
1340 chan->drvstats_if_send.if_send_skb_null ++;
1342 netif_wake_queue(dev);
1346 /* If a peripheral task is running just drop packets */
1347 if (test_bit(PERI_CRIT, &card->wandev.critical)){
1349 printk(KERN_INFO "%s: Critical in if_send(): Peripheral running!\n",
1352 dev_kfree_skb_any(skb);
1353 netif_start_queue(dev);
1357 /* We must set the 'tbusy' flag if we already have a packet queued for
1358 transmission in the transmit interrupt handler. However, we must
1359 ensure that the transmit interrupt does not reset the 'tbusy' flag
1360 just before we set it, as this will result in a "transmit timeout".
1362 set_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical);
1363 if(chan->transmit_length) {
1364 netif_stop_queue(dev);
1365 chan->tick_counter = jiffies;
1366 clear_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical);
1369 clear_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical);
1371 /* Move the if_header() code to here. By inserting frame
1372 * relay header in if_header() we would break the
1373 * tcpdump and other packet sniffers */
1374 chan->fr_header_len = setup_fr_header(&skb,dev,chan->common.usedby);
1375 if (chan->fr_header_len < 0 ){
1376 ++chan->ifstats.tx_dropped;
1377 ++card->wandev.stats.tx_dropped;
1379 dev_kfree_skb_any(skb);
1380 netif_start_queue(dev);
1384 sendpacket = skb->data;
1386 udp_type = udp_pkt_type(skb, card);
1388 if(udp_type != UDP_INVALID_TYPE) {
1389 if(store_udp_mgmt_pkt(udp_type, UDP_PKT_FRM_STACK, card, skb,
1391 adptr_flags->imask |= FR_INTR_TIMER;
1392 if (udp_type == UDP_FPIPE_TYPE){
1393 chan->drvstats_if_send.
1394 if_send_PIPE_request ++;
1397 netif_start_queue(dev);
1401 //FIXME: can we do better than sendpacket[2]?
1402 if ((chan->common.usedby == WANPIPE) && (sendpacket[2] == 0x45)) {
1404 /* check to see if the source IP address is a broadcast or */
1405 /* multicast IP address */
1406 if(chk_bcast_mcast_addr(card, dev, skb)){
1407 ++chan->ifstats.tx_dropped;
1408 ++card->wandev.stats.tx_dropped;
1409 dev_kfree_skb_any(skb);
1410 netif_start_queue(dev);
1416 /* Lock the S514/S508 card: SMP Supported */
1417 s508_s514_lock(card,&smp_flags);
1419 if (test_and_set_bit(SEND_CRIT, (void*)&card->wandev.critical)) {
1421 chan->drvstats_if_send.if_send_critical_non_ISR ++;
1422 chan->ifstats.tx_dropped ++;
1423 printk(KERN_INFO "%s Critical in IF_SEND: if_send() already running!\n",
1425 goto if_send_start_and_exit;
1428 /* API packet check: minimum packet size must be greater than
1429 * 16 byte API header */
1430 if((chan->common.usedby == API) && (skb->len <= sizeof(api_tx_hdr_t))) {
1431 ++chan->ifstats.tx_dropped;
1432 ++card->wandev.stats.tx_dropped;
1435 goto if_send_start_and_exit;
1438 /* During API transmission, get rid of the API header */
1439 if (chan->common.usedby == API) {
1440 api_tx_hdr_t* api_tx_hdr;
1441 api_tx_hdr = (api_tx_hdr_t*)&skb->data[0x00];
1442 attr = api_tx_hdr->attr;
1443 skb_pull(skb,sizeof(api_tx_hdr_t));
1447 if (card->wandev.state != WAN_CONNECTED) {
1448 chan->drvstats_if_send.if_send_wan_disconnected ++;
1449 ++chan->ifstats.tx_dropped;
1450 ++card->wandev.stats.tx_dropped;
1452 } else if (chan->common.state != WAN_CONNECTED) {
1453 chan->drvstats_if_send.if_send_dlci_disconnected ++;
1455 /* Update the DLCI state in timer interrupt */
1456 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UPDATE_STATE;
1457 adptr_flags->imask |= FR_INTR_TIMER;
1459 ++chan->ifstats.tx_dropped;
1460 ++card->wandev.stats.tx_dropped;
1462 } else if (!is_tx_ready(card, chan)) {
1463 /* No tx buffers available, store for delayed transmit */
1464 if (!setup_for_delayed_transmit(dev, skb)){
1465 set_bit(1,&delay_tx_queued);
1467 chan->drvstats_if_send.if_send_no_bfrs++;
1469 } else if (!skb->protocol) {
1470 /* No protocols drop packet */
1471 chan->drvstats_if_send.if_send_protocol_error ++;
1472 ++card->wandev.stats.tx_errors;
1474 } else if (test_bit(ARP_CRIT,&card->wandev.critical)){
1475 /* We are trying to send an ARP Packet, block IP data until
1477 ++chan->ifstats.tx_dropped;
1478 ++card->wandev.stats.tx_dropped;
1481 //FIXME: IPX is not implemented in this version of Frame Relay ?
1482 if((chan->common.usedby == WANPIPE) &&
1483 sendpacket[1] == 0x00 &&
1484 sendpacket[2] == 0x80 &&
1485 sendpacket[6] == 0x81 &&
1486 sendpacket[7] == 0x37) {
1488 if( chan->enable_IPX ) {
1489 switch_net_numbers(sendpacket,
1490 chan->network_number, 0);
1492 //FIXME: Take this out when IPX is fixed
1494 "%s: WARNING: Unsupported IPX data in send, packet dropped\n",
1499 err = fr_send_data_header(card, chan->dlci, attr, skb->len, skb->data, chan->fr_header_len);
1502 case FRRES_CIR_OVERFLOW:
1503 case FRRES_BUFFER_OVERFLOW:
1504 if (!setup_for_delayed_transmit(dev, skb)){
1505 set_bit(1,&delay_tx_queued);
1507 chan->drvstats_if_send.
1508 if_send_adptr_bfrs_full ++;
1511 case FRRES_TOO_LONG:
1512 if (net_ratelimit()){
1514 "%s: Error: Frame too long, transmission failed %i\n",
1515 card->devname, (unsigned int)skb->len);
1517 /* Drop down to default */
1519 chan->drvstats_if_send.
1520 if_send_dlci_disconnected ++;
1521 ++chan->ifstats.tx_dropped;
1522 ++card->wandev.stats.tx_dropped;
1526 chan->drvstats_if_send.
1527 if_send_bfr_passed_to_adptr++;
1528 ++chan->ifstats.tx_packets;
1529 ++card->wandev.stats.tx_packets;
1531 chan->ifstats.tx_bytes += skb->len;
1532 card->wandev.stats.tx_bytes += skb->len;
1533 dev->trans_start = jiffies;
1538 if_send_start_and_exit:
1540 netif_start_queue(dev);
1542 /* If we queued the packet for transmission, we must not
1543 * deallocate it. The packet is unlinked from the IP stack
1544 * not copied. Therefore, we must keep the original packet */
1545 if (!test_bit(1,&delay_tx_queued)) {
1546 dev_kfree_skb_any(skb);
1548 adptr_flags->imask |= FR_INTR_TXRDY;
1549 card->u.f.tx_interrupts_pending ++;
1552 clear_bit(SEND_CRIT, (void*)&card->wandev.critical);
1554 s508_s514_unlock(card,&smp_flags);
1561 /*============================================================================
1562 * Setup so that a frame can be transmitted on the occurrence of a transmit
1565 static int setup_for_delayed_transmit(struct net_device* dev,
1566 struct sk_buff *skb)
1568 fr_channel_t* chan = dev->priv;
1569 sdla_t* card = chan->card;
1570 fr_dlci_interface_t* dlci_interface;
1573 /* Check that the dlci is properly configured,
1574 * before using tx interrupt */
1575 if (!chan->dlci_int_interface){
1576 if (net_ratelimit()){
1578 "%s: ERROR on DLCI %i: Not configured properly !\n",
1579 card->devname, chan->dlci);
1580 printk(KERN_INFO "%s: Please contact Sangoma Technologies\n",
1586 dlci_interface = chan->dlci_int_interface;
1588 if(chan->transmit_length) {
1589 printk(KERN_INFO "%s: Big mess in setup_for_del...\n",
1594 if(len > FR_MAX_NO_DATA_BYTES_IN_FRAME) {
1595 //FIXME: increment some statistic */
1601 chan->transmit_length = len;
1602 chan->delay_skb = skb;
1604 dlci_interface->gen_interrupt |= FR_INTR_TXRDY;
1605 dlci_interface->packet_length = len;
1607 /* Turn on TX interrupt at the end of if_send */
1612 /*============================================================================
1613 * Check to see if the packet to be transmitted contains a broadcast or
1614 * multicast source IP address.
1615 * Return 0 if not broadcast/multicast address, otherwise return 1.
1618 static int chk_bcast_mcast_addr(sdla_t *card, struct net_device* dev,
1619 struct sk_buff *skb)
1622 u32 broadcast_ip_addr = 0;
1623 struct in_device *in_dev;
1624 fr_channel_t* chan = dev->priv;
1626 /* read the IP source address from the outgoing packet */
1627 src_ip_addr = *(u32 *)(skb->data + 14);
1629 /* read the IP broadcast address for the device */
1630 in_dev = dev->ip_ptr;
1631 if(in_dev != NULL) {
1632 struct in_ifaddr *ifa= in_dev->ifa_list;
1634 broadcast_ip_addr = ifa->ifa_broadcast;
1639 /* check if the IP Source Address is a Broadcast address */
1640 if((dev->flags & IFF_BROADCAST) && (src_ip_addr == broadcast_ip_addr)) {
1642 "%s: Broadcast Source Address silently discarded\n",
1647 /* check if the IP Source Address is a Multicast address */
1648 if((chan->mc == WANOPT_NO) && (ntohl(src_ip_addr) >= 0xE0000001) &&
1649 (ntohl(src_ip_addr) <= 0xFFFFFFFE)) {
1651 "%s: Multicast Source Address silently discarded\n",
1659 /*============================================================================
1660 * Reply to UDP Management system.
1663 static int reply_udp( unsigned char *data, unsigned int mbox_len )
1665 unsigned short len, udp_length, temp, ip_length;
1666 unsigned long ip_temp;
1670 fr_udp_pkt_t *fr_udp_pkt = (fr_udp_pkt_t *)data;
1672 /* Set length of packet */
1673 len = //sizeof(fr_encap_hdr_t)+
1681 /* fill in UDP reply */
1682 fr_udp_pkt->wp_mgmt.request_reply = UDPMGMT_REPLY;
1684 /* fill in UDP length */
1685 udp_length = sizeof(udp_pkt_t)+
1691 /* put it on an even boundary */
1692 if ( udp_length & 0x0001 ) {
1698 temp = (udp_length<<8)|(udp_length>>8);
1699 fr_udp_pkt->udp_pkt.udp_length = temp;
1701 /* swap UDP ports */
1702 temp = fr_udp_pkt->udp_pkt.udp_src_port;
1703 fr_udp_pkt->udp_pkt.udp_src_port =
1704 fr_udp_pkt->udp_pkt.udp_dst_port;
1705 fr_udp_pkt->udp_pkt.udp_dst_port = temp;
1709 /* add UDP pseudo header */
1711 *((unsigned short *)
1712 (fr_udp_pkt->data+mbox_len+even_bound)) = temp;
1713 temp = (udp_length<<8)|(udp_length>>8);
1714 *((unsigned short *)
1715 (fr_udp_pkt->data+mbox_len+even_bound+2)) = temp;
1717 /* calculate UDP checksum */
1718 fr_udp_pkt->udp_pkt.udp_checksum = 0;
1720 fr_udp_pkt->udp_pkt.udp_checksum =
1721 calc_checksum(&data[UDP_OFFSET/*+sizeof(fr_encap_hdr_t)*/],
1722 udp_length+UDP_OFFSET);
1724 /* fill in IP length */
1725 ip_length = udp_length + sizeof(ip_pkt_t);
1726 temp = (ip_length<<8)|(ip_length>>8);
1727 fr_udp_pkt->ip_pkt.total_length = temp;
1729 /* swap IP addresses */
1730 ip_temp = fr_udp_pkt->ip_pkt.ip_src_address;
1731 fr_udp_pkt->ip_pkt.ip_src_address =
1732 fr_udp_pkt->ip_pkt.ip_dst_address;
1733 fr_udp_pkt->ip_pkt.ip_dst_address = ip_temp;
1736 /* fill in IP checksum */
1737 fr_udp_pkt->ip_pkt.hdr_checksum = 0;
1738 fr_udp_pkt->ip_pkt.hdr_checksum =
1739 calc_checksum(&data[/*sizeof(fr_encap_hdr_t)*/0],
1745 unsigned short calc_checksum (char *data, int len)
1747 unsigned short temp;
1748 unsigned long sum=0;
1751 for( i = 0; i <len; i+=2 ) {
1752 memcpy(&temp,&data[i],2);
1753 sum += (unsigned long)temp;
1756 while (sum >> 16 ) {
1757 sum = (sum & 0xffffUL) + (sum >> 16);
1760 temp = (unsigned short)sum;
1770 If incoming is 0 (outgoing)- if the net numbers is ours make it 0
1771 if incoming is 1 - if the net number is 0 make it ours
1774 static void switch_net_numbers(unsigned char *sendpacket, unsigned long network_number, unsigned char incoming)
1776 unsigned long pnetwork_number;
1778 pnetwork_number = (unsigned long)((sendpacket[14] << 24) +
1779 (sendpacket[15] << 16) + (sendpacket[16] << 8) +
1783 /* If the destination network number is ours, make it 0 */
1784 if( pnetwork_number == network_number) {
1785 sendpacket[14] = sendpacket[15] = sendpacket[16] =
1786 sendpacket[17] = 0x00;
1789 /* If the incoming network is 0, make it ours */
1790 if( pnetwork_number == 0) {
1791 sendpacket[14] = (unsigned char)(network_number >> 24);
1792 sendpacket[15] = (unsigned char)((network_number &
1794 sendpacket[16] = (unsigned char)((network_number &
1796 sendpacket[17] = (unsigned char)(network_number &
1802 pnetwork_number = (unsigned long)((sendpacket[26] << 24) +
1803 (sendpacket[27] << 16) + (sendpacket[28] << 8) +
1807 /* If the source network is ours, make it 0 */
1808 if( pnetwork_number == network_number) {
1809 sendpacket[26] = sendpacket[27] = sendpacket[28] =
1810 sendpacket[29] = 0x00;
1813 /* If the source network is 0, make it ours */
1814 if( pnetwork_number == 0 ) {
1815 sendpacket[26] = (unsigned char)(network_number >> 24);
1816 sendpacket[27] = (unsigned char)((network_number &
1818 sendpacket[28] = (unsigned char)((network_number &
1820 sendpacket[29] = (unsigned char)(network_number &
1824 } /* switch_net_numbers */
1826 /*============================================================================
1827 * Get ethernet-style interface statistics.
1828 * Return a pointer to struct enet_statistics.
1830 static struct net_device_stats *if_stats(struct net_device *dev)
1832 fr_channel_t* chan = dev->priv;
1837 return &chan->ifstats;
1840 /****** Interrupt Handlers **************************************************/
1842 /*============================================================================
1843 * fr_isr: S508 frame relay interrupt service routine.
1846 * Frame relay main interrupt service route. This
1847 * function check the interrupt type and takes
1848 * the appropriate action.
1850 static void fr_isr (sdla_t* card)
1852 fr508_flags_t* flags = card->flags;
1853 char *ptr = &flags->iflag;
1855 fr_mbox_t* mbox = card->mbox;
1857 /* This flag prevents nesting of interrupts. See sdla_isr() routine
1861 ++card->statistics.isr_entry;
1864 /* All peripheral (configuraiton, re-configuration) events
1865 * take presidence over the ISR. Thus, retrigger */
1866 if (test_bit(PERI_CRIT, (void*)&card->wandev.critical)) {
1867 ++card->statistics.isr_already_critical;
1871 if(card->hw.type != SDLA_S514) {
1872 if (test_bit(SEND_CRIT, (void*)&card->wandev.critical)) {
1873 printk(KERN_INFO "%s: Critical while in ISR: If Send Running!\n",
1875 ++card->statistics.isr_already_critical;
1880 switch (flags->iflag) {
1882 case FR_INTR_RXRDY: /* receive interrupt */
1883 ++card->statistics.isr_rx;
1888 case FR_INTR_TXRDY: /* transmit interrupt */
1889 ++ card->statistics.isr_tx;
1894 Intr_test_counter++;
1895 ++card->statistics.isr_intr_test;
1898 case FR_INTR_DLC: /* Event interrupt occurred */
1899 mbox->cmd.command = FR_READ_STATUS;
1900 mbox->cmd.length = 0;
1901 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
1903 fr_event(card, err, mbox);
1906 case FR_INTR_TIMER: /* Timer interrupt */
1911 ++card->statistics.isr_spurious;
1913 printk(KERN_INFO "%s: Interrupt Type 0x%02X!\n",
1914 card->devname, flags->iflag);
1916 printk(KERN_INFO "%s: ID Bytes = ",card->devname);
1917 for(i = 0; i < 8; i ++)
1918 printk(KERN_INFO "0x%02X ", *(ptr + 0x28 + i));
1919 printk(KERN_INFO "\n");
1933 /*===========================================================
1934 * rx_intr Receive interrupt handler.
1937 * Upon receiveing an interrupt:
1938 * 1. Check that the firmware is in sync with
1940 * 2. Find an appropriate network interface
1941 * based on the received dlci number.
1942 * 3. Check that the netowrk interface exists
1943 * and that it's setup properly.
1944 * 4. Copy the data into an skb buffer.
1945 * 5. Check the packet type and take
1946 * appropriate acton: UPD, API, ARP or Data.
1949 static void rx_intr (sdla_t* card)
1951 fr_rx_buf_ctl_t* frbuf = card->rxmb;
1952 fr508_flags_t* flags = card->flags;
1954 char *ptr = &flags->iflag;
1955 struct sk_buff* skb;
1956 struct net_device* dev;
1958 unsigned dlci, len, offs, len_incl_hdr;
1962 /* Check that firmware buffers are in sync */
1963 if (frbuf->flag != 0x01) {
1966 "%s: corrupted Rx buffer @ 0x%X, flag = 0x%02X!\n",
1967 card->devname, (unsigned)frbuf, frbuf->flag);
1969 printk(KERN_INFO "%s: ID Bytes = ",card->devname);
1970 for(i = 0; i < 8; i ++)
1971 printk(KERN_INFO "0x%02X ", *(ptr + 0x28 + i));
1972 printk(KERN_INFO "\n");
1974 ++card->statistics.rx_intr_corrupt_rx_bfr;
1976 /* Bug Fix: Mar 6 2000
1977 * If we get a corrupted mailbox, it means that driver
1978 * is out of sync with the firmware. There is no recovery.
1979 * If we don't turn off all interrupts for this card
1980 * the machine will crash.
1982 printk(KERN_INFO "%s: Critical router failure ...!!!\n", card->devname);
1983 printk(KERN_INFO "Please contact Sangoma Technologies !\n");
1984 fr_set_intr_mode(card, 0, 0, 0);
1988 len = frbuf->length;
1990 offs = frbuf->offset;
1992 /* Find the network interface for this packet */
1993 dev = find_channel(card, dlci);
1996 /* Check that the network interface is active and
1999 if( net_ratelimit()) {
2000 printk(KERN_INFO "%s: received data on unconfigured DLCI %d!\n",
2001 card->devname, dlci);
2003 ++card->statistics.rx_intr_on_orphaned_DLCI;
2004 ++card->wandev.stats.rx_dropped;
2008 if ((chan = dev->priv) == NULL){
2009 if( net_ratelimit()) {
2010 printk(KERN_INFO "%s: received data on unconfigured DLCI %d!\n",
2011 card->devname, dlci);
2013 ++card->statistics.rx_intr_on_orphaned_DLCI;
2014 ++card->wandev.stats.rx_dropped;
2018 skb = dev_alloc_skb(len);
2020 if (!netif_running(dev) || (skb == NULL)){
2022 ++chan->ifstats.rx_dropped;
2025 if (net_ratelimit()) {
2027 "%s: no socket buffers available!\n",
2030 chan->drvstats_rx_intr.rx_intr_no_socket ++;
2033 if (!netif_running(dev)){
2034 chan->drvstats_rx_intr.
2035 rx_intr_dev_not_started ++;
2037 dev_kfree_skb_any(skb);
2043 /* Copy data from the board into the socket buffer */
2044 if ((offs + len) > card->u.f.rx_top + 1) {
2045 unsigned tmp = card->u.f.rx_top - offs + 1;
2047 buf = skb_put(skb, tmp);
2048 sdla_peek(&card->hw, offs, buf, tmp);
2049 offs = card->u.f.rx_base;
2053 buf = skb_put(skb, len);
2054 sdla_peek(&card->hw, offs, buf, len);
2057 /* We got the packet from the bard.
2058 * Check the packet type and take appropriate action */
2060 udp_type = udp_pkt_type( skb, card );
2062 if(udp_type != UDP_INVALID_TYPE) {
2064 /* UDP Debug packet received, store the
2065 * packet and handle it in timer interrupt */
2068 if (wanrouter_type_trans(skb, dev)){
2069 if(store_udp_mgmt_pkt(udp_type,UDP_PKT_FRM_NETWORK,card,skb,dlci)){
2071 flags->imask |= FR_INTR_TIMER;
2073 if (udp_type == UDP_FPIPE_TYPE){
2074 ++chan->drvstats_rx_intr.rx_intr_PIPE_request;
2079 }else if (chan->common.usedby == API) {
2081 /* We are in API mode.
2082 * Add an API header to the RAW packet
2083 * and queue it into a circular buffer.
2084 * Then kick the fr_bh() bottom half handler */
2086 api_rx_hdr_t* api_rx_hdr;
2087 chan->drvstats_rx_intr.rx_intr_bfr_passed_to_stack ++;
2088 chan->ifstats.rx_packets ++;
2089 card->wandev.stats.rx_packets ++;
2091 chan->ifstats.rx_bytes += skb->len;
2092 card->wandev.stats.rx_bytes += skb->len;
2094 skb_push(skb, sizeof(api_rx_hdr_t));
2095 api_rx_hdr = (api_rx_hdr_t*)&skb->data[0x00];
2096 api_rx_hdr->attr = frbuf->attr;
2097 api_rx_hdr->time_stamp = frbuf->tmstamp;
2099 skb->protocol = htons(ETH_P_IP);
2100 skb->mac.raw = skb->data;
2102 skb->pkt_type = WAN_PACKET_DATA;
2104 bh_enqueue(dev, skb);
2106 trigger_fr_bh(chan);
2108 }else if (handle_IPXWAN(skb->data,chan->name,chan->enable_IPX, chan->network_number)){
2110 //FIXME: Frame Relay IPX is not supported, Yet !
2111 //if (chan->enable_IPX) {
2112 // fr_send(card, dlci, 0, skb->len,skb->data);
2114 dev_kfree_skb_any(skb);
2116 } else if (is_arp(skb->data)) {
2118 /* ARP support enabled Mar 16 2000
2119 * Process incoming ARP reply/request, setup
2120 * dynamic routes. */
2122 if (process_ARP((arphdr_1490_t *)skb->data, card, dev)) {
2123 if (net_ratelimit()){
2125 "%s: Error processing ARP Packet.\n",
2129 dev_kfree_skb_any(skb);
2131 } else if (skb->data[0] != 0x03) {
2133 if (net_ratelimit()) {
2134 printk(KERN_INFO "%s: Non IETF packet discarded.\n",
2137 dev_kfree_skb_any(skb);
2141 len_incl_hdr = skb->len;
2142 /* Decapsulate packet and pass it up the
2146 if (chan->common.usedby == BRIDGE || chan->common.usedby == BRIDGE_NODE){
2148 /* Make sure it's an Ethernet frame, otherwise drop it */
2149 if (!memcmp(skb->data, "\x03\x00\x80\x00\x80\xC2\x00\x07", 8)) {
2151 skb->protocol=eth_type_trans(skb,dev);
2153 ++chan->drvstats_rx_intr.rx_intr_bfr_not_passed_to_stack;
2154 ++chan->ifstats.rx_errors;
2155 ++card->wandev.stats.rx_errors;
2160 /* remove hardware header */
2161 buf = skb_pull(skb, 1);
2163 if (!wanrouter_type_trans(skb, dev)) {
2165 /* can't decapsulate packet */
2166 dev_kfree_skb_any(skb);
2168 ++chan->drvstats_rx_intr.rx_intr_bfr_not_passed_to_stack;
2169 ++chan->ifstats.rx_errors;
2170 ++card->wandev.stats.rx_errors;
2173 skb->mac.raw = skb->data;
2177 /* Send a packet up the IP stack */
2178 skb->dev->last_rx = jiffies;
2180 ++chan->drvstats_rx_intr.rx_intr_bfr_passed_to_stack;
2181 ++chan->ifstats.rx_packets;
2182 ++card->wandev.stats.rx_packets;
2184 chan->ifstats.rx_bytes += len_incl_hdr;
2185 card->wandev.stats.rx_bytes += len_incl_hdr;
2190 /* Release buffer element and calculate a pointer to the next one */
2192 card->rxmb = ++frbuf;
2193 if ((void*)frbuf > card->u.f.rxmb_last)
2194 card->rxmb = card->u.f.rxmb_base;
2198 /*==================================================================
2199 * tx_intr: Transmit interrupt handler.
2202 * If the board is busy transmitting, if_send() will
2203 * buffers a single packet and turn on
2204 * the tx interrupt. Tx interrupt will be called
2205 * by the board, once the firmware can send more
2206 * data. Thus, no polling is required.
2209 * Tx interrupt is called for each
2210 * configured dlci channel. Thus:
2211 * 1. Obtain the netowrk interface based on the
2213 * 2. Check that network interface is up and
2215 * 3. Check for a buffered packet.
2216 * 4. Transmit the packet.
2217 * 5. If we are in WANPIPE mode, mark the
2219 * 6. If we are in API mode, kick
2220 * the AF_WANPIPE socket for more data.
2223 static void tx_intr(sdla_t *card)
2225 fr508_flags_t* flags = card->flags;
2226 fr_tx_buf_ctl_t* bctl;
2227 struct net_device* dev;
2230 if(card->hw.type == SDLA_S514){
2231 bctl = (void*)(flags->tse_offs + card->hw.dpmbase);
2233 bctl = (void*)(flags->tse_offs - FR_MB_VECTOR +
2237 /* Find the structure and make it unbusy */
2238 dev = find_channel(card, flags->dlci);
2240 printk(KERN_INFO "NO DEV IN TX Interrupt\n");
2241 goto end_of_tx_intr;
2244 if ((chan = dev->priv) == NULL){
2245 printk(KERN_INFO "NO CHAN IN TX Interrupt\n");
2246 goto end_of_tx_intr;
2249 if(!chan->transmit_length || !chan->delay_skb) {
2250 printk(KERN_INFO "%s: tx int error - transmit length zero\n",
2252 goto end_of_tx_intr;
2255 /* If the 'if_send()' procedure is currently checking the 'tbusy'
2256 status, then we cannot transmit. Instead, we configure the microcode
2257 so as to re-issue this transmit interrupt at a later stage.
2259 if (test_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical)) {
2261 fr_dlci_interface_t* dlci_interface = chan->dlci_int_interface;
2263 dlci_interface->gen_interrupt |= FR_INTR_TXRDY;
2267 bctl->dlci = flags->dlci;
2268 bctl->length = chan->transmit_length+chan->fr_header_len;
2269 sdla_poke(&card->hw,
2270 fr_send_hdr(card,bctl->dlci,bctl->offset),
2271 chan->delay_skb->data,
2272 chan->delay_skb->len);
2275 ++chan->ifstats.tx_packets;
2276 ++card->wandev.stats.tx_packets;
2277 chan->ifstats.tx_bytes += chan->transmit_length;
2278 card->wandev.stats.tx_bytes += chan->transmit_length;
2280 /* We must free an sk buffer, which we used
2281 * for delayed transmission; Otherwise, the sock
2282 * will run out of memory */
2283 dev_kfree_skb_any(chan->delay_skb);
2285 chan->delay_skb = NULL;
2286 chan->transmit_length = 0;
2288 dev->trans_start = jiffies;
2290 if (netif_queue_stopped(dev)){
2291 /* If using API, than wakeup socket BH handler */
2292 if (chan->common.usedby == API){
2293 netif_start_queue(dev);
2296 netif_wake_queue(dev);
2303 /* if any other interfaces have transmit interrupts pending,
2304 * do not disable the global transmit interrupt */
2305 if(!(-- card->u.f.tx_interrupts_pending))
2306 flags->imask &= ~FR_INTR_TXRDY;
2312 /*============================================================================
2313 * timer_intr: Timer interrupt handler.
2316 * All commans must be executed within the timer
2317 * interrupt since no two commands should execute
2321 * The timer interrupt is used to:
2322 * 1. Processing udp calls from 'fpipemon'.
2323 * 2. Processing update calls from /proc file system
2324 * 3. Reading board-level statistics for
2325 * updating the proc file system.
2326 * 4. Sending inverse ARP request packets.
2327 * 5. Configure a dlci/channel.
2328 * 6. Unconfigure a dlci/channel. (Node only)
2331 static void timer_intr(sdla_t *card)
2333 fr508_flags_t* flags = card->flags;
2335 /* UDP Debuging: fpipemon call */
2336 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UDP) {
2337 if(card->u.f.udp_type == UDP_FPIPE_TYPE) {
2338 if(process_udp_mgmt_pkt(card)) {
2339 card->u.f.timer_int_enabled &=
2340 ~TMR_INT_ENABLED_UDP;
2345 /* /proc update call : triggered from update() */
2346 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UPDATE) {
2347 fr_get_err_stats(card);
2349 card->u.f.update_comms_stats = 0;
2350 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE;
2353 /* Update the channel state call. This is call is
2354 * triggered by if_send() function */
2355 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UPDATE_STATE){
2356 struct net_device *dev;
2357 if (card->wandev.state == WAN_CONNECTED){
2358 for (dev = card->wandev.dev; dev;
2359 dev = *((struct net_device **)dev->priv)){
2360 fr_channel_t *chan = dev->priv;
2361 if (chan->common.state != WAN_CONNECTED){
2362 update_chan_state(dev);
2366 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE_STATE;
2369 /* configure a dlci/channel */
2370 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_CONFIG){
2372 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_CONFIG;
2375 /* unconfigure a dlci/channel */
2376 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UNCONFIG){
2378 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UNCONFIG;
2382 /* Transmit ARP packets */
2383 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_ARP){
2385 struct net_device *dev;
2387 if (card->u.f.arp_dev == NULL)
2388 card->u.f.arp_dev = card->wandev.dev;
2390 dev = card->u.f.arp_dev;
2394 fr_channel_t *chan = dev->priv;
2396 /* If the interface is brought down cancel sending In-ARPs */
2397 if (!(dev->flags&IFF_UP)){
2398 clear_bit(0,&chan->inarp_ready);
2401 if (test_bit(0,&chan->inarp_ready)){
2403 if (check_tx_status(card,dev)){
2404 set_bit(ARP_CRIT,&card->wandev.critical);
2408 if (!send_inarp_request(card,dev)){
2409 trigger_fr_arp(dev);
2410 chan->inarp_tick = jiffies;
2413 clear_bit(0,&chan->inarp_ready);
2414 dev = move_dev_to_next(card,dev);
2417 dev = move_dev_to_next(card,dev);
2419 if (++i == card->wandev.new_if_cnt){
2420 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_ARP;
2424 card->u.f.arp_dev = dev;
2427 if(!card->u.f.timer_int_enabled)
2428 flags->imask &= ~FR_INTR_TIMER;
2432 /*============================================================================
2433 * spur_intr: Spurious interrupt handler.
2436 * We don't know this interrupt.
2440 static void spur_intr (sdla_t* card)
2442 if (net_ratelimit()){
2443 printk(KERN_INFO "%s: spurious interrupt!\n", card->devname);
2448 //FIXME: Fix the IPX in next version
2449 /*===========================================================================
2450 * Return 0 for non-IPXWAN packet
2451 * 1 for IPXWAN packet or IPX is not enabled!
2452 * FIXME: Use a IPX structure here not offsets
2454 static int handle_IPXWAN(unsigned char *sendpacket,
2455 char *devname, unsigned char enable_IPX,
2456 unsigned long network_number)
2460 if( sendpacket[1] == 0x00 && sendpacket[2] == 0x80 &&
2461 sendpacket[6] == 0x81 && sendpacket[7] == 0x37) {
2463 /* It's an IPX packet */
2465 /* Return 1 so we don't pass it up the stack. */
2466 //FIXME: Take this out when IPX is fixed
2467 if (net_ratelimit()){
2469 "%s: WARNING: Unsupported IPX packet received and dropped\n",
2475 /* It's not IPX so return and pass it up the stack. */
2479 if( sendpacket[24] == 0x90 && sendpacket[25] == 0x04){
2482 if( sendpacket[10] == 0x02 && sendpacket[42] == 0x00){
2484 /* It's a timer request packet */
2485 printk(KERN_INFO "%s: Received IPXWAN Timer Request packet\n",
2488 /* Go through the routing options and answer no to every
2489 * option except Unnumbered RIP/SAP
2491 for(i = 49; sendpacket[i] == 0x00; i += 5){
2492 /* 0x02 is the option for Unnumbered RIP/SAP */
2493 if( sendpacket[i + 4] != 0x02){
2494 sendpacket[i + 1] = 0;
2498 /* Skip over the extended Node ID option */
2499 if( sendpacket[i] == 0x04 ){
2503 /* We also want to turn off all header compression opt.
2505 for(; sendpacket[i] == 0x80 ;){
2506 sendpacket[i + 1] = 0;
2507 i += (sendpacket[i + 2] << 8) + (sendpacket[i + 3]) + 4;
2510 /* Set the packet type to timer response */
2511 sendpacket[42] = 0x01;
2513 printk(KERN_INFO "%s: Sending IPXWAN Timer Response\n",
2516 } else if( sendpacket[42] == 0x02 ){
2518 /* This is an information request packet */
2520 "%s: Received IPXWAN Information Request packet\n",
2523 /* Set the packet type to information response */
2524 sendpacket[42] = 0x03;
2526 /* Set the router name */
2527 sendpacket[59] = 'F';
2528 sendpacket[60] = 'P';
2529 sendpacket[61] = 'I';
2530 sendpacket[62] = 'P';
2531 sendpacket[63] = 'E';
2532 sendpacket[64] = '-';
2533 sendpacket[65] = CVHexToAscii(network_number >> 28);
2534 sendpacket[66] = CVHexToAscii((network_number & 0x0F000000)>> 24);
2535 sendpacket[67] = CVHexToAscii((network_number & 0x00F00000)>> 20);
2536 sendpacket[68] = CVHexToAscii((network_number & 0x000F0000)>> 16);
2537 sendpacket[69] = CVHexToAscii((network_number & 0x0000F000)>> 12);
2538 sendpacket[70] = CVHexToAscii((network_number & 0x00000F00)>> 8);
2539 sendpacket[71] = CVHexToAscii((network_number & 0x000000F0)>> 4);
2540 sendpacket[72] = CVHexToAscii(network_number & 0x0000000F);
2541 for(i = 73; i < 107; i+= 1)
2546 printk(KERN_INFO "%s: Sending IPXWAN Information Response packet\n",
2550 printk(KERN_INFO "%s: Unknown IPXWAN packet!\n",devname);
2554 /* Set the WNodeID to our network address */
2555 sendpacket[43] = (unsigned char)(network_number >> 24);
2556 sendpacket[44] = (unsigned char)((network_number & 0x00FF0000) >> 16);
2557 sendpacket[45] = (unsigned char)((network_number & 0x0000FF00) >> 8);
2558 sendpacket[46] = (unsigned char)(network_number & 0x000000FF);
2563 /* If we get here, it's an IPX-data packet so it'll get passed up the
2565 * switch the network numbers
2567 switch_net_numbers(sendpacket, network_number ,1);
2570 /*============================================================================
2574 * If the interface goes down, or we receive an ARP request,
2575 * we have to change the network interface ip addresses.
2576 * This cannot be done within the interrupt.
2580 * This routine is called as a polling routine to dynamically
2581 * add/delete routes negotiated by inverse ARP. It is in this
2582 * "task" because we don't want routes to be added while in
2583 * interrupt context.
2586 * This function is called by fr_poll() polling funtion.
2589 static void process_route(struct net_device *dev)
2591 fr_channel_t *chan = dev->priv;
2592 sdla_t *card = chan->card;
2594 struct ifreq if_info;
2595 struct sockaddr_in *if_data;
2596 mm_segment_t fs = get_fs();
2601 switch(chan->route_flag){
2605 /* Set remote addresses */
2606 memset(&if_info, 0, sizeof(if_info));
2607 strcpy(if_info.ifr_name, dev->name);
2609 set_fs(get_ds()); /* get user space block */
2611 if_data = (struct sockaddr_in *)&if_info.ifr_dstaddr;
2612 if_data->sin_addr.s_addr = chan->ip_remote;
2613 if_data->sin_family = AF_INET;
2614 err = devinet_ioctl( SIOCSIFDSTADDR, &if_info );
2616 set_fs(fs); /* restore old block */
2620 "%s: Route Add failed. Error: %d\n",
2622 printk(KERN_INFO "%s: Address: %u.%u.%u.%u\n",
2623 chan->name, NIPQUAD(chan->ip_remote));
2626 printk(KERN_INFO "%s: Route Added Successfully: %u.%u.%u.%u\n",
2627 card->devname,NIPQUAD(chan->ip_remote));
2628 chan->route_flag = ROUTE_ADDED;
2634 /* Set remote addresses */
2635 memset(&if_info, 0, sizeof(if_info));
2636 strcpy(if_info.ifr_name, dev->name);
2638 ip_tmp = get_ip_address(dev,WAN_POINTOPOINT_IP);
2640 set_fs(get_ds()); /* get user space block */
2642 if_data = (struct sockaddr_in *)&if_info.ifr_dstaddr;
2643 if_data->sin_addr.s_addr = 0;
2644 if_data->sin_family = AF_INET;
2645 err = devinet_ioctl( SIOCSIFDSTADDR, &if_info );
2651 "%s: Deleting of route failed. Error: %d\n",
2653 printk(KERN_INFO "%s: Address: %u.%u.%u.%u\n",
2654 dev->name,NIPQUAD(chan->ip_remote) );
2657 printk(KERN_INFO "%s: Route Removed Sucessfuly: %u.%u.%u.%u\n",
2658 card->devname,NIPQUAD(ip_tmp));
2659 chan->route_flag = NO_ROUTE;
2663 } /* Case Statement */
2669 /****** Frame Relay Firmware-Specific Functions *****************************/
2671 /*============================================================================
2672 * Read firmware code version.
2673 * o fill string str with firmware version info.
2675 static int fr_read_version (sdla_t* card, char* str)
2677 fr_mbox_t* mbox = card->mbox;
2678 int retry = MAX_CMD_RETRY;
2683 mbox->cmd.command = FR_READ_CODE_VERSION;
2684 mbox->cmd.length = 0;
2685 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2686 } while (err && retry-- && fr_event(card, err, mbox));
2689 int len = mbox->cmd.length;
2690 memcpy(str, mbox->data, len);
2696 /*============================================================================
2697 * Set global configuration.
2699 static int fr_configure (sdla_t* card, fr_conf_t *conf)
2701 fr_mbox_t* mbox = card->mbox;
2702 int retry = MAX_CMD_RETRY;
2703 int dlci_num = card->u.f.dlci_num;
2708 memcpy(mbox->data, conf, sizeof(fr_conf_t));
2710 if (dlci_num) for (i = 0; i < dlci_num; ++i)
2711 ((fr_conf_t*)mbox->data)->dlci[i] =
2712 card->u.f.node_dlci[i];
2714 mbox->cmd.command = FR_SET_CONFIG;
2716 sizeof(fr_conf_t) + dlci_num * sizeof(short);
2718 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2720 } while (err && retry-- && fr_event(card, err, mbox));
2724 printk(KERN_ERR "%s: Frame Relay Configuration Failed: rc=0x%x\n",
2731 /*============================================================================
2732 * Set DLCI configuration.
2734 static int fr_dlci_configure (sdla_t* card, fr_dlc_conf_t *conf, unsigned dlci)
2736 fr_mbox_t* mbox = card->mbox;
2737 int retry = MAX_CMD_RETRY;
2742 memcpy(mbox->data, conf, sizeof(fr_dlc_conf_t));
2743 mbox->cmd.dlci = (unsigned short) dlci;
2744 mbox->cmd.command = FR_SET_CONFIG;
2745 mbox->cmd.length = sizeof(fr_dlc_conf_t);
2746 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2747 } while (err && retry--);
2751 /*============================================================================
2752 * Set interrupt mode.
2754 static int fr_set_intr_mode (sdla_t* card, unsigned mode, unsigned mtu,
2755 unsigned short timeout)
2757 fr_mbox_t* mbox = card->mbox;
2758 fr508_intr_ctl_t* ictl = (void*)mbox->data;
2759 int retry = MAX_CMD_RETRY;
2764 memset(ictl, 0, sizeof(fr508_intr_ctl_t));
2767 ictl->irq = card->hw.irq;
2769 /* indicate timeout on timer */
2770 if (mode & 0x20) ictl->timeout = timeout;
2772 mbox->cmd.length = sizeof(fr508_intr_ctl_t);
2773 mbox->cmd.command = FR_SET_INTR_MODE;
2774 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2776 } while (err && retry-- && fr_event(card, err, mbox));
2781 /*============================================================================
2782 * Enable communications.
2784 static int fr_comm_enable (sdla_t* card)
2786 fr_mbox_t* mbox = card->mbox;
2787 int retry = MAX_CMD_RETRY;
2792 mbox->cmd.command = FR_COMM_ENABLE;
2793 mbox->cmd.length = 0;
2794 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2795 } while (err && retry-- && fr_event(card, err, mbox));
2800 /*============================================================================
2803 * Warning: This functin is called by the shutdown() procedure. It is void
2804 * since dev->priv are has already been deallocated and no
2805 * error checking is possible using fr_event() function.
2807 static void fr_comm_disable (sdla_t* card)
2809 fr_mbox_t* mbox = card->mbox;
2810 int retry = MAX_CMD_RETRY;
2814 mbox->cmd.command = FR_SET_MODEM_STATUS;
2815 mbox->cmd.length = 1;
2817 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2818 } while (err && retry--);
2820 retry = MAX_CMD_RETRY;
2824 mbox->cmd.command = FR_COMM_DISABLE;
2825 mbox->cmd.length = 0;
2826 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2827 } while (err && retry--);
2834 /*============================================================================
2835 * Get communications error statistics.
2837 static int fr_get_err_stats (sdla_t* card)
2839 fr_mbox_t* mbox = card->mbox;
2840 int retry = MAX_CMD_RETRY;
2846 mbox->cmd.command = FR_READ_ERROR_STATS;
2847 mbox->cmd.length = 0;
2849 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2850 } while (err && retry-- && fr_event(card, err, mbox));
2853 fr_comm_stat_t* stats = (void*)mbox->data;
2854 card->wandev.stats.rx_over_errors = stats->rx_overruns;
2855 card->wandev.stats.rx_crc_errors = stats->rx_bad_crc;
2856 card->wandev.stats.rx_missed_errors = stats->rx_aborts;
2857 card->wandev.stats.rx_length_errors = stats->rx_too_long;
2858 card->wandev.stats.tx_aborted_errors = stats->tx_aborts;
2865 /*============================================================================
2868 static int fr_get_stats (sdla_t* card)
2870 fr_mbox_t* mbox = card->mbox;
2871 int retry = MAX_CMD_RETRY;
2877 mbox->cmd.command = FR_READ_STATISTICS;
2878 mbox->cmd.length = 0;
2880 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2881 } while (err && retry-- && fr_event(card, err, mbox));
2884 fr_link_stat_t* stats = (void*)mbox->data;
2885 card->wandev.stats.rx_frame_errors = stats->rx_bad_format;
2886 card->wandev.stats.rx_dropped =
2887 stats->rx_dropped + stats->rx_dropped2;
2893 /*============================================================================
2894 * Add DLCI(s) (Access Node only!).
2895 * This routine will perform the ADD_DLCIs command for the specified DLCI.
2897 static int fr_add_dlci (sdla_t* card, int dlci)
2899 fr_mbox_t* mbox = card->mbox;
2900 int retry = MAX_CMD_RETRY;
2905 unsigned short* dlci_list = (void*)mbox->data;
2907 mbox->cmd.length = sizeof(short);
2908 dlci_list[0] = dlci;
2909 mbox->cmd.command = FR_ADD_DLCI;
2910 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2912 } while (err && retry-- && fr_event(card, err, mbox));
2917 /*============================================================================
2918 * Activate DLCI(s) (Access Node only!).
2919 * This routine will perform the ACTIVATE_DLCIs command with a DLCI number.
2921 static int fr_activate_dlci (sdla_t* card, int dlci)
2923 fr_mbox_t* mbox = card->mbox;
2924 int retry = MAX_CMD_RETRY;
2929 unsigned short* dlci_list = (void*)mbox->data;
2931 mbox->cmd.length = sizeof(short);
2932 dlci_list[0] = dlci;
2933 mbox->cmd.command = FR_ACTIVATE_DLCI;
2934 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2936 } while (err && retry-- && fr_event(card, err, mbox));
2941 /*============================================================================
2942 * Delete DLCI(s) (Access Node only!).
2943 * This routine will perform the DELETE_DLCIs command with a DLCI number.
2945 static int fr_delete_dlci (sdla_t* card, int dlci)
2947 fr_mbox_t* mbox = card->mbox;
2948 int retry = MAX_CMD_RETRY;
2953 unsigned short* dlci_list = (void*)mbox->data;
2955 mbox->cmd.length = sizeof(short);
2956 dlci_list[0] = dlci;
2957 mbox->cmd.command = FR_DELETE_DLCI;
2958 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2960 } while (err && retry-- && fr_event(card, err, mbox));
2967 /*============================================================================
2968 * Issue in-channel signalling frame.
2970 static int fr_issue_isf (sdla_t* card, int isf)
2972 fr_mbox_t* mbox = card->mbox;
2973 int retry = MAX_CMD_RETRY;
2978 mbox->data[0] = isf;
2979 mbox->cmd.length = 1;
2980 mbox->cmd.command = FR_ISSUE_IS_FRAME;
2981 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2982 } while (err && retry-- && fr_event(card, err, mbox));
2988 static unsigned int fr_send_hdr (sdla_t*card, int dlci, unsigned int offset)
2990 struct net_device *dev = find_channel(card,dlci);
2993 if (!dev || !(chan=dev->priv))
2996 if (chan->fr_header_len){
2997 sdla_poke(&card->hw, offset, chan->fr_header, chan->fr_header_len);
3000 return offset+chan->fr_header_len;
3003 /*============================================================================
3004 * Send a frame on a selected DLCI.
3006 static int fr_send_data_header (sdla_t* card, int dlci, unsigned char attr, int len,
3007 void *buf, unsigned char hdr_len)
3009 fr_mbox_t* mbox = card->mbox + 0x800;
3010 int retry = MAX_CMD_RETRY;
3015 mbox->cmd.dlci = dlci;
3016 mbox->cmd.attr = attr;
3017 mbox->cmd.length = len+hdr_len;
3018 mbox->cmd.command = FR_WRITE;
3019 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3020 } while (err && retry-- && fr_event(card, err, mbox));
3023 fr_tx_buf_ctl_t* frbuf;
3025 if(card->hw.type == SDLA_S514)
3026 frbuf = (void*)(*(unsigned long*)mbox->data +
3029 frbuf = (void*)(*(unsigned long*)mbox->data -
3030 FR_MB_VECTOR + card->hw.dpmbase);
3032 sdla_poke(&card->hw, fr_send_hdr(card,dlci,frbuf->offset), buf, len);
3039 static int fr_send (sdla_t* card, int dlci, unsigned char attr, int len,
3042 fr_mbox_t* mbox = card->mbox + 0x800;
3043 int retry = MAX_CMD_RETRY;
3048 mbox->cmd.dlci = dlci;
3049 mbox->cmd.attr = attr;
3050 mbox->cmd.length = len;
3051 mbox->cmd.command = FR_WRITE;
3052 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3053 } while (err && retry-- && fr_event(card, err, mbox));
3056 fr_tx_buf_ctl_t* frbuf;
3058 if(card->hw.type == SDLA_S514)
3059 frbuf = (void*)(*(unsigned long*)mbox->data +
3062 frbuf = (void*)(*(unsigned long*)mbox->data -
3063 FR_MB_VECTOR + card->hw.dpmbase);
3065 sdla_poke(&card->hw, frbuf->offset, buf, len);
3073 /****** Firmware Asynchronous Event Handlers ********************************/
3075 /*============================================================================
3076 * Main asyncronous event/error handler.
3077 * This routine is called whenever firmware command returns non-zero
3080 * Return zero if previous command has to be cancelled.
3082 static int fr_event (sdla_t *card, int event, fr_mbox_t* mbox)
3084 fr508_flags_t* flags = card->flags;
3085 char *ptr = &flags->iflag;
3090 case FRRES_MODEM_FAILURE:
3091 return fr_modem_failure(card, mbox);
3093 case FRRES_CHANNEL_DOWN: {
3094 struct net_device *dev;
3096 /* Remove all routes from associated DLCI's */
3097 for (dev = card->wandev.dev; dev;
3098 dev = *((struct net_device **)dev->priv)) {
3099 fr_channel_t *chan = dev->priv;
3100 if (chan->route_flag == ROUTE_ADDED) {
3101 chan->route_flag = REMOVE_ROUTE;
3104 if (chan->inarp == INARP_CONFIGURED) {
3105 chan->inarp = INARP_REQUEST;
3108 /* If the link becomes disconnected then,
3109 * all channels will be disconnected
3112 set_chan_state(dev,WAN_DISCONNECTED);
3115 wanpipe_set_state(card, WAN_DISCONNECTED);
3119 case FRRES_CHANNEL_UP: {
3120 struct net_device *dev;
3122 /* FIXME: Only startup devices that are on the list */
3124 for (dev = card->wandev.dev; dev;
3125 dev = *((struct net_device **)dev->priv)) {
3127 set_chan_state(dev,WAN_CONNECTED);
3130 wanpipe_set_state(card, WAN_CONNECTED);
3134 case FRRES_DLCI_CHANGE:
3135 return fr_dlci_change(card, mbox);
3137 case FRRES_DLCI_MISMATCH:
3138 printk(KERN_INFO "%s: DLCI list mismatch!\n",
3143 printk(KERN_ERR "%s: command 0x%02X timed out!\n",
3144 card->devname, mbox->cmd.command);
3145 printk(KERN_INFO "%s: ID Bytes = ",card->devname);
3146 for(i = 0; i < 8; i ++)
3147 printk(KERN_INFO "0x%02X ", *(ptr + 0x18 + i));
3148 printk(KERN_INFO "\n");
3152 case FRRES_DLCI_INACTIVE:
3155 case FRRES_CIR_OVERFLOW:
3158 case FRRES_BUFFER_OVERFLOW:
3162 printk(KERN_INFO "%s: command 0x%02X returned 0x%02X!\n"
3163 , card->devname, mbox->cmd.command, event);
3169 /*============================================================================
3170 * Handle modem error.
3172 * Return zero if previous command has to be cancelled.
3174 static int fr_modem_failure (sdla_t *card, fr_mbox_t* mbox)
3176 printk(KERN_INFO "%s: physical link down! (modem error 0x%02X)\n",
3177 card->devname, mbox->data[0]);
3179 switch (mbox->cmd.command){
3189 /*============================================================================
3190 * Handle DLCI status change.
3192 * Return zero if previous command has to be cancelled.
3194 static int fr_dlci_change (sdla_t *card, fr_mbox_t* mbox)
3196 dlci_status_t* status = (void*)mbox->data;
3197 int cnt = mbox->cmd.length / sizeof(dlci_status_t);
3199 struct net_device* dev2;
3202 for (; cnt; --cnt, ++status) {
3204 unsigned short dlci= status->dlci;
3205 struct net_device* dev = find_channel(card, dlci);
3209 "%s: CPE contains unconfigured DLCI= %d\n",
3210 card->devname, dlci);
3213 "%s: unconfigured DLCI %d reported by network\n"
3214 , card->devname, dlci);
3217 if (status->state == FR_LINK_INOPER) {
3219 "%s: DLCI %u is inactive!\n",
3220 card->devname, dlci);
3222 if (dev && netif_running(dev))
3223 set_chan_state(dev, WAN_DISCONNECTED);
3226 if (status->state & FR_DLCI_DELETED) {
3229 "%s: DLCI %u has been deleted!\n",
3230 card->devname, dlci);
3232 if (dev && netif_running(dev)){
3234 fr_channel_t *chan = dev->priv;
3236 if (chan->route_flag == ROUTE_ADDED) {
3237 chan->route_flag = REMOVE_ROUTE;
3238 /* The state change will trigger
3239 * the fr polling routine */
3242 if (chan->inarp == INARP_CONFIGURED) {
3243 chan->inarp = INARP_REQUEST;
3246 set_chan_state(dev, WAN_DISCONNECTED);
3249 } else if (status->state & FR_DLCI_ACTIVE) {
3253 /* This flag is used for configuring specific
3254 DLCI(s) when they become active.
3256 chan->dlci_configured = DLCI_CONFIG_PENDING;
3258 set_chan_state(dev, WAN_CONNECTED);
3264 for (dev2 = card->wandev.dev; dev2;
3265 dev2 = *((struct net_device **)dev2->priv)){
3269 if (chan->dlci_configured == DLCI_CONFIG_PENDING) {
3270 if (fr_init_dlci(card, chan)){
3280 static int fr_init_dlci (sdla_t *card, fr_channel_t *chan)
3284 memset(&cfg, 0, sizeof(cfg));
3286 if ( chan->cir_status == CIR_DISABLED) {
3288 cfg.cir_fwd = cfg.cir_bwd = 16;
3289 cfg.bc_fwd = cfg.bc_bwd = 16;
3290 cfg.conf_flags = 0x0001;
3292 }else if (chan->cir_status == CIR_ENABLED) {
3294 cfg.cir_fwd = cfg.cir_bwd = chan->cir;
3295 cfg.bc_fwd = cfg.bc_bwd = chan->bc;
3296 cfg.be_fwd = cfg.be_bwd = chan->be;
3297 cfg.conf_flags = 0x0000;
3300 if (fr_dlci_configure( card, &cfg , chan->dlci)){
3302 "%s: DLCI Configure failed for %d\n",
3303 card->devname, chan->dlci);
3307 chan->dlci_configured = DLCI_CONFIGURED;
3309 /* Read the interface byte mapping into the channel
3312 read_DLCI_IB_mapping( card, chan );
3316 /******* Miscellaneous ******************************************************/
3318 /*============================================================================
3319 * Update channel state.
3321 static int update_chan_state(struct net_device* dev)
3323 fr_channel_t* chan = dev->priv;
3324 sdla_t* card = chan->card;
3325 fr_mbox_t* mbox = card->mbox;
3326 int retry = MAX_CMD_RETRY;
3331 mbox->cmd.command = FR_LIST_ACTIVE_DLCI;
3332 mbox->cmd.length = 0;
3333 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3334 } while (err && retry-- && fr_event(card, err, mbox));
3338 unsigned short* list = (void*)mbox->data;
3339 int cnt = mbox->cmd.length / sizeof(short);
3343 for (; cnt; --cnt, ++list) {
3345 if (*list == chan->dlci) {
3346 set_chan_state(dev, WAN_CONNECTED);
3350 * When a dlci is added or restarted,
3351 * the dlci_int_interface pointer must
3352 * be reinitialized. */
3353 if (!chan->dlci_int_interface){
3354 err=fr_init_dlci (card,chan);
3364 /*============================================================================
3365 * Set channel state.
3367 static void set_chan_state(struct net_device* dev, int state)
3369 fr_channel_t* chan = dev->priv;
3370 sdla_t* card = chan->card;
3372 if (chan->common.state != state) {
3378 "%s: Interface %s: DLCI %d connected\n",
3379 card->devname, dev->name, chan->dlci);
3381 /* If the interface was previoulsy down,
3382 * bring it up, since the channel is active */
3384 trigger_fr_poll (dev);
3385 trigger_fr_arp (dev);
3388 case WAN_CONNECTING:
3390 "%s: Interface %s: DLCI %d connecting\n",
3391 card->devname, dev->name, chan->dlci);
3394 case WAN_DISCONNECTED:
3396 "%s: Interface %s: DLCI %d disconnected!\n",
3397 card->devname, dev->name, chan->dlci);
3399 /* If the interface is up, bring it down,
3400 * since the channel is now disconnected */
3401 trigger_fr_poll (dev);
3405 chan->common.state = state;
3408 chan->state_tick = jiffies;
3411 /*============================================================================
3412 * Find network device by its channel number.
3414 * We need this critical flag because we change
3415 * the dlci_to_dev_map outside the interrupt.
3417 * NOTE: del_if() functions updates this array, it uses
3418 * the spin locks to avoid corruption.
3420 static struct net_device* find_channel(sdla_t* card, unsigned dlci)
3422 if(dlci > HIGHEST_VALID_DLCI)
3425 return(card->u.f.dlci_to_dev_map[dlci]);
3428 /*============================================================================
3429 * Check to see if a frame can be sent. If no transmit buffers available,
3430 * enable transmit interrupts.
3432 * Return: 1 - Tx buffer(s) available
3433 * 0 - no buffers available
3435 static int is_tx_ready (sdla_t* card, fr_channel_t* chan)
3439 if(card->hw.type == SDLA_S514)
3442 sb = inb(card->hw.port);
3449 /*============================================================================
3450 * Convert decimal string to unsigned integer.
3451 * If len != 0 then only 'len' characters of the string are converted.
3453 static unsigned int dec_to_uint (unsigned char* str, int len)
3460 for (val = 0; len && is_digit(*str); ++str, --len)
3461 val = (val * 10) + (*str - (unsigned)'0');
3468 /*=============================================================================
3469 * Store a UDP management packet for later processing.
3472 static int store_udp_mgmt_pkt(int udp_type, char udp_pkt_src, sdla_t* card,
3473 struct sk_buff *skb, int dlci)
3475 int udp_pkt_stored = 0;
3477 struct net_device *dev = find_channel(card, dlci);
3480 if (!dev || !(chan=dev->priv))
3483 if(!card->u.f.udp_pkt_lgth && (skb->len <= MAX_LGTH_UDP_MGNT_PKT)){
3484 card->u.f.udp_pkt_lgth = skb->len + chan->fr_header_len;
3485 card->u.f.udp_type = udp_type;
3486 card->u.f.udp_pkt_src = udp_pkt_src;
3487 card->u.f.udp_dlci = dlci;
3488 memcpy(card->u.f.udp_pkt_data, skb->data, skb->len);
3489 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UDP;
3493 printk(KERN_INFO "ERROR: UDP packet not stored for DLCI %d\n",
3497 if(udp_pkt_src == UDP_PKT_FRM_STACK){
3498 dev_kfree_skb_any(skb);
3500 dev_kfree_skb_any(skb);
3503 return(udp_pkt_stored);
3507 /*==============================================================================
3508 * Process UDP call of type FPIPE8ND
3510 static int process_udp_mgmt_pkt(sdla_t* card)
3513 int c_retry = MAX_CMD_RETRY;
3515 unsigned char frames;
3517 unsigned short buffer_length;
3518 struct sk_buff *new_skb;
3519 fr_mbox_t* mbox = card->mbox;
3522 int udp_mgmt_req_valid = 1;
3523 struct net_device* dev;
3525 fr_udp_pkt_t *fr_udp_pkt;
3526 unsigned short num_trc_els;
3527 fr_trc_el_t* ptr_trc_el;
3529 fpipemon_trc_t* fpipemon_trc;
3531 char udp_pkt_src = card->u.f.udp_pkt_src;
3532 int dlci = card->u.f.udp_dlci;
3534 /* Find network interface for this packet */
3535 dev = find_channel(card, dlci);
3537 card->u.f.udp_pkt_lgth = 0;
3540 if ((chan = dev->priv) == NULL){
3541 card->u.f.udp_pkt_lgth = 0;
3545 /* If the UDP packet is from the network, we are going to have to
3546 transmit a response. Before doing so, we must check to see that
3547 we are not currently transmitting a frame (in 'if_send()') and
3548 that we are not already in a 'delayed transmit' state.
3550 if(udp_pkt_src == UDP_PKT_FRM_NETWORK) {
3551 if (check_tx_status(card,dev)){
3552 card->u.f.udp_pkt_lgth = 0;
3557 fr_udp_pkt = (fr_udp_pkt_t *)card->u.f.udp_pkt_data;
3559 if(udp_pkt_src == UDP_PKT_FRM_NETWORK) {
3561 switch(fr_udp_pkt->cblock.command) {
3563 case FR_READ_MODEM_STATUS:
3564 case FR_READ_STATUS:
3565 case FPIPE_ROUTER_UP_TIME:
3566 case FR_READ_ERROR_STATS:
3567 case FPIPE_DRIVER_STAT_GEN:
3568 case FR_READ_STATISTICS:
3569 case FR_READ_ADD_DLC_STATS:
3570 case FR_READ_CONFIG:
3571 case FR_READ_CODE_VERSION:
3572 udp_mgmt_req_valid = 1;
3575 udp_mgmt_req_valid = 0;
3580 if(!udp_mgmt_req_valid) {
3581 /* set length to 0 */
3582 fr_udp_pkt->cblock.length = 0;
3583 /* set return code */
3584 fr_udp_pkt->cblock.result = 0xCD;
3586 chan->drvstats_gen.UDP_PIPE_mgmt_direction_err ++;
3588 if (net_ratelimit()){
3590 "%s: Warning, Illegal UDP command attempted from network: %x\n",
3591 card->devname,fr_udp_pkt->cblock.command);
3596 switch(fr_udp_pkt->cblock.command) {
3598 case FPIPE_ENABLE_TRACING:
3599 if(!card->TracingEnabled) {
3601 mbox->cmd.command = FR_SET_TRACE_CONFIG;
3602 mbox->cmd.length = 1;
3603 mbox->cmd.dlci = 0x00;
3604 mbox->data[0] = fr_udp_pkt->data[0] |
3606 err = sdla_exec(mbox) ?
3607 mbox->cmd.result : CMD_TIMEOUT;
3608 } while (err && c_retry-- && fr_event(card, err,
3612 card->TracingEnabled = 0;
3613 /* set the return code */
3614 fr_udp_pkt->cblock.result =
3616 mbox->cmd.length = 0;
3620 sdla_peek(&card->hw, NO_TRC_ELEMENTS_OFF,
3622 sdla_peek(&card->hw, BASE_TRC_ELEMENTS_OFF,
3623 &card->u.f.trc_el_base, 4);
3624 card->u.f.curr_trc_el = card->u.f.trc_el_base;
3625 card->u.f.trc_el_last = card->u.f.curr_trc_el +
3626 ((num_trc_els - 1) *
3627 sizeof(fr_trc_el_t));
3629 /* Calculate the maximum trace data area in */
3630 /* the UDP packet */
3631 card->u.f.trc_bfr_space=(MAX_LGTH_UDP_MGNT_PKT -
3632 //sizeof(fr_encap_hdr_t) -
3638 /* set return code */
3639 fr_udp_pkt->cblock.result = 0;
3642 /* set return code to line trace already
3644 fr_udp_pkt->cblock.result = 1;
3647 mbox->cmd.length = 0;
3648 card->TracingEnabled = 1;
3652 case FPIPE_DISABLE_TRACING:
3653 if(card->TracingEnabled) {
3656 mbox->cmd.command = FR_SET_TRACE_CONFIG;
3657 mbox->cmd.length = 1;
3658 mbox->cmd.dlci = 0x00;
3659 mbox->data[0] = ~ACTIVATE_TRC;
3660 err = sdla_exec(mbox) ?
3661 mbox->cmd.result : CMD_TIMEOUT;
3662 } while (err && c_retry-- && fr_event(card, err, mbox));
3665 /* set return code */
3666 fr_udp_pkt->cblock.result = 0;
3667 mbox->cmd.length = 0;
3668 card->TracingEnabled = 0;
3671 case FPIPE_GET_TRACE_INFO:
3673 /* Line trace cannot be performed on the 502 */
3674 if(!card->TracingEnabled) {
3675 /* set return code */
3676 fr_udp_pkt->cblock.result = 1;
3677 mbox->cmd.length = 0;
3681 ptr_trc_el = (void *)card->u.f.curr_trc_el;
3684 fr_udp_pkt->data[0x00] = 0x00;
3686 for(frames = 0; frames < MAX_FRMS_TRACED; frames ++) {
3688 sdla_peek(&card->hw, (unsigned long)ptr_trc_el,
3689 (void *)&trc_el.flag,
3690 sizeof(fr_trc_el_t));
3691 if(trc_el.flag == 0x00) {
3694 if((card->u.f.trc_bfr_space - buffer_length)
3695 < sizeof(fpipemon_trc_hdr_t)) {
3696 fr_udp_pkt->data[0x00] |= MORE_TRC_DATA;
3701 (fpipemon_trc_t *)&fr_udp_pkt->data[buffer_length];
3702 fpipemon_trc->fpipemon_trc_hdr.status =
3704 fpipemon_trc->fpipemon_trc_hdr.tmstamp =
3706 fpipemon_trc->fpipemon_trc_hdr.length =
3709 if(!trc_el.offset || !trc_el.length) {
3711 fpipemon_trc->fpipemon_trc_hdr.data_passed = 0x00;
3713 }else if((trc_el.length + sizeof(fpipemon_trc_hdr_t) + 1) >
3714 (card->u.f.trc_bfr_space - buffer_length)){
3716 fpipemon_trc->fpipemon_trc_hdr.data_passed = 0x00;
3717 fr_udp_pkt->data[0x00] |= MORE_TRC_DATA;
3720 fpipemon_trc->fpipemon_trc_hdr.data_passed = 0x01;
3721 sdla_peek(&card->hw, trc_el.offset,
3727 sdla_poke(&card->hw, (unsigned long)ptr_trc_el,
3731 if((void *)ptr_trc_el > card->u.f.trc_el_last)
3732 ptr_trc_el = (void*)card->u.f.trc_el_base;
3734 buffer_length += sizeof(fpipemon_trc_hdr_t);
3735 if(fpipemon_trc->fpipemon_trc_hdr.data_passed) {
3736 buffer_length += trc_el.length;
3739 if(fr_udp_pkt->data[0x00] & MORE_TRC_DATA) {
3744 if(frames == MAX_FRMS_TRACED) {
3745 fr_udp_pkt->data[0x00] |= MORE_TRC_DATA;
3748 card->u.f.curr_trc_el = (void *)ptr_trc_el;
3750 /* set the total number of frames passed */
3751 fr_udp_pkt->data[0x00] |=
3752 ((frames << 1) & (MAX_FRMS_TRACED << 1));
3754 /* set the data length and return code */
3755 fr_udp_pkt->cblock.length = mbox->cmd.length = buffer_length;
3756 fr_udp_pkt->cblock.result = 0;
3759 case FPIPE_FT1_READ_STATUS:
3760 sdla_peek(&card->hw, 0xF020,
3761 &fr_udp_pkt->data[0x00] , 2);
3762 fr_udp_pkt->cblock.length = mbox->cmd.length = 2;
3763 fr_udp_pkt->cblock.result = 0;
3766 case FPIPE_FLUSH_DRIVER_STATS:
3767 init_chan_statistics(chan);
3768 init_global_statistics(card);
3769 mbox->cmd.length = 0;
3772 case FPIPE_ROUTER_UP_TIME:
3773 do_gettimeofday(&tv);
3774 chan->router_up_time = tv.tv_sec -
3775 chan->router_start_time;
3776 *(unsigned long *)&fr_udp_pkt->data =
3777 chan->router_up_time;
3778 mbox->cmd.length = fr_udp_pkt->cblock.length = 4;
3779 fr_udp_pkt->cblock.result = 0;
3782 case FPIPE_DRIVER_STAT_IFSEND:
3783 memcpy(fr_udp_pkt->data,
3784 &chan->drvstats_if_send.if_send_entry,
3785 sizeof(if_send_stat_t));
3786 mbox->cmd.length = fr_udp_pkt->cblock.length =sizeof(if_send_stat_t);
3787 fr_udp_pkt->cblock.result = 0;
3790 case FPIPE_DRIVER_STAT_INTR:
3792 memcpy(fr_udp_pkt->data,
3793 &card->statistics.isr_entry,
3794 sizeof(global_stats_t));
3796 memcpy(&fr_udp_pkt->data[sizeof(global_stats_t)],
3797 &chan->drvstats_rx_intr.rx_intr_no_socket,
3798 sizeof(rx_intr_stat_t));
3800 mbox->cmd.length = fr_udp_pkt->cblock.length =
3801 sizeof(global_stats_t) +
3802 sizeof(rx_intr_stat_t);
3803 fr_udp_pkt->cblock.result = 0;
3806 case FPIPE_DRIVER_STAT_GEN:
3807 memcpy(fr_udp_pkt->data,
3808 &chan->drvstats_gen.UDP_PIPE_mgmt_kmalloc_err,
3809 sizeof(pipe_mgmt_stat_t));
3811 memcpy(&fr_udp_pkt->data[sizeof(pipe_mgmt_stat_t)],
3812 &card->statistics, sizeof(global_stats_t));
3814 mbox->cmd.length = fr_udp_pkt->cblock.length = sizeof(global_stats_t)+
3815 sizeof(rx_intr_stat_t);
3816 fr_udp_pkt->cblock.result = 0;
3820 case FR_FT1_STATUS_CTRL:
3821 if(fr_udp_pkt->data[0] == 1) {
3823 fr_udp_pkt->cblock.result = 0;
3824 mbox->cmd.length = 1;
3829 /* Disable FT1 MONITOR STATUS */
3830 if(fr_udp_pkt->data[0] == 0) {
3831 if( --rCount != 0) {
3832 fr_udp_pkt->cblock.result = 0;
3833 mbox->cmd.length = 1;
3844 &fr_udp_pkt->cblock.command,
3846 if(mbox->cmd.length) {
3848 (char *)fr_udp_pkt->data,
3852 err = sdla_exec(mbox) ? mbox->cmd.result :
3854 } while (err && c_retry-- && fr_event(card, err, mbox));
3858 UDP_PIPE_mgmt_adptr_cmnd_OK ++;
3861 UDP_PIPE_mgmt_adptr_cmnd_timeout ++;
3863 /* copy the result back to our buffer */
3864 memcpy(&fr_udp_pkt->cblock.command,
3865 &mbox->cmd, sizeof(fr_cmd_t));
3867 if(mbox->cmd.length) {
3868 memcpy(&fr_udp_pkt->data,
3869 &mbox->data, mbox->cmd.length);
3875 fr_udp_pkt->ip_pkt.ttl = card->wandev.ttl;
3876 len = reply_udp(card->u.f.udp_pkt_data, mbox->cmd.length);
3878 if(udp_pkt_src == UDP_PKT_FRM_NETWORK) {
3880 chan->fr_header_len=2;
3881 chan->fr_header[0]=Q922_UI;
3882 chan->fr_header[1]=NLPID_IP;
3884 err = fr_send_data_header(card, dlci, 0, len,
3885 card->u.f.udp_pkt_data,chan->fr_header_len);
3887 chan->drvstats_gen.UDP_PIPE_mgmt_adptr_send_passed ++;
3889 chan->drvstats_gen.UDP_PIPE_mgmt_adptr_send_failed ++;
3893 /* Allocate socket buffer */
3894 if((new_skb = dev_alloc_skb(len)) != NULL) {
3896 /* copy data into new_skb */
3897 buf = skb_put(new_skb, len);
3898 memcpy(buf, card->u.f.udp_pkt_data, len);
3901 UDP_PIPE_mgmt_passed_to_stack ++;
3903 new_skb->protocol = htons(ETH_P_IP);
3904 new_skb->mac.raw = new_skb->data;
3908 chan->drvstats_gen.UDP_PIPE_mgmt_no_socket ++;
3910 "%s: UDP mgmt cmnd, no socket buffers available!\n",
3915 card->u.f.udp_pkt_lgth = 0;
3920 /*==============================================================================
3921 * Send Inverse ARP Request
3924 int send_inarp_request(sdla_t *card, struct net_device *dev)
3928 arphdr_1490_t *ArpPacket;
3929 arphdr_fr_t *arphdr;
3930 fr_channel_t *chan = dev->priv;
3931 struct in_device *in_dev;
3933 in_dev = dev->ip_ptr;
3935 if(in_dev != NULL ) {
3937 ArpPacket = kmalloc(sizeof(arphdr_1490_t) + sizeof(arphdr_fr_t), GFP_ATOMIC);
3938 /* SNAP Header indicating ARP */
3939 ArpPacket->control = 0x03;
3940 ArpPacket->pad = 0x00;
3941 ArpPacket->NLPID = 0x80;
3942 ArpPacket->OUI[0] = 0;
3943 ArpPacket->OUI[1] = 0;
3944 ArpPacket->OUI[2] = 0;
3945 ArpPacket->PID = 0x0608;
3947 arphdr = (arphdr_fr_t *)(ArpPacket + 1); // Go to ARP Packet
3950 arphdr->ar_hrd = 0x0F00; /* Frame Relay HW type */
3951 arphdr->ar_pro = 0x0008; /* IP Protocol */
3952 arphdr->ar_hln = 2; /* HW addr length */
3953 arphdr->ar_pln = 4; /* IP addr length */
3954 arphdr->ar_op = htons(0x08); /* InARP Request */
3955 arphdr->ar_sha = 0; /* src HW DLCI - Doesn't matter */
3956 if(in_dev->ifa_list != NULL)
3957 arphdr->ar_sip = in_dev->ifa_list->ifa_local; /* Local Address */else
3959 arphdr->ar_tha = 0; /* dst HW DLCI - Doesn't matter */
3960 arphdr->ar_tip = 0; /* Remote Address -- what we want */
3962 err = fr_send(card, chan->dlci, 0, sizeof(arphdr_1490_t) + sizeof(arphdr_fr_t),
3966 printk(KERN_INFO "\n%s: Sending InARP request on DLCI %d.\n",
3967 card->devname, chan->dlci);
3968 clear_bit(ARP_CRIT,&card->wandev.critical);
3973 printk(KERN_INFO "%s: INARP ERROR: %s doesn't have a local IP address!\n",
3974 card->devname,dev->name);
3982 /*==============================================================================
3983 * Check packet for ARP Type
3986 int is_arp(void *buf)
3988 arphdr_1490_t *arphdr = (arphdr_1490_t *)buf;
3990 if (arphdr->pad == 0x00 &&
3991 arphdr->NLPID == 0x80 &&
3992 arphdr->PID == 0x0608)
3997 /*==============================================================================
3998 * Process ARP Packet Type
4001 int process_ARP(arphdr_1490_t *ArpPacket, sdla_t *card, struct net_device* dev)
4005 arphdr_fr_t *arphdr = (arphdr_fr_t *)(ArpPacket + 1); /* Skip header */
4006 fr_rx_buf_ctl_t* frbuf = card->rxmb;
4007 struct in_device *in_dev;
4008 fr_channel_t *chan = dev->priv;
4010 /* Before we transmit ARP packet, we must check
4011 * to see that we are not currently transmitting a
4012 * frame (in 'if_send()') and that we are not
4013 * already in a 'delayed transmit' state. */
4014 if (check_tx_status(card,dev)){
4015 if (net_ratelimit()){
4016 printk(KERN_INFO "%s: Disabling comminication to process ARP\n",
4019 set_bit(ARP_CRIT,&card->wandev.critical);
4023 in_dev = dev->ip_ptr;
4025 /* Check that IP addresses exist for our network address */
4026 if (in_dev == NULL || in_dev->ifa_list == NULL)
4029 switch (ntohs(arphdr->ar_op)) {
4031 case 0x08: // Inverse ARP request -- Send Reply, add route.
4033 /* Check for valid Address */
4034 printk(KERN_INFO "%s: Recvd PtP addr -InArp Req: %u.%u.%u.%u\n",
4035 card->devname, NIPQUAD(arphdr->ar_sip));
4038 /* Check that the network address is the same as ours, only
4039 * if the netowrk mask is not 255.255.255.255. Otherwise
4040 * this check would not make sense */
4042 if (in_dev->ifa_list->ifa_mask != 0xFFFFFFFF &&
4043 (in_dev->ifa_list->ifa_mask & arphdr->ar_sip) !=
4044 (in_dev->ifa_list->ifa_mask & in_dev->ifa_list->ifa_local)){
4046 "%s: Invalid PtP address. %u.%u.%u.%u InARP ignored.\n",
4047 card->devname,NIPQUAD(arphdr->ar_sip));
4049 printk(KERN_INFO "%s: mask %u.%u.%u.%u\n",
4050 card->devname, NIPQUAD(in_dev->ifa_list->ifa_mask));
4051 printk(KERN_INFO "%s: local %u.%u.%u.%u\n",
4052 card->devname,NIPQUAD(in_dev->ifa_list->ifa_local));
4056 if (in_dev->ifa_list->ifa_local == arphdr->ar_sip){
4058 "%s: Local addr = PtP addr. InARP ignored.\n",
4063 arphdr->ar_op = htons(0x09); /* InARP Reply */
4066 arphdr->ar_tip = arphdr->ar_sip;
4067 arphdr->ar_sip = in_dev->ifa_list->ifa_local;
4069 chan->ip_local = in_dev->ifa_list->ifa_local;
4070 chan->ip_remote = arphdr->ar_sip;
4072 fr_send(card, frbuf->dlci, 0, frbuf->length, (void *)ArpPacket);
4074 if (test_bit(ARP_CRIT,&card->wandev.critical)){
4075 if (net_ratelimit()){
4076 printk(KERN_INFO "%s: ARP Processed Enabling Communication!\n",
4080 clear_bit(ARP_CRIT,&card->wandev.critical);
4082 chan->ip_local = in_dev->ifa_list->ifa_local;
4083 chan->ip_remote = arphdr->ar_sip;
4085 /* Add Route Flag */
4086 /* The route will be added in the polling routine so
4087 that it is not interrupt context. */
4089 chan->route_flag = ADD_ROUTE;
4090 trigger_fr_poll (dev);
4094 case 0x09: // Inverse ARP reply
4096 /* Check for valid Address */
4097 printk(KERN_INFO "%s: Recvd PtP addr %u.%u.%u.%u -InArp Reply\n",
4098 card->devname, NIPQUAD(arphdr->ar_sip));
4101 /* Compare network addresses, only if network mask
4102 * is not 255.255.255.255 It would not make sense
4103 * to perform this test if the mask was all 1's */
4105 if (in_dev->ifa_list->ifa_mask != 0xffffffff &&
4106 (in_dev->ifa_list->ifa_mask & arphdr->ar_sip) !=
4107 (in_dev->ifa_list->ifa_mask & in_dev->ifa_list->ifa_local)) {
4109 printk(KERN_INFO "%s: Invalid PtP address. InARP ignored.\n",
4114 /* Make sure that the received IP address is not
4115 * the same as our own local address */
4116 if (in_dev->ifa_list->ifa_local == arphdr->ar_sip) {
4117 printk(KERN_INFO "%s: Local addr = PtP addr. InARP ignored.\n",
4122 chan->ip_local = in_dev->ifa_list->ifa_local;
4123 chan->ip_remote = arphdr->ar_sip;
4125 /* Add Route Flag */
4126 /* The route will be added in the polling routine so
4127 that it is not interrupt context. */
4129 chan->route_flag = ADD_ROUTE;
4130 chan->inarp = INARP_CONFIGURED;
4131 trigger_fr_poll(dev);
4135 break; // ARP's and RARP's -- Shouldn't happen.
4142 /*============================================================
4146 * Add an fr_arp() task into a arp
4147 * timer handler for a specific dlci/interface.
4148 * This will kick the fr_arp() routine
4149 * within the specified time interval.
4152 * This timer is used to send ARP requests at
4153 * certain time intervals.
4154 * Called by an interrupt to request an action
4158 static void trigger_fr_arp(struct net_device *dev)
4160 fr_channel_t* chan = dev->priv;
4162 mod_timer(&chan->fr_arp_timer, jiffies + chan->inarp_interval * HZ);
4168 /*==============================================================================
4169 * ARP Request Action
4171 * This funciton is called by timer interrupt to send an arp request
4172 * to the remote end.
4175 static void fr_arp (unsigned long data)
4177 struct net_device *dev = (struct net_device *)data;
4178 fr_channel_t *chan = dev->priv;
4179 volatile sdla_t *card = chan->card;
4180 fr508_flags_t* flags = card->flags;
4182 /* Send ARP packets for all devs' until
4183 * ARP state changes to CONFIGURED */
4185 if (chan->inarp == INARP_REQUEST &&
4186 chan->common.state == WAN_CONNECTED &&
4187 card->wandev.state == WAN_CONNECTED){
4188 set_bit(0,&chan->inarp_ready);
4189 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_ARP;
4190 flags->imask |= FR_INTR_TIMER;
4197 /*==============================================================================
4198 * Perform the Interrupt Test by running the READ_CODE_VERSION command MAX_INTR_
4199 * TEST_COUNTER times.
4201 static int intr_test( sdla_t* card )
4203 fr_mbox_t* mb = card->mbox;
4206 err = fr_set_intr_mode(card, FR_INTR_READY, card->wandev.mtu, 0 );
4208 if (err == CMD_OK) {
4210 for ( i = 0; i < MAX_INTR_TEST_COUNTER; i++ ) {
4211 /* Run command READ_CODE_VERSION */
4213 mb->cmd.command = FR_READ_CODE_VERSION;
4214 err = sdla_exec(mb) ? mb->cmd.result : CMD_TIMEOUT;
4216 fr_event(card, err, mb);
4223 err = fr_set_intr_mode( card, 0, card->wandev.mtu, 0 );
4231 /*==============================================================================
4232 * Determine what type of UDP call it is. FPIPE8ND ?
4234 static int udp_pkt_type( struct sk_buff *skb, sdla_t* card )
4236 fr_udp_pkt_t *fr_udp_pkt = (fr_udp_pkt_t *)skb->data;
4241 if((fr_udp_pkt->ip_pkt.protocol == UDPMGMT_UDP_PROTOCOL) &&
4242 (fr_udp_pkt->ip_pkt.ver_inet_hdr_length == 0x45) &&
4243 (fr_udp_pkt->udp_pkt.udp_dst_port ==
4244 ntohs(card->wandev.udp_port)) &&
4245 (fr_udp_pkt->wp_mgmt.request_reply ==
4247 if(!strncmp(fr_udp_pkt->wp_mgmt.signature,
4248 UDPMGMT_FPIPE_SIGNATURE, 8)){
4249 return UDP_FPIPE_TYPE;
4252 return UDP_INVALID_TYPE;
4256 /*==============================================================================
4257 * Initializes the Statistics values in the fr_channel structure.
4259 void init_chan_statistics( fr_channel_t* chan)
4261 memset(&chan->drvstats_if_send.if_send_entry, 0,
4262 sizeof(if_send_stat_t));
4263 memset(&chan->drvstats_rx_intr.rx_intr_no_socket, 0,
4264 sizeof(rx_intr_stat_t));
4265 memset(&chan->drvstats_gen.UDP_PIPE_mgmt_kmalloc_err, 0,
4266 sizeof(pipe_mgmt_stat_t));
4269 /*==============================================================================
4270 * Initializes the Statistics values in the Sdla_t structure.
4272 void init_global_statistics( sdla_t* card )
4274 /* Intialize global statistics for a card */
4275 memset(&card->statistics.isr_entry, 0, sizeof(global_stats_t));
4278 static void read_DLCI_IB_mapping( sdla_t* card, fr_channel_t* chan )
4280 fr_mbox_t* mbox = card->mbox;
4281 int retry = MAX_CMD_RETRY;
4282 dlci_IB_mapping_t* result;
4283 int err, counter, found;
4286 mbox->cmd.command = FR_READ_DLCI_IB_MAPPING;
4287 mbox->cmd.length = 0;
4288 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4289 } while (err && retry-- && fr_event(card, err, mbox));
4291 if( mbox->cmd.result != 0){
4292 printk(KERN_INFO "%s: Read DLCI IB Mapping failed\n",
4296 counter = mbox->cmd.length / sizeof(dlci_IB_mapping_t);
4297 result = (void *)mbox->data;
4300 for (; counter; --counter, ++result) {
4301 if ( result->dlci == chan->dlci ) {
4302 chan->IB_addr = result->addr_value;
4303 if(card->hw.type == SDLA_S514){
4304 chan->dlci_int_interface =
4305 (void*)(card->hw.dpmbase +
4308 chan->dlci_int_interface =
4309 (void*)(card->hw.dpmbase +
4310 (chan->IB_addr & 0x00001FFF));
4318 printk( KERN_INFO "%s: DLCI %d not found by IB MAPPING cmd\n",
4319 card->devname, chan->dlci);
4324 void s508_s514_lock(sdla_t *card, unsigned long *smp_flags)
4326 if (card->hw.type != SDLA_S514){
4328 spin_lock_irqsave(&card->wandev.lock, *smp_flags);
4330 spin_lock(&card->u.f.if_send_lock);
4336 void s508_s514_unlock(sdla_t *card, unsigned long *smp_flags)
4338 if (card->hw.type != SDLA_S514){
4340 spin_unlock_irqrestore (&card->wandev.lock, *smp_flags);
4342 spin_unlock(&card->u.f.if_send_lock);
4349 /*----------------------------------------------------------------------
4350 RECEIVE INTERRUPT: BOTTOM HALF HANDLERS
4351 ----------------------------------------------------------------------*/
4354 /*========================================================
4358 * Insert a received packet into a circular
4359 * rx queue. This packet will be picked up
4360 * by fr_bh() and sent up the stack to the
4364 * This function is called by rx interrupt,
4369 static int bh_enqueue(struct net_device *dev, struct sk_buff *skb)
4371 /* Check for full */
4372 fr_channel_t* chan = dev->priv;
4373 sdla_t *card = chan->card;
4376 if (atomic_read(&chan->bh_buff_used) == MAX_BH_BUFF){
4377 ++card->wandev.stats.rx_dropped;
4378 dev_kfree_skb_any(skb);
4382 ((bh_data_t *)&chan->bh_head[chan->bh_write])->skb = skb;
4384 if (chan->bh_write == (MAX_BH_BUFF-1)){
4390 atomic_inc(&chan->bh_buff_used);
4396 /*========================================================
4400 * Kick the fr_bh() handler
4403 * rx interrupt calls this function during
4407 static void trigger_fr_bh (fr_channel_t *chan)
4409 if (!test_and_set_bit(0,&chan->tq_working)){
4410 wanpipe_queue_work(&chan->common.wanpipe_work);
4415 /*========================================================
4419 * Frame relay receive BH handler.
4420 * Dequeue data from the BH circular
4421 * buffer and pass it up the API sock.
4424 * This fuction is used to offload the
4425 * rx_interrupt during API operation mode.
4426 * The fr_bh() function executes for each
4429 * Once receive interrupt copies data from the
4430 * card into an skb buffer, the skb buffer
4431 * is appended to a circular BH buffer.
4432 * Then the interrupt kicks fr_bh() to finish the
4433 * job at a later time (not within the interrupt).
4436 * Interrupts use this to defer a task to
4437 * a polling routine.
4441 static void fr_bh(struct net_device * dev)
4443 fr_channel_t* chan = dev->priv;
4444 sdla_t *card = chan->card;
4445 struct sk_buff *skb;
4447 if (atomic_read(&chan->bh_buff_used) == 0){
4448 clear_bit(0, &chan->tq_working);
4452 while (atomic_read(&chan->bh_buff_used)){
4454 if (chan->common.sk == NULL || chan->common.func == NULL){
4455 clear_bit(0, &chan->tq_working);
4459 skb = ((bh_data_t *)&chan->bh_head[chan->bh_read])->skb;
4463 if (chan->common.sk == NULL || chan->common.func == NULL){
4464 ++card->wandev.stats.rx_dropped;
4465 ++chan->ifstats.rx_dropped;
4466 dev_kfree_skb_any(skb);
4471 if (chan->common.func(skb,dev,chan->common.sk) != 0){
4472 /* Sock full cannot send, queue us for
4474 atomic_set(&chan->common.receive_block,1);
4483 clear_bit(0, &chan->tq_working);
4488 static int fr_bh_cleanup(struct net_device *dev)
4490 fr_channel_t* chan = dev->priv;
4492 ((bh_data_t *)&chan->bh_head[chan->bh_read])->skb = NULL;
4494 if (chan->bh_read == (MAX_BH_BUFF-1)){
4500 atomic_dec(&chan->bh_buff_used);
4505 /*----------------------------------------------------------------------
4506 POLL BH HANDLERS AND KICK ROUTINES
4507 ----------------------------------------------------------------------*/
4509 /*============================================================
4513 * Add a fr_poll() task into a tq_scheduler bh handler
4514 * for a specific dlci/interface. This will kick
4515 * the fr_poll() routine at a later time.
4518 * Interrupts use this to defer a taks to
4519 * a polling routine.
4522 static void trigger_fr_poll(struct net_device *dev)
4524 fr_channel_t* chan = dev->priv;
4525 schedule_work(&chan->fr_poll_work);
4530 /*============================================================
4534 * We cannot manipulate the routing tables, or
4535 * ip addresses withing the interrupt. Therefore
4536 * we must perform such actons outside an interrupt
4540 * Frame relay polling routine, responsible for
4541 * shutting down interfaces upon disconnect
4542 * and adding/removing routes.
4545 * This function is executed for each frame relay
4546 * dlci/interface through a tq_schedule bottom half.
4548 * trigger_fr_poll() function is used to kick
4549 * the fr_poll routine.
4552 static void fr_poll(struct net_device *dev)
4559 if (!dev || (chan = dev->priv) == NULL)
4564 /* (Re)Configuraiton is in progress, stop what you are
4565 * doing and get out */
4566 if (test_bit(PERI_CRIT,&card->wandev.critical)){
4570 switch (chan->common.state){
4572 case WAN_DISCONNECTED:
4574 if (test_bit(DYN_OPT_ON,&chan->interface_down) &&
4575 !test_bit(DEV_DOWN, &chan->interface_down) &&
4578 printk(KERN_INFO "%s: Interface %s is Down.\n",
4579 card->devname,dev->name);
4580 change_dev_flags(dev,dev->flags&~IFF_UP);
4581 set_bit(DEV_DOWN, &chan->interface_down);
4582 chan->route_flag = NO_ROUTE;
4585 if (chan->inarp != INARP_NONE)
4592 if (test_bit(DYN_OPT_ON,&chan->interface_down) &&
4593 test_bit(DEV_DOWN, &chan->interface_down) &&
4594 !(dev->flags&IFF_UP)){
4596 printk(KERN_INFO "%s: Interface %s is Up.\n",
4597 card->devname,dev->name);
4599 change_dev_flags(dev,dev->flags|IFF_UP);
4600 clear_bit(DEV_DOWN, &chan->interface_down);
4604 if (chan->inarp != INARP_NONE){
4609 if (chan->gateway && check_gateway)
4610 add_gateway(card,dev);
4619 /*==============================================================
4623 * We cannot transmit from an interrupt while
4624 * the if_send is transmitting data. Therefore,
4625 * we must check whether the tx buffers are
4626 * begin used, before we transmit from an
4630 * Checks whether it's safe to use the transmit
4634 * ARP and UDP handling routines use this function
4635 * because, they need to transmit data during
4639 static int check_tx_status(sdla_t *card, struct net_device *dev)
4642 if (card->hw.type == SDLA_S514){
4643 if (test_bit(SEND_CRIT, (void*)&card->wandev.critical) ||
4644 test_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical)) {
4649 if (netif_queue_stopped(dev) || (card->u.f.tx_interrupts_pending))
4655 /*===============================================================
4659 * Move the dev pointer to the next location in the
4660 * link list. Check if we are at the end of the
4661 * list, if so start from the begining.
4664 * Timer interrupt uses this function to efficiently
4665 * step through the devices that need to send ARP data.
4669 struct net_device *move_dev_to_next(sdla_t *card, struct net_device *dev)
4671 if (card->wandev.new_if_cnt != 1){
4672 if (!*((struct net_device **)dev->priv))
4673 return card->wandev.dev;
4675 return *((struct net_device **)dev->priv);
4680 /*==============================================================
4684 * All commands must be performed inside of a
4688 * Kick the config_fr() routine throught the
4693 static void trigger_config_fr (sdla_t *card)
4695 fr508_flags_t* flags = card->flags;
4697 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_CONFIG;
4698 flags->imask |= FR_INTR_TIMER;
4702 /*==============================================================
4706 * All commands must be performed inside of a
4710 * Configure a DLCI. This function is executed
4711 * by a timer_interrupt. The if_open() function
4715 * new_if() collects all data necessary to
4716 * configure the DLCI. It sets the chan->dlci_ready
4717 * bit. When the if_open() function is executed
4718 * it checks this bit, and if its set it triggers
4719 * the timer interrupt to execute the config_fr()
4723 static void config_fr (sdla_t *card)
4725 struct net_device *dev;
4728 for (dev = card->wandev.dev; dev;
4729 dev = *((struct net_device **)dev->priv)) {
4731 if ((chan=dev->priv) == NULL)
4734 if (!test_bit(0,&chan->config_dlci))
4737 clear_bit(0,&chan->config_dlci);
4739 /* If signalling is set to NO, then setup
4740 * DLCI addresses right away. Don't have to wait for
4743 if (card->wandev.signalling == WANOPT_NO){
4744 printk(KERN_INFO "%s: Signalling set to NO: Mapping DLCI's\n",
4746 if (fr_init_dlci(card,chan)){
4747 printk(KERN_INFO "%s: ERROR: Failed to configure DLCI %i !\n",
4748 card->devname, chan->dlci);
4753 if (card->wandev.station == WANOPT_CPE) {
4755 update_chan_state(dev);
4757 /* CPE: issue full status enquiry */
4758 fr_issue_isf(card, FR_ISF_FSE);
4761 /* FR switch: activate DLCI(s) */
4763 /* For Switch emulation we have to ADD and ACTIVATE
4764 * the DLCI(s) that were configured with the SET_DLCI_
4765 * CONFIGURATION command. Add and Activate will fail if
4766 * DLCI specified is not included in the list.
4768 * Also If_open is called once for each interface. But
4769 * it does not get in here for all the interface. So
4770 * we have to pass the entire list of DLCI(s) to add
4771 * activate routines.
4774 if (!check_dlci_config (card, chan)){
4775 fr_add_dlci(card, chan->dlci);
4776 fr_activate_dlci(card, chan->dlci);
4780 card->u.f.dlci_to_dev_map[chan->dlci] = dev;
4786 /*==============================================================
4790 * All commands must be executed during an interrupt.
4793 * Trigger uncofig_fr() function through
4794 * the timer interrupt.
4798 static void trigger_unconfig_fr(struct net_device *dev)
4800 fr_channel_t *chan = dev->priv;
4801 volatile sdla_t *card = chan->card;
4803 fr508_flags_t* flags = card->flags;
4804 int reset_critical=0;
4806 if (test_bit(PERI_CRIT,(void*)&card->wandev.critical)){
4807 clear_bit(PERI_CRIT,(void*)&card->wandev.critical);
4811 /* run unconfig_dlci() function
4812 * throught the timer interrupt */
4813 set_bit(0,(void*)&chan->unconfig_dlci);
4814 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UNCONFIG;
4815 flags->imask |= FR_INTR_TIMER;
4817 /* Wait for the command to complete */
4821 if(!(card->u.f.timer_int_enabled & TMR_INT_ENABLED_UNCONFIG))
4824 if ((jiffies - timeout) > (1 * HZ)){
4825 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UNCONFIG;
4826 printk(KERN_INFO "%s: Failed to delete DLCI %i\n",
4827 card->devname,chan->dlci);
4832 if (reset_critical){
4833 set_bit(PERI_CRIT,(void*)&card->wandev.critical);
4837 /*==============================================================
4841 * All commands must be executed during an interrupt.
4844 * Remove the dlci from firmware.
4845 * This funciton is used in NODE shutdown.
4848 static void unconfig_fr (sdla_t *card)
4850 struct net_device *dev;
4853 for (dev = card->wandev.dev; dev;
4854 dev = *((struct net_device **)dev->priv)){
4856 if ((chan=dev->priv) == NULL)
4859 if (!test_bit(0,&chan->unconfig_dlci))
4862 clear_bit(0,&chan->unconfig_dlci);
4864 if (card->wandev.station == WANOPT_NODE){
4865 printk(KERN_INFO "%s: Unconfiguring DLCI %i\n",
4866 card->devname,chan->dlci);
4867 fr_delete_dlci(card,chan->dlci);
4869 card->u.f.dlci_to_dev_map[chan->dlci] = NULL;
4873 static int setup_fr_header(struct sk_buff **skb_orig, struct net_device* dev,
4876 struct sk_buff *skb = *skb_orig;
4877 fr_channel_t *chan=dev->priv;
4879 if (op_mode == WANPIPE){
4881 chan->fr_header[0]=Q922_UI;
4883 switch (htons(skb->protocol)){
4886 chan->fr_header[1]=NLPID_IP;
4895 /* If we are in bridging mode, we must apply
4896 * an Ethernet header */
4897 if (op_mode == BRIDGE || op_mode == BRIDGE_NODE){
4900 /* Encapsulate the packet as a bridged Ethernet frame. */
4902 printk(KERN_INFO "%s: encapsulating skb for frame relay\n",
4906 chan->fr_header[0] = 0x03;
4907 chan->fr_header[1] = 0x00;
4908 chan->fr_header[2] = 0x80;
4909 chan->fr_header[3] = 0x00;
4910 chan->fr_header[4] = 0x80;
4911 chan->fr_header[5] = 0xC2;
4912 chan->fr_header[6] = 0x00;
4913 chan->fr_header[7] = 0x07;
4916 skb->protocol = ETH_P_802_3;
4925 static int check_dlci_config (sdla_t *card, fr_channel_t *chan)
4927 fr_mbox_t* mbox = card->mbox;
4929 fr_conf_t *conf=NULL;
4930 unsigned short dlci_num = chan->dlci;
4932 struct net_device *dev = NULL;
4934 mbox->cmd.command = FR_READ_CONFIG;
4935 mbox->cmd.length = 0;
4936 mbox->cmd.dlci = dlci_num;
4938 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4944 for (dev = card->wandev.dev; dev;
4945 dev=*((struct net_device **)dev->priv))
4946 set_chan_state(dev,WAN_DISCONNECTED);
4948 printk(KERN_INFO "DLCI %i Not configured, configuring\n",dlci_num);
4950 mbox->cmd.command = FR_COMM_DISABLE;
4951 mbox->cmd.length = 0;
4952 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4954 fr_event(card, err, mbox);
4958 printk(KERN_INFO "Disabled Communications \n");
4960 mbox->cmd.command = FR_READ_CONFIG;
4961 mbox->cmd.length = 0;
4964 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4967 fr_event(card, err, mbox);
4971 conf = (fr_conf_t *)mbox->data;
4974 for (dev = card->wandev.dev; dev;
4975 dev = *((struct net_device **)dev->priv)) {
4976 fr_channel_t *chan_tmp = dev->priv;
4977 conf->dlci[dlci_offset] = chan_tmp->dlci;
4981 printk(KERN_INFO "Got Fr configuration Buffer Length is %x Dlci %i Dlci Off %i\n",
4983 mbox->cmd.length > 0x20 ? conf->dlci[0] : -1,
4986 mbox->cmd.length = 0x20 + dlci_offset*2;
4988 mbox->cmd.command = FR_SET_CONFIG;
4991 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4994 fr_event(card, err, mbox);
4998 initialize_rx_tx_buffers (card);
5001 printk(KERN_INFO "Configuraiton Succeded for new DLCI %i\n",dlci_num);
5003 if (fr_comm_enable (card)){
5007 printk(KERN_INFO "Enabling Communications \n");
5009 for (dev = card->wandev.dev; dev;
5010 dev = *((struct net_device **)dev->priv)) {
5011 fr_channel_t *chan_tmp = dev->priv;
5012 fr_init_dlci(card,chan_tmp);
5013 fr_add_dlci(card, chan_tmp->dlci);
5014 fr_activate_dlci(card, chan_tmp->dlci);
5017 printk(KERN_INFO "END OF CONFIGURAITON %i\n",dlci_num);
5022 static void initialize_rx_tx_buffers (sdla_t *card)
5024 fr_buf_info_t* buf_info;
5026 if (card->hw.type == SDLA_S514) {
5028 buf_info = (void*)(card->hw.dpmbase + FR_MB_VECTOR +
5031 card->rxmb = (void*)(buf_info->rse_next + card->hw.dpmbase);
5033 card->u.f.rxmb_base =
5034 (void*)(buf_info->rse_base + card->hw.dpmbase);
5036 card->u.f.rxmb_last =
5037 (void*)(buf_info->rse_base +
5038 (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) +
5041 buf_info = (void*)(card->hw.dpmbase + FR508_RXBC_OFFS);
5043 card->rxmb = (void*)(buf_info->rse_next -
5044 FR_MB_VECTOR + card->hw.dpmbase);
5046 card->u.f.rxmb_base =
5047 (void*)(buf_info->rse_base -
5048 FR_MB_VECTOR + card->hw.dpmbase);
5050 card->u.f.rxmb_last =
5051 (void*)(buf_info->rse_base +
5052 (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) -
5053 FR_MB_VECTOR + card->hw.dpmbase);
5056 card->u.f.rx_base = buf_info->buf_base;
5057 card->u.f.rx_top = buf_info->buf_top;
5059 card->u.f.tx_interrupts_pending = 0;
5066 MODULE_LICENSE("GPL");
5068 /****** End *****************************************************************/
projects / linux-2.6 / blob