File: /usr/src/linux/drivers/net/wan/sdla_fr.c
1 /*****************************************************************************
2 * sdla_fr.c WANPIPE(tm) Multiprotocol WAN Link Driver. Frame relay module.
3 *
4 * Author(s): Nenad Corbic <ncorbic@sangoma.com>
5 * Gideon Hack
6 *
7 * Copyright: (c) 1995-2001 Sangoma Technologies Inc.
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version
12 * 2 of the License, or (at your option) any later version.
13 * ============================================================================
14 * Nov 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
34 * interface setups.
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
43 *
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
49 * signalling.
50 * o Took out IPX support, implement in next
51 * version
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
74 * testing.
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
80 * Driver Statistics.
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)
108 * forever.
109 * The code got into this stage due to an
110 * interrupt occuring 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
119 * structure.
120 * May 21, 1997 Jaspreet Singh o Fixed UDP Management for multiple
121 * boards.
122 *
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
131 * returning 0
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_
137 * mode
138 * Jan 02, 1997 Gene Kozin Initial version.
139 *****************************************************************************/
140
141 #include <linux/module.h>
142 #include <linux/version.h>
143 #include <linux/kernel.h> /* printk(), and other useful stuff */
144 #include <linux/stddef.h> /* offsetof(), etc. */
145 #include <linux/errno.h> /* return codes */
146 #include <linux/string.h> /* inline memset(), etc. */
147 #include <linux/slab.h> /* kmalloc(), kfree() */
148 #include <linux/wanrouter.h> /* WAN router definitions */
149 #include <linux/wanpipe.h> /* WANPIPE common user API definitions */
150 #include <linux/if_arp.h> /* ARPHRD_* defines */
151 #include <asm/byteorder.h> /* htons(), etc. */
152 #include <asm/io.h> /* for inb(), outb(), etc. */
153 #include <linux/time.h> /* for do_gettimeofday */
154 #include <linux/in.h> /* sockaddr_in */
155 #include <linux/inet.h> /* in_ntoa(), etc... */
156 #include <asm/errno.h>
157
158 #include <linux/ip.h>
159 #include <linux/if.h>
160
161 #include <linux/if_wanpipe_common.h> /* Wanpipe Socket */
162 #include <linux/if_wanpipe.h>
163
164 #include <linux/sdla_fr.h> /* frame relay firmware API definitions */
165
166 #if defined(LINUX_2_1) || defined(LINUX_2_4)
167 #include <asm/uaccess.h>
168 #include <linux/inetdevice.h>
169 #include <linux/netdevice.h>
170
171 #else
172 #include <asm/segment.h>
173 #endif
174
175 #include <net/route.h> /* Dynamic Route Creation */
176 #include <linux/etherdevice.h> /* eth_type_trans() used for bridging */
177 #include <linux/random.h>
178
179 /****** Defines & Macros ****************************************************/
180
181 #define MAX_CMD_RETRY 10 /* max number of firmware retries */
182
183 #define FR_HEADER_LEN 8 /* max encapsulation header size */
184 #define FR_CHANNEL_MTU 1500 /* unfragmented logical channel MTU */
185
186 /* Q.922 frame types */
187 #define Q922_UI 0x03 /* Unnumbered Info frame */
188 #define Q922_XID 0xAF
189
190 /* DLCI configured or not */
191 #define DLCI_NOT_CONFIGURED 0x00
192 #define DLCI_CONFIG_PENDING 0x01
193 #define DLCI_CONFIGURED 0x02
194
195 /* CIR enabled or not */
196 #define CIR_ENABLED 0x00
197 #define CIR_DISABLED 0x01
198
199 #define FRAME_RELAY_API 1
200 #define MAX_BH_BUFF 10
201
202 /* For handle_IPXWAN() */
203 #define CVHexToAscii(b) (((unsigned char)(b) > (unsigned char)9) ? ((unsigned char)'A' + ((unsigned char)(b) - (unsigned char)10)) : ((unsigned char)'0' + (unsigned char)(b)))
204
205 /****** Data Structures *****************************************************/
206
207 /* This is an extention of the 'struct device' we create for each network
208 * interface to keep the rest of channel-specific data.
209 */
210 typedef struct fr_channel
211 {
212 wanpipe_common_t common;
213 char name[WAN_IFNAME_SZ+1]; /* interface name, ASCIIZ */
214 unsigned dlci_configured ; /* check whether configured or not */
215 unsigned cir_status; /* check whether CIR enabled or not */
216 unsigned dlci; /* logical channel number */
217 unsigned cir; /* committed information rate */
218 unsigned bc; /* committed burst size */
219 unsigned be; /* excess burst size */
220 unsigned mc; /* multicast support on or off */
221 unsigned tx_int_status; /* Transmit Interrupt Status */
222 unsigned short pkt_length; /* Packet Length */
223 unsigned long router_start_time;/* Router start time in seconds */
224 unsigned long tick_counter; /* counter for transmit time out */
225 char dev_pending_devtint; /* interface pending dev_tint() */
226 void *dlci_int_interface; /* pointer to the DLCI Interface */
227 unsigned long IB_addr; /* physical address of Interface Byte */
228 unsigned long state_tick; /* time of the last state change */
229 unsigned char enable_IPX; /* Enable/Disable the use of IPX */
230 unsigned long network_number; /* Internal Network Number for IPX*/
231 sdla_t *card; /* -> owner */
232 unsigned route_flag; /* Add/Rem dest addr in route tables */
233 unsigned inarp; /* Inverse Arp Request status */
234 unsigned char inarp_ready; /* Ready to send requests */
235 int inarp_interval; /* Time between InArp Requests */
236 unsigned long inarp_tick; /* InArp jiffies tick counter */
237 unsigned char interface_down; /* Bring interface down on disconnect */
238 #if defined(LINUX_2_1) || defined(LINUX_2_4)
239 struct net_device_stats ifstats; /* interface statistics */
240 #else
241 struct enet_statistics ifstats;
242 #endif
243 if_send_stat_t drvstats_if_send;
244 rx_intr_stat_t drvstats_rx_intr;
245 pipe_mgmt_stat_t drvstats_gen;
246 unsigned long router_up_time;
247
248 unsigned short transmit_length;
249 struct sk_buff *delay_skb;
250
251
252 #if defined(LINUX_2_1) || defined(LINUX_2_4)
253 bh_data_t *bh_head; /* Circular buffer for chdlc_bh */
254 unsigned long tq_working;
255 volatile int bh_write;
256 volatile int bh_read;
257 atomic_t bh_buff_used;
258 #endif
259
260 /* Polling task queue. Each interface
261 * has its own task queue, which is used
262 * to defer events from the interrupt */
263 struct tq_struct fr_poll_task;
264 struct timer_list fr_arp_timer;
265
266 u32 ip_local;
267 u32 ip_remote;
268 u8 config_dlci;
269 u32 unconfig_dlci;
270
271 /* Whether this interface should be setup as a gateway.
272 * Used by dynamic route setup code */
273 u8 gateway;
274
275 /* True interface type */
276 u8 true_if_encoding;
277 u8 fr_header[FR_HEADER_LEN];
278 char fr_header_len;
279
280 } fr_channel_t;
281
282 /* Route Flag options */
283 #define NO_ROUTE 0x00
284 #define ADD_ROUTE 0x01
285 #define ROUTE_ADDED 0x02
286 #define REMOVE_ROUTE 0x03
287 #define ARP_REQ 0x04
288
289 /* inarp options */
290 #define INARP_NONE 0x00
291 #define INARP_REQUEST 0x01
292 #define INARP_CONFIGURED 0x02
293
294 /* reasons for enabling the timer interrupt on the adapter */
295 #define TMR_INT_ENABLED_UDP 0x01
296 #define TMR_INT_ENABLED_UPDATE 0x02
297 #define TMR_INT_ENABLED_ARP 0x04
298 #define TMR_INT_ENABLED_UPDATE_STATE 0x08
299 #define TMR_INT_ENABLED_CONFIG 0x10
300 #define TMR_INT_ENABLED_UNCONFIG 0x20
301
302
303 typedef struct dlci_status
304 {
305 unsigned short dlci PACKED;
306 unsigned char state PACKED;
307 } dlci_status_t;
308
309 typedef struct dlci_IB_mapping
310 {
311 unsigned short dlci PACKED;
312 unsigned long addr_value PACKED;
313 } dlci_IB_mapping_t;
314
315 /* This structure is used for DLCI list Tx interrupt mode. It is used to
316 enable interrupt bit and set the packet length for transmission
317 */
318 typedef struct fr_dlci_interface
319 {
320 unsigned char gen_interrupt PACKED;
321 unsigned short packet_length PACKED;
322 unsigned char reserved PACKED;
323 } fr_dlci_interface_t;
324
325 /* variable for keeping track of enabling/disabling FT1 monitor status */
326 static int rCount = 0;
327
328 extern void disable_irq(unsigned int);
329 extern void enable_irq(unsigned int);
330
331 /* variable for keeping track of number of interrupts generated during
332 * interrupt test routine
333 */
334 static int Intr_test_counter;
335
336 /****** Function Prototypes *************************************************/
337
338 /* WAN link driver entry points. These are called by the WAN router module. */
339 static int update(wan_device_t *wandev);
340 static int new_if(wan_device_t *wandev, netdevice_t *dev, wanif_conf_t *conf);
341 static int del_if(wan_device_t *wandev, netdevice_t *dev);
342 static void disable_comm (sdla_t *card);
343
344 /* WANPIPE-specific entry points */
345 static int wpf_exec(struct sdla *card, void *u_cmd, void *u_data);
346
347 /* Network device interface */
348 static int if_init(netdevice_t *dev);
349 static int if_open(netdevice_t *dev);
350 static int if_close(netdevice_t *dev);
351
352
353 #ifdef LINUX_2_4
354 static void if_tx_timeout (netdevice_t *dev);
355 #endif
356
357 #if defined(LINUX_2_1) || defined(LINUX_2_4)
358 static int if_rebuild_hdr (struct sk_buff *skb);
359 #else
360 static int if_rebuild_hdr (void* hdr, netdevice_t* dev, unsigned long raddr,
361 struct sk_buff* skb);
362 #endif
363
364 static int if_send(struct sk_buff *skb, netdevice_t *dev);
365 static int chk_bcast_mcast_addr(sdla_t *card, netdevice_t* dev,
366 struct sk_buff *skb);
367 #if defined(LINUX_2_1) || defined(LINUX_2_4)
368 static struct net_device_stats *if_stats(netdevice_t *dev);
369 #else
370 static struct enet_statistics* if_stats (netdevice_t* dev);
371 #endif
372
373 /* Interrupt handlers */
374 static void fr_isr(sdla_t *card);
375 static void rx_intr(sdla_t *card);
376 static void tx_intr(sdla_t *card);
377 static void timer_intr(sdla_t *card);
378 static void spur_intr(sdla_t *card);
379
380 /* Frame relay firmware interface functions */
381 static int fr_read_version(sdla_t *card, char *str);
382 static int fr_configure(sdla_t *card, fr_conf_t *conf);
383 static int fr_dlci_configure(sdla_t *card, fr_dlc_conf_t *conf, unsigned dlci);
384 static int fr_init_dlci (sdla_t *card, fr_channel_t *chan);
385 static int fr_set_intr_mode (sdla_t *card, unsigned mode, unsigned mtu, unsigned short timeout);
386 static int fr_comm_enable(sdla_t *card);
387 static void fr_comm_disable(sdla_t *card);
388 static int fr_get_err_stats(sdla_t *card);
389 static int fr_get_stats(sdla_t *card);
390 static int fr_add_dlci(sdla_t *card, int dlci);
391 static int fr_activate_dlci(sdla_t *card, int dlci);
392 static int fr_delete_dlci (sdla_t* card, int dlci);
393 static int fr_issue_isf(sdla_t *card, int isf);
394 static int fr_send(sdla_t *card, int dlci, unsigned char attr, int len,
395 void *buf);
396 static int fr_send_data_header(sdla_t *card, int dlci, unsigned char attr, int len,
397 void *buf,unsigned char hdr_len);
398 static unsigned int fr_send_hdr(sdla_t *card, int dlci, unsigned int offset);
399
400 static int check_dlci_config (sdla_t *card, fr_channel_t *chan);
401 static void initialize_rx_tx_buffers (sdla_t *card);
402
403
404 /* Firmware asynchronous event handlers */
405 static int fr_event(sdla_t *card, int event, fr_mbox_t *mbox);
406 static int fr_modem_failure(sdla_t *card, fr_mbox_t *mbox);
407 static int fr_dlci_change(sdla_t *card, fr_mbox_t *mbox);
408
409 /* Miscellaneous functions */
410 static int update_chan_state(netdevice_t *dev);
411 static void set_chan_state(netdevice_t *dev, int state);
412 static netdevice_t *find_channel(sdla_t *card, unsigned dlci);
413 static int is_tx_ready(sdla_t *card, fr_channel_t *chan);
414 static unsigned int dec_to_uint(unsigned char *str, int len);
415 static int reply_udp( unsigned char *data, unsigned int mbox_len );
416
417 static int intr_test( sdla_t* card );
418 static void init_chan_statistics( fr_channel_t* chan );
419 static void init_global_statistics( sdla_t* card );
420 static void read_DLCI_IB_mapping( sdla_t* card, fr_channel_t* chan );
421 static int setup_for_delayed_transmit(netdevice_t* dev, struct sk_buff *skb);
422
423 netdevice_t * move_dev_to_next (sdla_t *, netdevice_t *);
424 static int check_tx_status(sdla_t *, netdevice_t *);
425
426 #if defined(LINUX_2_1) || defined(LINUX_2_4)
427 /* Frame Relay Socket API */
428 static void trigger_fr_bh (fr_channel_t *);
429 static void fr_bh (netdevice_t *);
430 static int fr_bh_cleanup (netdevice_t *);
431 static int bh_enqueue (netdevice_t *, struct sk_buff *);
432 #endif
433
434 static void trigger_fr_poll (netdevice_t *);
435 static void fr_poll (netdevice_t *);
436 //static void add_gateway (netdevice_t *);
437
438 static void trigger_unconfig_fr (netdevice_t *dev);
439 static void unconfig_fr (sdla_t *);
440
441 static void trigger_config_fr (sdla_t *);
442 static void config_fr (sdla_t *);
443
444
445 /* Inverse ARP and Dynamic routing functions */
446 int process_ARP(arphdr_1490_t *ArpPacket, sdla_t *card, netdevice_t *dev);
447 int is_arp(void *buf);
448 int send_inarp_request(sdla_t *card, netdevice_t *dev);
449
450 static void trigger_fr_arp (netdevice_t *);
451 static void fr_arp (unsigned long data);
452
453
454 /* Udp management functions */
455 static int process_udp_mgmt_pkt(sdla_t *card);
456 static int udp_pkt_type( struct sk_buff *skb, sdla_t *card );
457 static int store_udp_mgmt_pkt(int udp_type, char udp_pkt_src, sdla_t* card,
458 struct sk_buff *skb, int dlci);
459
460 /* IPX functions */
461 static void switch_net_numbers(unsigned char *sendpacket,
462 unsigned long network_number, unsigned char incoming);
463
464 static int handle_IPXWAN(unsigned char *sendpacket, char *devname,
465 unsigned char enable_IPX, unsigned long network_number);
466
467 /* Lock Functions: SMP supported */
468 void s508_s514_unlock(sdla_t *card, unsigned long *smp_flags);
469 void s508_s514_lock(sdla_t *card, unsigned long *smp_flags);
470
471 unsigned short calc_checksum (char *, int);
472 static int setup_fr_header(struct sk_buff** skb, netdevice_t* dev, char op_mode);
473
474
475 /****** Public Functions ****************************************************/
476
477 /*============================================================================
478 * Frame relay protocol initialization routine.
479 *
480 * This routine is called by the main WANPIPE module during setup. At this
481 * point adapter is completely initialized and firmware is running.
482 * o read firmware version (to make sure it's alive)
483 * o configure adapter
484 * o initialize protocol-specific fields of the adapter data space.
485 *
486 * Return: 0 o.k.
487 * < 0 failure.
488 */
489 int wpf_init(sdla_t *card, wandev_conf_t *conf)
490 {
491
492 int err;
493 fr508_flags_t* flags;
494
495 union
496 {
497 char str[80];
498 fr_conf_t cfg;
499 } u;
500
501 fr_buf_info_t* buf_info;
502 int i;
503
504
505 printk(KERN_INFO "\n");
506
507 /* Verify configuration ID */
508 if (conf->config_id != WANCONFIG_FR) {
509
510 printk(KERN_INFO "%s: invalid configuration ID %u!\n",
511 card->devname, conf->config_id);
512 return -EINVAL;
513
514 }
515
516 /* Initialize protocol-specific fields of adapter data space */
517 switch (card->hw.fwid) {
518
519 case SFID_FR508:
520 card->mbox = (void*)(card->hw.dpmbase +
521 FR508_MBOX_OFFS);
522 card->flags = (void*)(card->hw.dpmbase +
523 FR508_FLAG_OFFS);
524 if(card->hw.type == SDLA_S514) {
525 card->mbox += FR_MB_VECTOR;
526 card->flags += FR_MB_VECTOR;
527 }
528 card->isr = &fr_isr;
529 break;
530
531 default:
532 return -EINVAL;
533 }
534
535 flags = card->flags;
536
537 /* Read firmware version. Note that when adapter initializes, it
538 * clears the mailbox, so it may appear that the first command was
539 * executed successfully when in fact it was merely erased. To work
540 * around this, we execute the first command twice.
541 */
542
543 if (fr_read_version(card, NULL) || fr_read_version(card, u.str))
544 return -EIO;
545
546 printk(KERN_INFO "%s: running frame relay firmware v%s\n",
547 card->devname, u.str);
548
549 /* Adjust configuration */
550 conf->mtu += FR_HEADER_LEN;
551 conf->mtu = (conf->mtu >= MIN_LGTH_FR_DATA_CFG) ?
552 min_t(unsigned int, conf->mtu, FR_MAX_NO_DATA_BYTES_IN_FRAME) :
553 FR_CHANNEL_MTU + FR_HEADER_LEN;
554
555 conf->bps = min_t(unsigned int, conf->bps, 2048000);
556
557 /* Initialze the configuration structure sent to the board to zero */
558 memset(&u.cfg, 0, sizeof(u.cfg));
559
560 memset(card->u.f.dlci_to_dev_map, 0, sizeof(card->u.f.dlci_to_dev_map));
561
562 /* Configure adapter firmware */
563
564 u.cfg.mtu = conf->mtu;
565 u.cfg.kbps = conf->bps / 1000;
566
567 u.cfg.cir_fwd = u.cfg.cir_bwd = 16;
568 u.cfg.bc_fwd = u.cfg.bc_bwd = 16;
569
570 u.cfg.options = 0x0000;
571 printk(KERN_INFO "%s: Global CIR enabled by Default\n", card->devname);
572
573 switch (conf->u.fr.signalling) {
574
575 case WANOPT_FR_ANSI:
576 u.cfg.options = 0x0000;
577 break;
578
579 case WANOPT_FR_Q933:
580 u.cfg.options |= 0x0200;
581 break;
582
583 case WANOPT_FR_LMI:
584 u.cfg.options |= 0x0400;
585 break;
586
587 case WANOPT_NO:
588 u.cfg.options |= 0x0800;
589 break;
590 default:
591 printk(KERN_INFO "%s: Illegal Signalling option\n",
592 card->wandev.name);
593 return -EINVAL;
594 }
595
596
597 card->wandev.signalling = conf->u.fr.signalling;
598
599 if (conf->station == WANOPT_CPE) {
600
601
602 if (conf->u.fr.signalling == WANOPT_NO){
603 printk(KERN_INFO
604 "%s: ERROR - For NO signalling, station must be set to Node!",
605 card->devname);
606 return -EINVAL;
607 }
608
609 u.cfg.station = 0;
610 u.cfg.options |= 0x8000; /* auto config DLCI */
611 card->u.f.dlci_num = 0;
612
613 } else {
614
615 u.cfg.station = 1; /* switch emulation mode */
616
617 /* For switch emulation we have to create a list of dlci(s)
618 * that will be sent to be global SET_DLCI_CONFIGURATION
619 * command in fr_configure() routine.
620 */
621
622 card->u.f.dlci_num = min_t(unsigned int, max_t(unsigned int, conf->u.fr.dlci_num, 1), 100);
623
624 for ( i = 0; i < card->u.f.dlci_num; i++) {
625
626 card->u.f.node_dlci[i] = (unsigned short)
627 conf->u.fr.dlci[i] ? conf->u.fr.dlci[i] : 16;
628
629 }
630 }
631
632 if (conf->clocking == WANOPT_INTERNAL)
633 u.cfg.port |= 0x0001;
634
635 if (conf->interface == WANOPT_RS232)
636 u.cfg.port |= 0x0002;
637
638 if (conf->u.fr.t391)
639 u.cfg.t391 = min_t(unsigned int, conf->u.fr.t391, 30);
640 else
641 u.cfg.t391 = 5;
642
643 if (conf->u.fr.t392)
644 u.cfg.t392 = min_t(unsigned int, conf->u.fr.t392, 30);
645 else
646 u.cfg.t392 = 15;
647
648 if (conf->u.fr.n391)
649 u.cfg.n391 = min_t(unsigned int, conf->u.fr.n391, 255);
650 else
651 u.cfg.n391 = 2;
652
653 if (conf->u.fr.n392)
654 u.cfg.n392 = min_t(unsigned int, conf->u.fr.n392, 10);
655 else
656 u.cfg.n392 = 3;
657
658 if (conf->u.fr.n393)
659 u.cfg.n393 = min_t(unsigned int, conf->u.fr.n393, 10);
660 else
661 u.cfg.n393 = 4;
662
663 if (fr_configure(card, &u.cfg))
664 return -EIO;
665
666 if (card->hw.type == SDLA_S514) {
667
668 buf_info = (void*)(card->hw.dpmbase + FR_MB_VECTOR +
669 FR508_RXBC_OFFS);
670
671 card->rxmb = (void*)(buf_info->rse_next + card->hw.dpmbase);
672
673 card->u.f.rxmb_base =
674 (void*)(buf_info->rse_base + card->hw.dpmbase);
675
676 card->u.f.rxmb_last =
677 (void*)(buf_info->rse_base +
678 (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) +
679 card->hw.dpmbase);
680 }else{
681 buf_info = (void*)(card->hw.dpmbase + FR508_RXBC_OFFS);
682
683 card->rxmb = (void*)(buf_info->rse_next -
684 FR_MB_VECTOR + card->hw.dpmbase);
685
686 card->u.f.rxmb_base =
687 (void*)(buf_info->rse_base -
688 FR_MB_VECTOR + card->hw.dpmbase);
689
690 card->u.f.rxmb_last =
691 (void*)(buf_info->rse_base +
692 (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) -
693 FR_MB_VECTOR + card->hw.dpmbase);
694 }
695
696 card->u.f.rx_base = buf_info->buf_base;
697 card->u.f.rx_top = buf_info->buf_top;
698
699 card->u.f.tx_interrupts_pending = 0;
700
701 card->wandev.mtu = conf->mtu;
702 card->wandev.bps = conf->bps;
703 card->wandev.interface = conf->interface;
704 card->wandev.clocking = conf->clocking;
705 card->wandev.station = conf->station;
706 card->poll = NULL;
707 card->exec = &wpf_exec;
708 card->wandev.update = &update;
709 card->wandev.new_if = &new_if;
710 card->wandev.del_if = &del_if;
711 card->wandev.state = WAN_DISCONNECTED;
712 card->wandev.ttl = conf->ttl;
713 card->wandev.udp_port = conf->udp_port;
714 card->disable_comm = &disable_comm;
715 card->u.f.arp_dev = NULL;
716
717 /* Intialize global statistics for a card */
718 init_global_statistics( card );
719
720 card->TracingEnabled = 0;
721
722 /* Interrupt Test */
723 Intr_test_counter = 0;
724 card->intr_mode = INTR_TEST_MODE;
725 err = intr_test( card );
726
727 printk(KERN_INFO "%s: End of Interrupt Test rc=0x%x count=%i\n",
728 card->devname,err,Intr_test_counter);
729
730 if (err || (Intr_test_counter < MAX_INTR_TEST_COUNTER)) {
731 printk(KERN_ERR "%s: Interrupt Test Failed, Counter: %i\n",
732 card->devname, Intr_test_counter);
733 printk(KERN_ERR "Please choose another interrupt\n");
734 err = -EIO;
735 return err;
736 }
737
738 printk(KERN_INFO "%s: Interrupt Test Passed, Counter: %i\n",
739 card->devname, Intr_test_counter);
740
741
742 /* Apr 28 2000. Nenad Corbic
743 * Enable commnunications here, not in if_open or new_if, since
744 * interfaces come down when the link is disconnected.
745 */
746
747 /* If you enable comms and then set ints, you get a Tx int as you
748 * perform the SET_INT_TRIGGERS command. So, we only set int
749 * triggers and then adjust the interrupt mask (to disable Tx ints)
750 * before enabling comms.
751 */
752 if (fr_set_intr_mode(card, (FR_INTR_RXRDY | FR_INTR_TXRDY |
753 FR_INTR_DLC | FR_INTR_TIMER | FR_INTR_TX_MULT_DLCIs) ,
754 card->wandev.mtu, 0)) {
755 return -EIO;
756 }
757
758 flags->imask &= ~(FR_INTR_TXRDY | FR_INTR_TIMER);
759
760 if (fr_comm_enable(card)) {
761 return -EIO;
762 }
763 wanpipe_set_state(card, WAN_CONNECTED);
764 spin_lock_init(&card->u.f.if_send_lock);
765
766 printk(KERN_INFO "\n");
767
768 return 0;
769 }
770
771 /******* WAN Device Driver Entry Points *************************************/
772
773 /*============================================================================
774 * Update device status & statistics.
775 */
776 static int update (wan_device_t* wandev)
777 {
778 volatile sdla_t* card;
779 unsigned long timeout;
780 fr508_flags_t* flags;
781
782 /* sanity checks */
783 if ((wandev == NULL) || (wandev->private == NULL))
784 return -EFAULT;
785
786 if (wandev->state == WAN_UNCONFIGURED)
787 return -ENODEV;
788
789 card = wandev->private;
790 flags = card->flags;
791
792
793 card->u.f.update_comms_stats = 1;
794 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UPDATE;
795 flags->imask |= FR_INTR_TIMER;
796 timeout = jiffies;
797 for(;;) {
798 if(card->u.f.update_comms_stats == 0)
799 break;
800 if ((jiffies - timeout) > (1 * HZ)){
801 card->u.f.update_comms_stats = 0;
802 return -EAGAIN;
803 }
804 }
805
806 return 0;
807 }
808
809 /*============================================================================
810 * Create new logical channel.
811 * This routine is called by the router when ROUTER_IFNEW IOCTL is being
812 * handled.
813 * o parse media- and hardware-specific configuration
814 * o make sure that a new channel can be created
815 * o allocate resources, if necessary
816 * o prepare network device structure for registaration.
817 *
818 * Return: 0 o.k.
819 * < 0 failure (channel will not be created)
820 */
821 static int new_if (wan_device_t* wandev, netdevice_t* dev, wanif_conf_t* conf)
822 {
823 sdla_t* card = wandev->private;
824 fr_channel_t* chan;
825 int dlci = 0;
826 int err = 0;
827
828
829 if ((conf->name[0] == '\0') || (strlen(conf->name) > WAN_IFNAME_SZ)) {
830
831 printk(KERN_INFO "%s: Invalid interface name!\n",
832 card->devname);
833 return -EINVAL;
834 }
835
836 /* allocate and initialize private data */
837 chan = kmalloc(sizeof(fr_channel_t), GFP_KERNEL);
838
839 if (chan == NULL)
840 return -ENOMEM;
841
842 memset(chan, 0, sizeof(fr_channel_t));
843 strcpy(chan->name, conf->name);
844 chan->card = card;
845
846 /* verify media address */
847 if (is_digit(conf->addr[0])) {
848
849 dlci = dec_to_uint(conf->addr, 0);
850
851 if (dlci && (dlci <= HIGHEST_VALID_DLCI)) {
852
853 chan->dlci = dlci;
854
855 } else {
856
857 printk(KERN_ERR
858 "%s: Invalid DLCI %u on interface %s!\n",
859 wandev->name, dlci, chan->name);
860 err = -EINVAL;
861 }
862
863 } else {
864 printk(KERN_ERR
865 "%s: Invalid media address on interface %s!\n",
866 wandev->name, chan->name);
867 err = -EINVAL;
868 }
869
870 if ((chan->true_if_encoding = conf->true_if_encoding) == WANOPT_YES){
871 printk(KERN_INFO
872 "%s: Enabling, true interface type encoding.\n",
873 card->devname);
874 }
875
876
877
878 /* Setup wanpipe as a router (WANPIPE) even if it is
879 * a bridged DLCI, or as an API
880 */
881 if (strcmp(conf->usedby, "WANPIPE") == 0 ||
882 strcmp(conf->usedby, "BRIDGE") == 0 ||
883 strcmp(conf->usedby, "BRIDGE_N") == 0){
884
885 if(strcmp(conf->usedby, "WANPIPE") == 0){
886 chan->common.usedby = WANPIPE;
887
888 printk(KERN_INFO "%s: Running in WANPIPE mode.\n",
889 card->devname);
890
891 }else if(strcmp(conf->usedby, "BRIDGE") == 0){
892
893 chan->common.usedby = BRIDGE;
894
895 #if defined(LINUX_2_1) || defined(LINUX_2_4)
896 printk(KERN_INFO "%s: Running in WANPIPE (BRIDGE) mode.\n",
897 card->devname);
898 #else
899 printk(KERN_INFO "%s: WANPIPE Bridging mode not supported in 2.0.X kernels.\n",
900 card->devname);
901 err = -EPROTONOSUPPORT;
902 #endif
903 }else if( strcmp(conf->usedby, "BRIDGE_N") == 0 ){
904
905 chan->common.usedby = BRIDGE_NODE;
906
907 #if defined(LINUX_2_1) || defined(LINUX_2_4)
908 printk(KERN_INFO "%s: Running in WANPIPE (BRIDGE_NODE) mode.\n",
909 card->devname);
910 #else
911 printk(KERN_INFO "%s: WANPIPE Bridging mode not supported in 2.0.X kernels.\n",
912 card->devname);
913 err = -EPROTONOSUPPORT;
914 #endif
915 }
916
917 if (!err){
918 /* Dynamic interface configuration option.
919 * On disconnect, if the options is selected,
920 * the interface will be brought down */
921 if (conf->if_down == WANOPT_YES){
922 set_bit(DYN_OPT_ON,&chan->interface_down);
923 printk(KERN_INFO
924 "%s: Dynamic interface configuration enabled.\n",
925 card->devname);
926 }
927 }
928
929 } else if(strcmp(conf->usedby, "API") == 0){
930
931 #if defined(LINUX_2_1) || defined(LINUX_2_4)
932 chan->common.usedby = API;
933 printk(KERN_INFO "%s: Running in API mode.\n",
934 wandev->name);
935 #else
936 printk(KERN_INFO "%s: The API Mode is not supported for"
937 "kernels lower than 2.2.X !\n",
938 wandev->name);
939 printk(KERN_INFO "%s: Please upgrade to a 2.2.X kernel for the API support\n",
940 wandev->name);
941 err = -EINVAL;
942 #endif
943 }
944
945 if (err) {
946
947 kfree(chan);
948 return err;
949 }
950
951 /* place cir,be,bc and other channel specific information into the
952 * chan structure
953 */
954 if (conf->cir) {
955
956 chan->cir = max_t(unsigned int, 1,
957 min_t(unsigned int, conf->cir, 512));
958 chan->cir_status = CIR_ENABLED;
959
960
961 /* If CIR is enabled, force BC to equal CIR
962 * this solves number of potential problems if CIR is
963 * set and BC is not
964 */
965 chan->bc = chan->cir;
966
967 if (conf->be){
968 chan->be = max_t(unsigned int,
969 0, min_t(unsigned int, conf->be, 511));
970 }else{
971 conf->be = 0;
972 }
973
974 printk (KERN_INFO "%s: CIR enabled for DLCI %i \n",
975 wandev->name,chan->dlci);
976 printk (KERN_INFO "%s: CIR = %i ; BC = %i ; BE = %i\n",
977 wandev->name,chan->cir,chan->bc,chan->be);
978
979
980 }else{
981 chan->cir_status = CIR_DISABLED;
982 printk (KERN_INFO "%s: CIR disabled for DLCI %i\n",
983 wandev->name,chan->dlci);
984 }
985
986 chan->mc = conf->mc;
987
988 if (conf->inarp == WANOPT_YES){
989 #if defined(LINUX_2_1) || defined(LINUX_2_4)
990 printk(KERN_INFO "%s: Inverse ARP Support Enabled\n",card->devname);
991 chan->inarp = conf->inarp ? INARP_REQUEST : INARP_NONE;
992 chan->inarp_interval = conf->inarp_interval ? conf->inarp_interval : 10;
993 #else
994 printk(KERN_INFO "%s: Warning, Inverse ARP Support not available for 2.0.X kernels!\n",
995 card->devname);
996 chan->inarp = INARP_NONE;
997 chan->inarp_interval = 10;
998 #endif
999 }else{
1000 printk(KERN_INFO "%s: Inverse ARP Support Disabled\n",card->devname);
1001 chan->inarp = INARP_NONE;
1002 chan->inarp_interval = 10;
1003 }
1004
1005
1006 chan->dlci_configured = DLCI_NOT_CONFIGURED;
1007
1008
1009 /*FIXME: IPX disabled in this WANPIPE version */
1010 if (conf->enable_IPX == WANOPT_YES){
1011 printk(KERN_INFO "%s: ERROR - This version of WANPIPE doesn't support IPX\n",
1012 card->devname);
1013 kfree(chan);
1014 return -EINVAL;
1015 }else{
1016 chan->enable_IPX = WANOPT_NO;
1017 }
1018
1019 if (conf->network_number){
1020 chan->network_number = conf->network_number;
1021 }else{
1022 chan->network_number = 0xDEADBEEF;
1023 }
1024
1025 chan->route_flag = NO_ROUTE;
1026
1027 init_chan_statistics(chan);
1028
1029 chan->transmit_length = 0;
1030
1031 /* prepare network device data space for registration */
1032 #ifdef LINUX_2_4
1033 strcpy(dev->name,chan->name);
1034 #else
1035 dev->name = (char *)kmalloc(strlen(chan->name) + 2, GFP_KERNEL);
1036 if(dev->name == NULL)
1037 {
1038 kfree(chan);
1039 return -ENOMEM;
1040 }
1041 sprintf(dev->name, "%s", chan->name);
1042 #endif
1043
1044 dev->init = &if_init;
1045 dev->priv = chan;
1046
1047 /* Initialize FR Polling Task Queue
1048 * We need a poll routine for each network
1049 * interface.
1050 */
1051 #ifndef LINUX_2_4
1052 chan->fr_poll_task.next = NULL;
1053 #endif
1054 chan->fr_poll_task.sync = 0;
1055 chan->fr_poll_task.routine = (void *)(void *)fr_poll;
1056 chan->fr_poll_task.data = dev;
1057
1058 init_timer(&chan->fr_arp_timer);
1059 chan->fr_arp_timer.data=(unsigned long)dev;
1060 chan->fr_arp_timer.function = fr_arp;
1061
1062 wandev->new_if_cnt++;
1063
1064 /* Tells us that if this interface is a
1065 * gateway or not */
1066 if ((chan->gateway = conf->gateway) == WANOPT_YES){
1067 printk(KERN_INFO "%s: Interface %s is set as a gateway.\n",
1068 card->devname,dev->name);
1069 }
1070
1071 /* M. Grant Patch Apr 28 2000
1072 * Disallow duplicate dlci configurations. */
1073 if (card->u.f.dlci_to_dev_map[chan->dlci] != NULL) {
1074 kfree(chan);
1075 return -EBUSY;
1076 }
1077
1078 /* Configure this dlci at a later date, when
1079 * the interface comes up. i.e. when if_open()
1080 * executes */
1081 set_bit(0,&chan->config_dlci);
1082
1083 printk(KERN_INFO "\n");
1084
1085 return 0;
1086 }
1087
1088 /*============================================================================
1089 * Delete logical channel.
1090 */
1091 static int del_if (wan_device_t* wandev, netdevice_t* dev)
1092 {
1093 fr_channel_t* chan = dev->priv;
1094 unsigned long smp_flags=0;
1095
1096 /* This interface is dead, make sure the
1097 * ARP timer is stopped */
1098 del_timer(&chan->fr_arp_timer);
1099
1100 /* If we are a NODE, we must unconfigure this DLCI
1101 * Trigger an unconfigure command that will
1102 * be executed in timer interrupt. We must wait
1103 * for the command to complete. */
1104 trigger_unconfig_fr(dev);
1105
1106 lock_adapter_irq(&wandev->lock, &smp_flags);
1107 wandev->new_if_cnt--;
1108 unlock_adapter_irq(&wandev->lock, &smp_flags);
1109
1110 return 0;
1111 }
1112
1113
1114 /*=====================================================================
1115 * disable_comm
1116 *
1117 * Description:
1118 * Disable communications.
1119 * This code runs in shutdown (sdlamain.c)
1120 * under critical flag. Therefore it is not
1121 * necessary to set a critical flag here
1122 *
1123 * Usage:
1124 * Commnunications are disabled only on a card
1125 * shutdown.
1126 */
1127
1128 static void disable_comm (sdla_t *card)
1129 {
1130 printk(KERN_INFO "%s: Disabling Communications!\n",
1131 card->devname);
1132 fr_comm_disable(card);
1133 }
1134
1135 /****** WANPIPE-specific entry points ***************************************/
1136
1137 /*============================================================================
1138 * Execute adapter interface command.
1139 */
1140 static int wpf_exec (struct sdla* card, void* u_cmd, void* u_data)
1141 {
1142 fr_mbox_t* mbox = card->mbox;
1143 int retry = MAX_CMD_RETRY;
1144 int err, len;
1145 fr_cmd_t cmd;
1146
1147 #if defined(LINUX_2_1) || defined(LINUX_2_4)
1148
1149 if(copy_from_user((void*)&cmd, u_cmd, sizeof(cmd)))
1150 return -EFAULT;
1151
1152 /* execute command */
1153 do
1154 {
1155 memcpy(&mbox->cmd, &cmd, sizeof(cmd));
1156
1157 if (cmd.length){
1158 if( copy_from_user((void*)&mbox->data, u_data, cmd.length))
1159 return -EFAULT;
1160 }
1161
1162 if (sdla_exec(mbox))
1163 err = mbox->cmd.result;
1164
1165 else return -EIO;
1166
1167 } while (err && retry-- && fr_event(card, err, mbox));
1168
1169 /* return result */
1170 if (copy_to_user(u_cmd, (void*)&mbox->cmd, sizeof(fr_cmd_t)))
1171 return -EFAULT;
1172
1173 len = mbox->cmd.length;
1174
1175 if (len && u_data && !copy_to_user(u_data, (void*)&mbox->data, len))
1176 return -EFAULT;
1177 return 0;
1178
1179 #else
1180 if (!u_cmd || verify_area(VERIFY_WRITE, u_cmd, sizeof(fr_cmd_t)))
1181 return -EFAULT;
1182
1183 memcpy_fromfs((void*)&cmd, u_cmd, sizeof(cmd));
1184
1185 if (cmd.length) {
1186
1187 if (!u_data || verify_area(VERIFY_READ, u_data, cmd.length))
1188 return -EFAULT;
1189 }
1190
1191 /* execute command */
1192 do
1193 {
1194 memcpy(&mbox->cmd, &cmd, sizeof(cmd));
1195
1196 if (cmd.length)
1197 memcpy_fromfs((void*)&mbox->data, u_data, cmd.length);
1198
1199 if (sdla_exec(mbox))
1200 err = mbox->cmd.result;
1201
1202 else return -EIO;
1203 } while (err && retry-- && fr_event(card, err, mbox));
1204
1205 /* return result */
1206 memcpy_tofs(u_cmd, (void*)&mbox->cmd, sizeof(fr_cmd_t));
1207 len = mbox->cmd.length;
1208
1209 if (len && u_data && !verify_area(VERIFY_WRITE, u_data, len))
1210 memcpy_tofs(u_data, (void*)&mbox->data, len);
1211
1212 return 0;
1213
1214 #endif
1215
1216 }
1217
1218 /****** Network Device Interface ********************************************/
1219
1220 /*============================================================================
1221 * Initialize Linux network interface.
1222 *
1223 * This routine is called only once for each interface, during Linux network
1224 * interface registration. Returning anything but zero will fail interface
1225 * registration.
1226 */
1227 static int if_init (netdevice_t* dev)
1228 {
1229 fr_channel_t* chan = dev->priv;
1230 sdla_t* card = chan->card;
1231 wan_device_t* wandev = &card->wandev;
1232 #ifdef LINUX_2_0
1233 int i;
1234 #endif
1235
1236 /* Initialize device driver entry points */
1237 dev->open = &if_open;
1238 dev->stop = &if_close;
1239 dev->hard_header = NULL;
1240 dev->rebuild_header = &if_rebuild_hdr;
1241 dev->hard_start_xmit = &if_send;
1242 dev->get_stats = &if_stats;
1243 #ifdef LINUX_2_4
1244 dev->tx_timeout = &if_tx_timeout;
1245 dev->watchdog_timeo = TX_TIMEOUT;
1246 #endif
1247
1248 if (chan->common.usedby == WANPIPE || chan->common.usedby == API){
1249 #ifdef LINUX_2_0
1250 dev->family = AF_INET;
1251 #endif
1252 /* Initialize media-specific parameters */
1253 if (chan->true_if_encoding){
1254 dev->type = ARPHRD_DLCI; /* This breaks tcpdump */
1255 }else{
1256 dev->type = ARPHRD_PPP; /* ARP h/w type */
1257 }
1258
1259 dev->flags |= IFF_POINTOPOINT;
1260 dev->flags |= IFF_NOARP;
1261
1262 /* Enable Multicast addressing */
1263 if (chan->mc == WANOPT_YES){
1264 dev->flags |= IFF_MULTICAST;
1265 }
1266
1267 dev->mtu = wandev->mtu - FR_HEADER_LEN;
1268 /* For an API, the maximum number of bytes that the stack will pass
1269 to the driver is (dev->mtu + dev->hard_header_len). So, adjust the
1270 mtu so that a frame of maximum size can be transmitted by the API.
1271 */
1272 if(chan->common.usedby == API) {
1273 dev->mtu += (sizeof(api_tx_hdr_t) - FR_HEADER_LEN);
1274 }
1275
1276 dev->hard_header_len = FR_HEADER_LEN;/* media header length */
1277 dev->addr_len = 2; /* hardware address length */
1278 *(unsigned short*)dev->dev_addr = htons(chan->dlci);
1279
1280 /* Set transmit buffer queue length */
1281 dev->tx_queue_len = 100;
1282
1283 /* Initialize socket buffers */
1284 #if !defined(LINUX_2_1) && !defined(LINUX_2_4)
1285 for (i = 0; i < DEV_NUMBUFFS; ++i)
1286 skb_queue_head_init(&dev->buffs[i]);
1287 #endif
1288 }else{
1289
1290 /* Setup the interface for Bridging */
1291 int hw_addr=0;
1292 ether_setup(dev);
1293
1294 /* Use a random number to generate the MAC address */
1295 memcpy(dev->dev_addr, "\xFE\xFC\x00\x00\x00\x00", 6);
1296 get_random_bytes(&hw_addr, sizeof(hw_addr));
1297 *(int *)(dev->dev_addr + 2) += hw_addr;
1298 }
1299
1300 /* Initialize hardware parameters (just for reference) */
1301 dev->irq = wandev->irq;
1302 dev->dma = wandev->dma;
1303 dev->base_addr = wandev->ioport;
1304 dev->mem_start = wandev->maddr;
1305 dev->mem_end = wandev->maddr + wandev->msize - 1;
1306
1307 return 0;
1308 }
1309
1310 /*============================================================================
1311 * Open network interface.
1312 * o if this is the first open, then enable communications and interrupts.
1313 * o prevent module from unloading by incrementing use count
1314 *
1315 * Return 0 if O.k. or errno.
1316 */
1317 static int if_open (netdevice_t* dev)
1318 {
1319 fr_channel_t* chan = dev->priv;
1320 sdla_t* card = chan->card;
1321 int err = 0;
1322 struct timeval tv;
1323
1324 if (is_dev_running(dev))
1325 return -EBUSY;
1326
1327 #if defined(LINUX_2_1) || defined(LINUX_2_4)
1328 /* Initialize the task queue */
1329 chan->tq_working=0;
1330
1331 #ifndef LINUX_2_4
1332 chan->common.wanpipe_task.next = NULL;
1333 #endif
1334 chan->common.wanpipe_task.sync = 0;
1335 chan->common.wanpipe_task.routine = (void *)(void *)fr_bh;
1336 chan->common.wanpipe_task.data = dev;
1337
1338 /* Allocate and initialize BH circular buffer */
1339 chan->bh_head = kmalloc((sizeof(bh_data_t)*MAX_BH_BUFF),GFP_ATOMIC);
1340 memset(chan->bh_head,0,(sizeof(bh_data_t)*MAX_BH_BUFF));
1341 atomic_set(&chan->bh_buff_used, 0);
1342 #endif
1343
1344 #ifdef LINUX_2_4
1345 netif_start_queue(dev);
1346 #else
1347 dev->interrupt = 0;
1348 dev->tbusy = 0;
1349 dev->start = 1;
1350 #endif
1351
1352 wanpipe_open(card);
1353 do_gettimeofday( &tv );
1354 chan->router_start_time = tv.tv_sec;
1355
1356 if (test_bit(0,&chan->config_dlci)){
1357 trigger_config_fr (card);
1358 }else if (chan->inarp == INARP_REQUEST){
1359 trigger_fr_arp(dev);
1360 }
1361
1362 return err;
1363 }
1364
1365 /*============================================================================
1366 * Close network interface.
1367 * o if this is the last open, then disable communications and interrupts.
1368 * o reset flags.
1369 */
1370 static int if_close (netdevice_t* dev)
1371 {
1372 fr_channel_t* chan = dev->priv;
1373 sdla_t* card = chan->card;
1374
1375 if (chan->inarp == INARP_CONFIGURED) {
1376 chan->inarp = INARP_REQUEST;
1377 }
1378
1379 stop_net_queue(dev);
1380 #ifndef LINUX_2_4
1381 dev->start=0;
1382 #endif
1383 wanpipe_close(card);
1384
1385 return 0;
1386 }
1387
1388 /*============================================================================
1389 * Re-build media header.
1390 *
1391 * Return: 1 physical address resolved.
1392 * 0 physical address not resolved
1393 */
1394 #if defined(LINUX_2_1) || defined(LINUX_2_4)
1395 static int if_rebuild_hdr (struct sk_buff* skb)
1396 {
1397 #else
1398 static int if_rebuild_hdr (void* hdr, netdevice_t* dev, unsigned long raddr,
1399 struct sk_buff* skb)
1400 {
1401 #endif
1402
1403 #if defined(LINUX_2_1) || defined(LINUX_2_4)
1404 netdevice_t *dev = skb->dev;
1405 #endif
1406 fr_channel_t* chan = dev->priv;
1407 sdla_t* card = chan->card;
1408
1409 printk(KERN_INFO "%s: rebuild_header() called for interface %s!\n",
1410 card->devname, dev->name);
1411 return 1;
1412 }
1413
1414 #ifdef LINUX_2_4
1415 /*============================================================================
1416 * Handle transmit timeout event from netif watchdog
1417 */
1418 static void if_tx_timeout (netdevice_t *dev)
1419 {
1420 fr_channel_t* chan = dev->priv;
1421 sdla_t *card = chan->card;
1422
1423 /* If our device stays busy for at least 5 seconds then we will
1424 * kick start the device by making dev->tbusy = 0. We expect
1425 * that our device never stays busy more than 5 seconds. So this
1426 * is only used as a last resort.
1427 */
1428
1429 chan->drvstats_if_send.if_send_tbusy++;
1430 ++chan->ifstats.collisions;
1431
1432 printk (KERN_INFO "%s: Transmit timed out on %s\n",
1433 card->devname, dev->name);
1434 chan->drvstats_if_send.if_send_tbusy_timeout++;
1435 netif_wake_queue (dev);
1436
1437 }
1438 #endif
1439
1440 /*============================================================================
1441 * Send a packet on a network interface.
1442 * o set tbusy flag (marks start of the transmission) to block a timer-based
1443 * transmit from overlapping.
1444 * o set critical flag when accessing board.
1445 * o check link state. If link is not up, then drop the packet.
1446 * o check channel status. If it's down then initiate a call.
1447 * o pass a packet to corresponding WAN device.
1448 * o free socket buffer
1449 *
1450 * Return: 0 complete (socket buffer must be freed)
1451 * non-0 packet may be re-transmitted (tbusy must be set)
1452 *
1453 * Notes:
1454 * 1. This routine is called either by the protocol stack or by the "net
1455 * bottom half" (with interrupts enabled).
1456 *
1457 * 2. Using the start_net_queue() and stop_net_queue() MACROS
1458 * will inhibit further transmit requests from the protocol stack
1459 * and can be used for flow control with protocol layer.
1460 */
1461 static int if_send (struct sk_buff* skb, netdevice_t* dev)
1462 {
1463 fr_channel_t* chan = dev->priv;
1464 sdla_t* card = chan->card;
1465 int err;
1466 unsigned char *sendpacket;
1467 fr508_flags_t* adptr_flags = card->flags;
1468 int udp_type, delay_tx_queued=0;
1469 unsigned long smp_flags=0;
1470 unsigned char attr = 0;
1471
1472 chan->drvstats_if_send.if_send_entry++;
1473
1474 #ifdef LINUX_2_4
1475 netif_stop_queue(dev);
1476 #endif
1477
1478 if (skb == NULL) {
1479 /* if we get here, some higher layer thinks we've missed an
1480 * tx-done interrupt.
1481 */
1482 printk(KERN_INFO "%s: interface %s got kicked!\n",
1483 card->devname, dev->name);
1484 chan->drvstats_if_send.if_send_skb_null ++;
1485
1486 wake_net_dev(dev);
1487 return 0;
1488 }
1489
1490 /* If a peripheral task is running just drop packets */
1491 if (test_bit(PERI_CRIT, &card->wandev.critical)){
1492
1493 printk(KERN_INFO "%s: Critical in if_send(): Peripheral running!\n",
1494 card->devname);
1495
1496 wan_dev_kfree_skb(skb,FREE_WRITE);
1497 start_net_queue(dev);
1498 return 0;
1499 }
1500
1501 /* We must set the 'tbusy' flag if we already have a packet queued for
1502 transmission in the transmit interrupt handler. However, we must
1503 ensure that the transmit interrupt does not reset the 'tbusy' flag
1504 just before we set it, as this will result in a "transmit timeout".
1505 */
1506 set_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical);
1507 if(chan->transmit_length) {
1508 stop_net_queue(dev);
1509 chan->tick_counter = jiffies;
1510 clear_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical);
1511 return 1;
1512 }
1513 clear_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical);
1514
1515 #ifndef LINUX_2_4
1516 if (dev->tbusy) {
1517
1518 /* If our device stays busy for at least 5 seconds then we will
1519 * kick start the device by making dev->tbusy = 0. We expect
1520 * that our device never stays busy more than 5 seconds. So this
1521 * is only used as a last resort.
1522 */
1523
1524 chan->drvstats_if_send.if_send_tbusy++;
1525 ++chan->ifstats.collisions;
1526
1527 if ((jiffies - chan->tick_counter) < (5 * HZ)) {
1528 return 1;
1529 }
1530
1531 printk(KERN_INFO "%s: Transmit timed out on %s\n",
1532 card->devname, chan->name);
1533 chan->drvstats_if_send.if_send_tbusy_timeout ++;
1534 dev->tbusy = 0;
1535 }
1536 #endif
1537
1538
1539 /* Move the if_header() code to here. By inserting frame
1540 * relay header in if_header() we would break the
1541 * tcpdump and other packet sniffers */
1542 chan->fr_header_len = setup_fr_header(&skb,dev,chan->common.usedby);
1543 if (chan->fr_header_len < 0 ){
1544 ++chan->ifstats.tx_dropped;
1545 ++card->wandev.stats.tx_dropped;
1546
1547 wan_dev_kfree_skb(skb,FREE_WRITE);
1548 start_net_queue(dev);
1549 return 0;
1550 }
1551
1552 sendpacket = skb->data;
1553
1554 udp_type = udp_pkt_type(skb, card);
1555
1556 if(udp_type != UDP_INVALID_TYPE) {
1557 if(store_udp_mgmt_pkt(udp_type, UDP_PKT_FRM_STACK, card, skb,
1558 chan->dlci)) {
1559 adptr_flags->imask |= FR_INTR_TIMER;
1560 if (udp_type == UDP_FPIPE_TYPE){
1561 chan->drvstats_if_send.
1562 if_send_PIPE_request ++;
1563 }
1564 }
1565 start_net_queue(dev);
1566 return 0;
1567 }
1568
1569 //FIXME: can we do better than sendpacket[2]?
1570 if ((chan->common.usedby == WANPIPE) && (sendpacket[2] == 0x45)) {
1571
1572 /* check to see if the source IP address is a broadcast or */
1573 /* multicast IP address */
1574 if(chk_bcast_mcast_addr(card, dev, skb)){
1575 ++chan->ifstats.tx_dropped;
1576 ++card->wandev.stats.tx_dropped;
1577 wan_dev_kfree_skb(skb, FREE_WRITE);
1578 start_net_queue(dev);
1579 return 0;
1580 }
1581 }
1582
1583
1584 /* Lock the S514/S508 card: SMP Supported */
1585 s508_s514_lock(card,&smp_flags);
1586
1587 if (test_and_set_bit(SEND_CRIT, (void*)&card->wandev.critical)) {
1588
1589 chan->drvstats_if_send.if_send_critical_non_ISR ++;
1590 chan->ifstats.tx_dropped ++;
1591 printk(KERN_INFO "%s Critical in IF_SEND: if_send() already running!\n",
1592 card->devname);
1593 goto if_send_start_and_exit;
1594 }
1595
1596 /* API packet check: minimum packet size must be greater than
1597 * 16 byte API header */
1598 if((chan->common.usedby == API) && (skb->len <= sizeof(api_tx_hdr_t))) {
1599 ++chan->ifstats.tx_dropped;
1600 ++card->wandev.stats.tx_dropped;
1601
1602
1603 goto if_send_start_and_exit;
1604
1605 }else{
1606 /* During API transmission, get rid of the API header */
1607 if (chan->common.usedby == API) {
1608 api_tx_hdr_t* api_tx_hdr;
1609 api_tx_hdr = (api_tx_hdr_t*)&skb->data[0x00];
1610 attr = api_tx_hdr->attr;
1611 skb_pull(skb,sizeof(api_tx_hdr_t));
1612 }
1613 }
1614
1615 if (card->wandev.state != WAN_CONNECTED) {
1616 chan->drvstats_if_send.if_send_wan_disconnected ++;
1617 ++chan->ifstats.tx_dropped;
1618 ++card->wandev.stats.tx_dropped;
1619
1620 } else if (chan->common.state != WAN_CONNECTED) {
1621 chan->drvstats_if_send.if_send_dlci_disconnected ++;
1622
1623 /* Update the DLCI state in timer interrupt */
1624 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UPDATE_STATE;
1625 adptr_flags->imask |= FR_INTR_TIMER;
1626
1627 ++chan->ifstats.tx_dropped;
1628 ++card->wandev.stats.tx_dropped;
1629
1630 } else if (!is_tx_ready(card, chan)) {
1631 /* No tx buffers available, store for delayed transmit */
1632 if (!setup_for_delayed_transmit(dev, skb)){
1633 set_bit(1,&delay_tx_queued);
1634 }
1635 chan->drvstats_if_send.if_send_no_bfrs++;
1636
1637 } else if (!skb->protocol) {
1638 /* No protocols drop packet */
1639 chan->drvstats_if_send.if_send_protocol_error ++;
1640 ++card->wandev.stats.tx_errors;
1641
1642 } else if (test_bit(ARP_CRIT,&card->wandev.critical)){
1643 /* We are trying to send an ARP Packet, block IP data until
1644 * ARP is sent */
1645 ++chan->ifstats.tx_dropped;
1646 ++card->wandev.stats.tx_dropped;
1647
1648 } else {
1649 //FIXME: IPX is not implemented in this version of Frame Relay ?
1650 if((chan->common.usedby == WANPIPE) &&
1651 sendpacket[1] == 0x00 &&
1652 sendpacket[2] == 0x80 &&
1653 sendpacket[6] == 0x81 &&
1654 sendpacket[7] == 0x37) {
1655
1656 if( chan->enable_IPX ) {
1657 switch_net_numbers(sendpacket,
1658 chan->network_number, 0);
1659 } else {
1660 //FIXME: Take this out when IPX is fixed
1661 printk(KERN_INFO
1662 "%s: WARNING: Unsupported IPX data in send, packet dropped\n",
1663 card->devname);
1664 }
1665
1666 }else{
1667 err = fr_send_data_header(card, chan->dlci, attr, skb->len, skb->data, chan->fr_header_len);
1668 if (err) {
1669 switch(err) {
1670 case FRRES_CIR_OVERFLOW:
1671 case FRRES_BUFFER_OVERFLOW:
1672 if (!setup_for_delayed_transmit(dev, skb)){
1673 set_bit(1,&delay_tx_queued);
1674 }
1675 chan->drvstats_if_send.
1676 if_send_adptr_bfrs_full ++;
1677 break;
1678
1679 case FRRES_TOO_LONG:
1680 if (net_ratelimit()){
1681 printk(KERN_INFO
1682 "%s: Error: Frame too long, transmission failed %i\n",
1683 card->devname, (unsigned int)skb->len);
1684 }
1685 /* Drop down to default */
1686 default:
1687 chan->drvstats_if_send.
1688 if_send_dlci_disconnected ++;
1689 ++chan->ifstats.tx_dropped;
1690 ++card->wandev.stats.tx_dropped;
1691 break;
1692 }
1693 } else {
1694 chan->drvstats_if_send.
1695 if_send_bfr_passed_to_adptr++;
1696 ++chan->ifstats.tx_packets;
1697 ++card->wandev.stats.tx_packets;
1698
1699 #if defined(LINUX_2_1) || defined(LINUX_2_4)
1700 chan->ifstats.tx_bytes += skb->len;
1701 card->wandev.stats.tx_bytes += skb->len;
1702 #endif
1703 #ifdef LINUX_2_4
1704 dev->trans_start = jiffies;
1705 #endif
1706 }
1707 }
1708 }
1709
1710 if_send_start_and_exit:
1711
1712 start_net_queue(dev);
1713
1714 /* If we queued the packet for transmission, we must not
1715 * deallocate it. The packet is unlinked from the IP stack
1716 * not copied. Therefore, we must keep the original packet */
1717 if (!test_bit(1,&delay_tx_queued)) {
1718 wan_dev_kfree_skb(skb, FREE_WRITE);
1719 }else{
1720 adptr_flags->imask |= FR_INTR_TXRDY;
1721 card->u.f.tx_interrupts_pending ++;
1722 }
1723
1724 clear_bit(SEND_CRIT, (void*)&card->wandev.critical);
1725
1726 s508_s514_unlock(card,&smp_flags);
1727
1728 return 0;
1729 }
1730
1731
1732
1733 /*============================================================================
1734 * Setup so that a frame can be transmitted on the occurence of a transmit
1735 * interrupt.
1736 */
1737 static int setup_for_delayed_transmit (netdevice_t* dev, struct sk_buff *skb)
1738 {
1739 fr_channel_t* chan = dev->priv;
1740 sdla_t* card = chan->card;
1741 fr_dlci_interface_t* dlci_interface;
1742 int len = skb->len;
1743
1744 /* Check that the dlci is properly configured,
1745 * before using tx interrupt */
1746 if (!chan->dlci_int_interface){
1747 if (net_ratelimit()){
1748 printk(KERN_INFO
1749 "%s: ERROR on DLCI %i: Not configured properly !\n",
1750 card->devname, chan->dlci);
1751 printk(KERN_INFO "%s: Please contact Sangoma Technologies\n",
1752 card->devname);
1753 }
1754 return 1;
1755 }
1756
1757 dlci_interface = chan->dlci_int_interface;
1758
1759 if(chan->transmit_length) {
1760 printk(KERN_INFO "%s: Big mess in setup_for_del...\n",
1761 card->devname);
1762 return 1;
1763 }
1764
1765 if(len > FR_MAX_NO_DATA_BYTES_IN_FRAME) {
1766 //FIXME: increment some statistic */
1767 return 1;
1768 }
1769
1770 skb_unlink(skb);
1771
1772 chan->transmit_length = len;
1773 chan->delay_skb = skb;
1774
1775 dlci_interface->gen_interrupt |= FR_INTR_TXRDY;
1776 dlci_interface->packet_length = len;
1777
1778 /* Turn on TX interrupt at the end of if_send */
1779 return 0;
1780 }
1781
1782
1783 /*============================================================================
1784 * Check to see if the packet to be transmitted contains a broadcast or
1785 * multicast source IP address.
1786 * Return 0 if not broadcast/multicast address, otherwise return 1.
1787 */
1788
1789 static int chk_bcast_mcast_addr(sdla_t *card, netdevice_t* dev,
1790 struct sk_buff *skb)
1791 {
1792 u32 src_ip_addr;
1793 u32 broadcast_ip_addr = 0;
1794 #if defined(LINUX_2_1) || defined(LINUX_2_4)
1795 struct in_device *in_dev;
1796 #endif
1797 fr_channel_t* chan = dev->priv;
1798
1799 /* read the IP source address from the outgoing packet */
1800 src_ip_addr = *(u32 *)(skb->data + 14);
1801
1802 /* read the IP broadcast address for the device */
1803 #if defined(LINUX_2_1) || defined(LINUX_2_4)
1804 in_dev = dev->ip_ptr;
1805 if(in_dev != NULL) {
1806 struct in_ifaddr *ifa= in_dev->ifa_list;
1807 if(ifa != NULL)
1808 broadcast_ip_addr = ifa->ifa_broadcast;
1809 else
1810 return 0;
1811 }
1812 #else
1813 broadcast_ip_addr = dev->pa_brdaddr;
1814 #endif
1815
1816 /* check if the IP Source Address is a Broadcast address */
1817 if((dev->flags & IFF_BROADCAST) && (src_ip_addr == broadcast_ip_addr)) {
1818 printk(KERN_INFO
1819 "%s: Broadcast Source Address silently discarded\n",
1820 card->devname);
1821 return 1;
1822 }
1823
1824 /* check if the IP Source Address is a Multicast address */
1825 if((chan->mc == WANOPT_NO) && (ntohl(src_ip_addr) >= 0xE0000001) &&
1826 (ntohl(src_ip_addr) <= 0xFFFFFFFE)) {
1827 printk(KERN_INFO
1828 "%s: Multicast Source Address silently discarded\n",
1829 card->devname);
1830 return 1;
1831 }
1832
1833 return 0;
1834 }
1835
1836 /*============================================================================
1837 * Reply to UDP Management system.
1838 * Return nothing.
1839 */
1840 static int reply_udp( unsigned char *data, unsigned int mbox_len )
1841 {
1842 unsigned short len, udp_length, temp, ip_length;
1843 unsigned long ip_temp;
1844 int even_bound = 0;
1845
1846
1847 fr_udp_pkt_t *fr_udp_pkt = (fr_udp_pkt_t *)data;
1848
1849 /* Set length of packet */
1850 len = //sizeof(fr_encap_hdr_t)+
1851 sizeof(ip_pkt_t)+
1852 sizeof(udp_pkt_t)+
1853 sizeof(wp_mgmt_t)+
1854 sizeof(cblock_t)+
1855 mbox_len;
1856
1857
1858 /* fill in UDP reply */
1859 fr_udp_pkt->wp_mgmt.request_reply = UDPMGMT_REPLY;
1860
1861 /* fill in UDP length */
1862 udp_length = sizeof(udp_pkt_t)+
1863 sizeof(wp_mgmt_t)+
1864 sizeof(cblock_t)+
1865 mbox_len;
1866
1867
1868 /* put it on an even boundary */
1869 if ( udp_length & 0x0001 ) {
1870 udp_length += 1;
1871 len += 1;
1872 even_bound = 1;
1873 }
1874
1875 temp = (udp_length<<8)|(udp_length>>8);
1876 fr_udp_pkt->udp_pkt.udp_length = temp;
1877
1878 /* swap UDP ports */
1879 temp = fr_udp_pkt->udp_pkt.udp_src_port;
1880 fr_udp_pkt->udp_pkt.udp_src_port =
1881 fr_udp_pkt->udp_pkt.udp_dst_port;
1882 fr_udp_pkt->udp_pkt.udp_dst_port = temp;
1883
1884
1885
1886 /* add UDP pseudo header */
1887 temp = 0x1100;
1888 *((unsigned short *)
1889 (fr_udp_pkt->data+mbox_len+even_bound)) = temp;
1890 temp = (udp_length<<8)|(udp_length>>8);
1891 *((unsigned short *)
1892 (fr_udp_pkt->data+mbox_len+even_bound+2)) = temp;
1893
1894 /* calculate UDP checksum */
1895 fr_udp_pkt->udp_pkt.udp_checksum = 0;
1896
1897 fr_udp_pkt->udp_pkt.udp_checksum =
1898 calc_checksum(&data[UDP_OFFSET/*+sizeof(fr_encap_hdr_t)*/],
1899 udp_length+UDP_OFFSET);
1900
1901 /* fill in IP length */
1902 ip_length = udp_length + sizeof(ip_pkt_t);
1903 temp = (ip_length<<8)|(ip_length>>8);
1904 fr_udp_pkt->ip_pkt.total_length = temp;
1905
1906 /* swap IP addresses */
1907 ip_temp = fr_udp_pkt->ip_pkt.ip_src_address;
1908 fr_udp_pkt->ip_pkt.ip_src_address =
1909 fr_udp_pkt->ip_pkt.ip_dst_address;
1910 fr_udp_pkt->ip_pkt.ip_dst_address = ip_temp;
1911
1912
1913 /* fill in IP checksum */
1914 fr_udp_pkt->ip_pkt.hdr_checksum = 0;
1915 fr_udp_pkt->ip_pkt.hdr_checksum =
1916 calc_checksum(&data[/*sizeof(fr_encap_hdr_t)*/0],
1917 sizeof(ip_pkt_t));
1918
1919 return len;
1920 } /* reply_udp */
1921
1922 unsigned short calc_checksum (char *data, int len)
1923 {
1924 unsigned short temp;
1925 unsigned long sum=0;
1926 int i;
1927
1928 for( i = 0; i <len; i+=2 ) {
1929 memcpy(&temp,&data[i],2);
1930 sum += (unsigned long)temp;
1931 }
1932
1933 while (sum >> 16 ) {
1934 sum = (sum & 0xffffUL) + (sum >> 16);
1935 }
1936
1937 temp = (unsigned short)sum;
1938 temp = ~temp;
1939
1940 if( temp == 0 )
1941 temp = 0xffff;
1942
1943 return temp;
1944 }
1945
1946 /*
1947 If incoming is 0 (outgoing)- if the net numbers is ours make it 0
1948 if incoming is 1 - if the net number is 0 make it ours
1949
1950 */
1951 static void switch_net_numbers(unsigned char *sendpacket, unsigned long network_number, unsigned char incoming)
1952 {
1953 unsigned long pnetwork_number;
1954
1955 pnetwork_number = (unsigned long)((sendpacket[14] << 24) +
1956 (sendpacket[15] << 16) + (sendpacket[16] << 8) +
1957 sendpacket[17]);
1958
1959 if (!incoming) {
1960 /* If the destination network number is ours, make it 0 */
1961 if( pnetwork_number == network_number) {
1962 sendpacket[14] = sendpacket[15] = sendpacket[16] =
1963 sendpacket[17] = 0x00;
1964 }
1965 } else {
1966 /* If the incoming network is 0, make it ours */
1967 if( pnetwork_number == 0) {
1968 sendpacket[14] = (unsigned char)(network_number >> 24);
1969 sendpacket[15] = (unsigned char)((network_number &
1970 0x00FF0000) >> 16);
1971 sendpacket[16] = (unsigned char)((network_number &
1972 0x0000FF00) >> 8);
1973 sendpacket[17] = (unsigned char)(network_number &
1974 0x000000FF);
1975 }
1976 }
1977
1978
1979 pnetwork_number = (unsigned long)((sendpacket[26] << 24) +
1980 (sendpacket[27] << 16) + (sendpacket[28] << 8) +
1981 sendpacket[29]);
1982
1983 if( !incoming ) {
1984 /* If the source network is ours, make it 0 */
1985 if( pnetwork_number == network_number) {
1986 sendpacket[26] = sendpacket[27] = sendpacket[28] =
1987 sendpacket[29] = 0x00;
1988 }
1989 } else {
1990 /* If the source network is 0, make it ours */
1991 if( pnetwork_number == 0 ) {
1992 sendpacket[26] = (unsigned char)(network_number >> 24);
1993 sendpacket[27] = (unsigned char)((network_number &
1994 0x00FF0000) >> 16);
1995 sendpacket[28] = (unsigned char)((network_number &
1996 0x0000FF00) >> 8);
1997 sendpacket[29] = (unsigned char)(network_number &
1998 0x000000FF);
1999 }
2000 }
2001 } /* switch_net_numbers */
2002
2003 /*============================================================================
2004 * Get ethernet-style interface statistics.
2005 * Return a pointer to struct enet_statistics.
2006 */
2007 #if defined(LINUX_2_1) || defined(LINUX_2_4)
2008 static struct net_device_stats *if_stats(netdevice_t *dev)
2009 #else
2010 static struct enet_statistics* if_stats (netdevice_t* dev)
2011 #endif
2012 {
2013 fr_channel_t* chan = dev->priv;
2014
2015 if(chan == NULL)
2016 return NULL;
2017
2018 return &chan->ifstats;
2019 }
2020
2021 /****** Interrupt Handlers **************************************************/
2022
2023 /*============================================================================
2024 * fr_isr: S508 frame relay interrupt service routine.
2025 *
2026 * Description:
2027 * Frame relay main interrupt service route. This
2028 * function check the interrupt type and takes
2029 * the appropriate action.
2030 */
2031 static void fr_isr (sdla_t* card)
2032 {
2033 fr508_flags_t* flags = card->flags;
2034 char *ptr = &flags->iflag;
2035 int i,err;
2036 fr_mbox_t* mbox = card->mbox;
2037
2038 /* This flag prevents nesting of interrupts. See sdla_isr() routine
2039 * in sdlamain.c. */
2040 card->in_isr = 1;
2041
2042 ++card->statistics.isr_entry;
2043
2044
2045 /* All peripheral (configuraiton, re-configuration) events
2046 * take presidence over the ISR. Thus, retrigger */
2047 if (test_bit(PERI_CRIT, (void*)&card->wandev.critical)) {
2048 ++card->statistics.isr_already_critical;
2049 goto fr_isr_exit;
2050 }
2051
2052 if(card->hw.type != SDLA_S514) {
2053 if (test_bit(SEND_CRIT, (void*)&card->wandev.critical)) {
2054 printk(KERN_INFO "%s: Critical while in ISR: If Send Running!\n",
2055 card->devname);
2056 ++card->statistics.isr_already_critical;
2057 goto fr_isr_exit;
2058 }
2059 }
2060
2061 switch (flags->iflag) {
2062
2063 case FR_INTR_RXRDY: /* receive interrupt */
2064 ++card->statistics.isr_rx;
2065 rx_intr(card);
2066 break;
2067
2068
2069 case FR_INTR_TXRDY: /* transmit interrupt */
2070 ++ card->statistics.isr_tx;
2071 tx_intr(card);
2072 break;
2073
2074 case FR_INTR_READY:
2075 Intr_test_counter++;
2076 ++card->statistics.isr_intr_test;
2077 break;
2078
2079 case FR_INTR_DLC: /* Event interrupt occured */
2080 mbox->cmd.command = FR_READ_STATUS;
2081 mbox->cmd.length = 0;
2082 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2083 if (err)
2084 fr_event(card, err, mbox);
2085 break;
2086
2087 case FR_INTR_TIMER: /* Timer interrupt */
2088 timer_intr(card);
2089 break;
2090
2091 default:
2092 ++card->statistics.isr_spurious;
2093 spur_intr(card);
2094 printk(KERN_INFO "%s: Interrupt Type 0x%02X!\n",
2095 card->devname, flags->iflag);
2096
2097 printk(KERN_INFO "%s: ID Bytes = ",card->devname);
2098 for(i = 0; i < 8; i ++)
2099 printk(KERN_INFO "0x%02X ", *(ptr + 0x28 + i));
2100 printk(KERN_INFO "\n");
2101
2102 break;
2103 }
2104
2105 fr_isr_exit:
2106
2107 card->in_isr = 0;
2108 flags->iflag = 0;
2109 return;
2110 }
2111
2112
2113
2114 /*===========================================================
2115 * rx_intr Receive interrupt handler.
2116 *
2117 * Description
2118 * Upon receiveing an interrupt:
2119 * 1. Check that the firmware is in sync with
2120 * the driver.
2121 * 2. Find an appropriate network interface
2122 * based on the received dlci number.
2123 * 3. Check that the netowrk interface exists
2124 * and that it's setup properly.
2125 * 4. Copy the data into an skb buffer.
2126 * 5. Check the packet type and take
2127 * appropriate acton: UPD, API, ARP or Data.
2128 */
2129
2130 static void rx_intr (sdla_t* card)
2131 {
2132 fr_rx_buf_ctl_t* frbuf = card->rxmb;
2133 fr508_flags_t* flags = card->flags;
2134 fr_channel_t* chan;
2135 char *ptr = &flags->iflag;
2136 struct sk_buff* skb;
2137 netdevice_t* dev;
2138 void* buf;
2139 unsigned dlci, len, offs, len_incl_hdr;
2140 int i, udp_type;
2141
2142
2143 /* Check that firmware buffers are in sync */
2144 if (frbuf->flag != 0x01) {
2145
2146 printk(KERN_INFO
2147 "%s: corrupted Rx buffer @ 0x%X, flag = 0x%02X!\n",
2148 card->devname, (unsigned)frbuf, frbuf->flag);
2149
2150 printk(KERN_INFO "%s: ID Bytes = ",card->devname);
2151 for(i = 0; i < 8; i ++)
2152 printk(KERN_INFO "0x%02X ", *(ptr + 0x28 + i));
2153 printk(KERN_INFO "\n");
2154
2155 ++card->statistics.rx_intr_corrupt_rx_bfr;
2156
2157 /* Bug Fix: Mar 6 2000
2158 * If we get a corrupted mailbox, it means that driver
2159 * is out of sync with the firmware. There is no recovery.
2160 * If we don't turn off all interrupts for this card
2161 * the machine will crash.
2162 */
2163 printk(KERN_INFO "%s: Critical router failure ...!!!\n", card->devname);
2164 printk(KERN_INFO "Please contact Sangoma Technologies !\n");
2165 fr_set_intr_mode(card, 0, 0, 0);
2166 return;
2167 }
2168
2169 len = frbuf->length;
2170 dlci = frbuf->dlci;
2171 offs = frbuf->offset;
2172
2173 /* Find the network interface for this packet */
2174 dev = find_channel(card, dlci);
2175
2176
2177 /* Check that the network interface is active and
2178 * properly setup */
2179 if (dev == NULL) {
2180 if( net_ratelimit()) {
2181 printk(KERN_INFO "%s: received data on unconfigured DLCI %d!\n",
2182 card->devname, dlci);
2183 }
2184 ++card->statistics.rx_intr_on_orphaned_DLCI;
2185 ++card->wandev.stats.rx_dropped;
2186 goto rx_done;
2187 }
2188
2189 if ((chan = dev->priv) == NULL){
2190 if( net_ratelimit()) {
2191 printk(KERN_INFO "%s: received data on unconfigured DLCI %d!\n",
2192 card->devname, dlci);
2193 }
2194 ++card->statistics.rx_intr_on_orphaned_DLCI;
2195 ++card->wandev.stats.rx_dropped;
2196 goto rx_done;
2197 }
2198
2199 skb = dev_alloc_skb(len);
2200
2201 if (!is_dev_running(dev) || (skb == NULL)){
2202
2203 ++chan->ifstats.rx_dropped;
2204
2205 if(skb == NULL) {
2206 if (net_ratelimit()) {
2207 printk(KERN_INFO
2208 "%s: no socket buffers available!\n",
2209 card->devname);
2210 }
2211 chan->drvstats_rx_intr.rx_intr_no_socket ++;
2212 }
2213
2214 if (!is_dev_running(dev)){
2215 chan->drvstats_rx_intr.
2216 rx_intr_dev_not_started ++;
2217 if (skb){
2218 wan_dev_kfree_skb(skb, FREE_READ);
2219 }
2220 }
2221 goto rx_done;
2222 }
2223
2224 /* Copy data from the board into the socket buffer */
2225 if ((offs + len) > card->u.f.rx_top + 1) {
2226 unsigned tmp = card->u.f.rx_top - offs + 1;
2227
2228 buf = skb_put(skb, tmp);
2229 sdla_peek(&card->hw, offs, buf, tmp);
2230 offs = card->u.f.rx_base;
2231 len -= tmp;
2232 }
2233
2234 buf = skb_put(skb, len);
2235 sdla_peek(&card->hw, offs, buf, len);
2236
2237
2238 /* We got the packet from the bard.
2239 * Check the packet type and take appropriate action */
2240
2241 udp_type = udp_pkt_type( skb, card );
2242
2243 if(udp_type != UDP_INVALID_TYPE) {
2244
2245 /* UDP Debug packet received, store the
2246 * packet and handle it in timer interrupt */
2247
2248 skb_pull(skb, 1);
2249 if (wanrouter_type_trans(skb, dev)){
2250 if(store_udp_mgmt_pkt(udp_type,UDP_PKT_FRM_NETWORK,card,skb,dlci)){
2251
2252 flags->imask |= FR_INTR_TIMER;
2253
2254 if (udp_type == UDP_FPIPE_TYPE){
2255 ++chan->drvstats_rx_intr.rx_intr_PIPE_request;
2256 }
2257 }
2258 }
2259
2260 #if defined(LINUX_2_1) || defined(LINUX_2_4)
2261 }else if (chan->common.usedby == API) {
2262
2263 /* We are in API mode.
2264 * Add an API header to the RAW packet
2265 * and queue it into a circular buffer.
2266 * Then kick the fr_bh() bottom half handler */
2267
2268 api_rx_hdr_t* api_rx_hdr;
2269 chan->drvstats_rx_intr.rx_intr_bfr_passed_to_stack ++;
2270 chan->ifstats.rx_packets ++;
2271 card->wandev.stats.rx_packets ++;
2272
2273 chan->ifstats.rx_bytes += skb->len;
2274 card->wandev.stats.rx_bytes += skb->len;
2275
2276 skb_push(skb, sizeof(api_rx_hdr_t));
2277 api_rx_hdr = (api_rx_hdr_t*)&skb->data[0x00];
2278 api_rx_hdr->attr = frbuf->attr;
2279 api_rx_hdr->time_stamp = frbuf->tmstamp;
2280
2281 skb->protocol = htons(ETH_P_IP);
2282 skb->mac.raw = skb->data;
2283 skb->dev = dev;
2284 skb->pkt_type = WAN_PACKET_DATA;
2285
2286 bh_enqueue(dev, skb);
2287
2288 trigger_fr_bh(chan);
2289 #endif
2290
2291 }else if (handle_IPXWAN(skb->data,chan->name,chan->enable_IPX, chan->network_number)){
2292
2293 //FIXME: Frame Relay IPX is not supported, Yet !
2294 //if (chan->enable_IPX) {
2295 // fr_send(card, dlci, 0, skb->len,skb->data);
2296 //}
2297 wan_dev_kfree_skb(skb, FREE_READ);
2298
2299 } else if (is_arp(skb->data)) {
2300
2301 /* ARP support enabled Mar 16 2000
2302 * Process incoming ARP reply/request, setup
2303 * dynamic routes. */
2304
2305 if (process_ARP((arphdr_1490_t *)skb->data, card, dev)) {
2306 if (net_ratelimit()){
2307 printk (KERN_INFO
2308 "%s: Error processing ARP Packet.\n",
2309 card->devname);
2310 }
2311 }
2312 wan_dev_kfree_skb(skb, FREE_READ);
2313
2314 } else if (skb->data[0] != 0x03) {
2315
2316 if (net_ratelimit()) {
2317 printk(KERN_INFO "%s: Non IETF packet discarded.\n",
2318 card->devname);
2319 }
2320 wan_dev_kfree_skb(skb, FREE_READ);
2321
2322 } else {
2323
2324 len_incl_hdr = skb->len;
2325 /* Decapsulate packet and pass it up the
2326 protocol stack */
2327 skb->dev = dev;
2328
2329 if (chan->common.usedby == BRIDGE || chan->common.usedby == BRIDGE_NODE){
2330
2331 /* Make sure it's an Ethernet frame, otherwise drop it */
2332 if (!memcmp(skb->data, "\x03\x00\x80\x00\x80\xC2\x00\x07", 8)) {
2333 skb_pull(skb, 8);
2334 skb->protocol=eth_type_trans(skb,dev);
2335 }else{
2336 ++chan->drvstats_rx_intr.rx_intr_bfr_not_passed_to_stack;
2337 ++chan->ifstats.rx_errors;
2338 ++card->wandev.stats.rx_errors;
2339 goto rx_done;
2340 }
2341 }else{
2342
2343 /* remove hardware header */
2344 buf = skb_pull(skb, 1);
2345
2346 if (!wanrouter_type_trans(skb, dev)) {
2347
2348 /* can't decapsulate packet */
2349 wan_dev_kfree_skb(skb, FREE_READ);
2350
2351 ++chan->drvstats_rx_intr.rx_intr_bfr_not_passed_to_stack;
2352 ++chan->ifstats.rx_errors;
2353 ++card->wandev.stats.rx_errors;
2354 goto rx_done;
2355 }
2356 skb->mac.raw = skb->data;
2357 }
2358
2359
2360 /* Send a packed up the IP stack */
2361 netif_rx(skb);
2362 ++chan->drvstats_rx_intr.rx_intr_bfr_passed_to_stack;
2363 ++chan->ifstats.rx_packets;
2364 ++card->wandev.stats.rx_packets;
2365
2366 #if defined(LINUX_2_1) || defined(LINUX_2_4)
2367 chan->ifstats.rx_bytes += len_incl_hdr;
2368 card->wandev.stats.rx_bytes += len_incl_hdr;
2369 #endif
2370 }
2371
2372 rx_done:
2373
2374 /* Release buffer element and calculate a pointer to the next one */
2375 frbuf->flag = 0;
2376 card->rxmb = ++frbuf;
2377 if ((void*)frbuf > card->u.f.rxmb_last)
2378 card->rxmb = card->u.f.rxmb_base;
2379
2380 }
2381
2382 /*==================================================================
2383 * tx_intr: Transmit interrupt handler.
2384 *
2385 * Rationale:
2386 * If the board is busy transmitting, if_send() will
2387 * buffers a single packet and turn on
2388 * the tx interrupt. Tx interrupt will be called
2389 * by the board, once the firmware can send more
2390 * data. Thus, no polling is required.
2391 *
2392 * Description:
2393 * Tx interrupt is called for each
2394 * configured dlci channel. Thus:
2395 * 1. Obtain the netowrk interface based on the
2396 * dlci number.
2397 * 2. Check that network interface is up and
2398 * properly setup.
2399 * 3. Check for a buffered packed.
2400 * 4. Transmit the packed.
2401 * 5. If we are in WANPIPE mode, mark the
2402 * NET_BH handler.
2403 * 6. If we are in API mode, kick
2404 * the AF_WANPIPE socket for more data.
2405 *
2406 */
2407 static void tx_intr(sdla_t *card)
2408 {
2409 fr508_flags_t* flags = card->flags;
2410 fr_tx_buf_ctl_t* bctl;
2411 netdevice_t* dev;
2412 fr_channel_t* chan;
2413
2414 if(card->hw.type == SDLA_S514){
2415 bctl = (void*)(flags->tse_offs + card->hw.dpmbase);
2416 }else{
2417 bctl = (void*)(flags->tse_offs - FR_MB_VECTOR +
2418 card->hw.dpmbase);
2419 }
2420
2421 /* Find the structure and make it unbusy */
2422 dev = find_channel(card, flags->dlci);
2423 if (dev == NULL){
2424 printk(KERN_INFO "NO DEV IN TX Interrupt\n");
2425 goto end_of_tx_intr;
2426 }
2427
2428 if ((chan = dev->priv) == NULL){
2429 printk(KERN_INFO "NO CHAN IN TX Interrupt\n");
2430 goto end_of_tx_intr;
2431 }
2432
2433 if(!chan->transmit_length || !chan->delay_skb) {
2434 printk(KERN_INFO "%s: tx int error - transmit length zero\n",
2435 card->wandev.name);
2436 goto end_of_tx_intr;
2437 }
2438
2439 /* If the 'if_send()' procedure is currently checking the 'tbusy'
2440 status, then we cannot transmit. Instead, we configure the microcode
2441 so as to re-issue this transmit interrupt at a later stage.
2442 */
2443 if (test_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical)) {
2444
2445 fr_dlci_interface_t* dlci_interface = chan->dlci_int_interface;
2446 bctl->flag = 0xA0;
2447 dlci_interface->gen_interrupt |= FR_INTR_TXRDY;
2448 return;
2449
2450 }else{
2451 bctl->dlci = flags->dlci;
2452 bctl->length = chan->transmit_length+chan->fr_header_len;
2453 sdla_poke(&card->hw,
2454 fr_send_hdr(card,bctl->dlci,bctl->offset),
2455 chan->delay_skb->data,
2456 chan->delay_skb->len);
2457 bctl->flag = 0xC0;
2458
2459 ++chan->ifstats.tx_packets;
2460 ++card->wandev.stats.tx_packets;
2461 #if defined(LINUX_2_1) || defined(LINUX_2_4)
2462 chan->ifstats.tx_bytes += chan->transmit_length;
2463 card->wandev.stats.tx_bytes += chan->transmit_length;
2464 #endif
2465
2466 /* We must free an sk buffer, which we used
2467 * for delayed transmission; Otherwise, the sock
2468 * will run out of memory */
2469 wan_dev_kfree_skb(chan->delay_skb, FREE_WRITE);
2470
2471 chan->delay_skb = NULL;
2472 chan->transmit_length = 0;
2473
2474 #ifdef LINUX_2_4
2475 dev->trans_start = jiffies;
2476 #endif
2477
2478 #ifdef LINUX_2_0
2479 wake_net_dev(dev);
2480 #else
2481 if (is_queue_stopped(dev)){
2482 /* If using API, than wakeup socket BH handler */
2483 if (chan->common.usedby == API){
2484 start_net_queue(dev);
2485 wakeup_sk_bh(dev);
2486 }else{
2487 wake_net_dev(dev);
2488 }
2489 }
2490 #endif
2491 }
2492
2493 end_of_tx_intr:
2494
2495 /* if any other interfaces have transmit interrupts pending,
2496 * do not disable the global transmit interrupt */
2497 if(!(-- card->u.f.tx_interrupts_pending))
2498 flags->imask &= ~FR_INTR_TXRDY;
2499
2500
2501 }
2502
2503
2504 /*============================================================================
2505 * timer_intr: Timer interrupt handler.
2506 *
2507 * Rationale:
2508 * All commans must be executed within the timer
2509 * interrupt since no two commands should execute
2510 * at the same time.
2511 *
2512 * Description:
2513 * The timer interrupt is used to:
2514 * 1. Processing udp calls from 'fpipemon'.
2515 * 2. Processing update calls from /proc file system
2516 * 3. Reading board-level statistics for
2517 * updating the proc file system.
2518 * 4. Sending inverse ARP request packets.
2519 * 5. Configure a dlci/channel.
2520 * 6. Unconfigure a dlci/channel. (Node only)
2521 */
2522
2523 static void timer_intr(sdla_t *card)
2524 {
2525 fr508_flags_t* flags = card->flags;
2526
2527 /* UDP Debuging: fpipemon call */
2528 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UDP) {
2529 if(card->u.f.udp_type == UDP_FPIPE_TYPE) {
2530 if(process_udp_mgmt_pkt(card)) {
2531 card->u.f.timer_int_enabled &=
2532 ~TMR_INT_ENABLED_UDP;
2533 }
2534 }
2535 }
2536
2537 /* /proc update call : triggered from update() */
2538 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UPDATE) {
2539 fr_get_err_stats(card);
2540 fr_get_stats(card);
2541 card->u.f.update_comms_stats = 0;
2542 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE;
2543 }
2544
2545 /* Update the channel state call. This is call is
2546 * triggered by if_send() function */
2547 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UPDATE_STATE){
2548 netdevice_t *dev;
2549 if (card->wandev.state == WAN_CONNECTED){
2550 for (dev=card->wandev.dev; dev; dev = *((netdevice_t **)dev->priv)){
2551 fr_channel_t *chan = dev->priv;
2552 if (chan->common.state != WAN_CONNECTED){
2553 update_chan_state(dev);
2554 }
2555 }
2556 }
2557 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UPDATE_STATE;
2558 }
2559
2560 /* configure a dlci/channel */
2561 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_CONFIG){
2562 config_fr(card);
2563 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_CONFIG;
2564 }
2565
2566 /* unconfigure a dlci/channel */
2567 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_UNCONFIG){
2568 unconfig_fr(card);
2569 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UNCONFIG;
2570 }
2571
2572
2573 /* Transmit ARP packets */
2574 if (card->u.f.timer_int_enabled & TMR_INT_ENABLED_ARP){
2575 int i=0;
2576 netdevice_t *dev;
2577
2578 if (card->u.f.arp_dev == NULL)
2579 card->u.f.arp_dev = card->wandev.dev;
2580
2581 dev = card->u.f.arp_dev;
2582
2583 for (;;){
2584
2585 fr_channel_t *chan = dev->priv;
2586
2587 /* If the interface is brought down cancel sending In-ARPs */
2588 if (!(dev->flags&IFF_UP)){
2589 clear_bit(0,&chan->inarp_ready);
2590 }
2591
2592 if (test_bit(0,&chan->inarp_ready)){
2593
2594 if (check_tx_status(card,dev)){
2595 set_bit(ARP_CRIT,&card->wandev.critical);
2596 break;
2597 }
2598
2599 if (!send_inarp_request(card,dev)){
2600 trigger_fr_arp(dev);
2601 chan->inarp_tick = jiffies;
2602 }
2603
2604 clear_bit(0,&chan->inarp_ready);
2605 dev = move_dev_to_next(card,dev);
2606 break;
2607 }
2608 dev = move_dev_to_next(card,dev);
2609
2610 if (++i == card->wandev.new_if_cnt){
2611 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_ARP;
2612 break;
2613 }
2614 }
2615 card->u.f.arp_dev = dev;
2616 }
2617
2618 if(!card->u.f.timer_int_enabled)
2619 flags->imask &= ~FR_INTR_TIMER;
2620 }
2621
2622
2623 /*============================================================================
2624 * spur_intr: Spurious interrupt handler.
2625 *
2626 * Description:
2627 * We don't know this interrupt.
2628 * Print a warning.
2629 */
2630
2631 static void spur_intr (sdla_t* card)
2632 {
2633 if (net_ratelimit()){
2634 printk(KERN_INFO "%s: spurious interrupt!\n", card->devname);
2635 }
2636 }
2637
2638
2639 //FIXME: Fix the IPX in next version
2640 /*===========================================================================
2641 * Return 0 for non-IPXWAN packet
2642 * 1 for IPXWAN packet or IPX is not enabled!
2643 * FIXME: Use a IPX structure here not offsets
2644 */
2645 static int handle_IPXWAN(unsigned char *sendpacket,
2646 char *devname, unsigned char enable_IPX,
2647 unsigned long network_number)
2648 {
2649 int i;
2650
2651 if( sendpacket[1] == 0x00 && sendpacket[2] == 0x80 &&
2652 sendpacket[6] == 0x81 && sendpacket[7] == 0x37) {
2653
2654 /* It's an IPX packet */
2655 if (!enable_IPX){
2656 /* Return 1 so we don't pass it up the stack. */
2657 //FIXME: Take this out when IPX is fixed
2658 if (net_ratelimit()){
2659 printk (KERN_INFO
2660 "%s: WARNING: Unsupported IPX packet received and dropped\n",
2661 devname);
2662 }
2663 return 1;
2664 }
2665 } else {
2666 /* It's not IPX so return and pass it up the stack. */
2667 return 0;
2668 }
2669
2670 if( sendpacket[24] == 0x90 && sendpacket[25] == 0x04){
2671 /* It's IPXWAN */
2672
2673 if( sendpacket[10] == 0x02 && sendpacket[42] == 0x00){
2674
2675 /* It's a timer request packet */
2676 printk(KERN_INFO "%s: Received IPXWAN Timer Request packet\n",
2677 devname);
2678
2679 /* Go through the routing options and answer no to every
2680 * option except Unnumbered RIP/SAP
2681 */
2682 for(i = 49; sendpacket[i] == 0x00; i += 5){
2683 /* 0x02 is the option for Unnumbered RIP/SAP */
2684 if( sendpacket[i + 4] != 0x02){
2685 sendpacket[i + 1] = 0;
2686 }
2687 }
2688
2689 /* Skip over the extended Node ID option */
2690 if( sendpacket[i] == 0x04 ){
2691 i += 8;
2692 }
2693
2694 /* We also want to turn off all header compression opt.
2695 */
2696 for(; sendpacket[i] == 0x80 ;){
2697 sendpacket[i + 1] = 0;
2698 i += (sendpacket[i + 2] << 8) + (sendpacket[i + 3]) + 4;
2699 }
2700
2701 /* Set the packet type to timer response */
2702 sendpacket[42] = 0x01;
2703
2704 printk(KERN_INFO "%s: Sending IPXWAN Timer Response\n",
2705 devname);
2706
2707 } else if( sendpacket[42] == 0x02 ){
2708
2709 /* This is an information request packet */
2710 printk(KERN_INFO
2711 "%s: Received IPXWAN Information Request packet\n",
2712 devname);
2713
2714 /* Set the packet type to information response */
2715 sendpacket[42] = 0x03;
2716
2717 /* Set the router name */
2718 sendpacket[59] = 'F';
2719 sendpacket[60] = 'P';
2720 sendpacket[61] = 'I';
2721 sendpacket[62] = 'P';
2722 sendpacket[63] = 'E';
2723 sendpacket[64] = '-';
2724 sendpacket[65] = CVHexToAscii(network_number >> 28);
2725 sendpacket[66] = CVHexToAscii((network_number & 0x0F000000)>> 24);
2726 sendpacket[67] = CVHexToAscii((network_number & 0x00F00000)>> 20);
2727 sendpacket[68] = CVHexToAscii((network_number & 0x000F0000)>> 16);
2728 sendpacket[69] = CVHexToAscii((network_number & 0x0000F000)>> 12);
2729 sendpacket[70] = CVHexToAscii((network_number & 0x00000F00)>> 8);
2730 sendpacket[71] = CVHexToAscii((network_number & 0x000000F0)>> 4);
2731 sendpacket[72] = CVHexToAscii(network_number & 0x0000000F);
2732 for(i = 73; i < 107; i+= 1)
2733 {
2734 sendpacket[i] = 0;
2735 }
2736
2737 printk(KERN_INFO "%s: Sending IPXWAN Information Response packet\n",
2738 devname);
2739 } else {
2740
2741 printk(KERN_INFO "%s: Unknown IPXWAN packet!\n",devname);
2742 return 0;
2743 }
2744
2745 /* Set the WNodeID to our network address */
2746 sendpacket[43] = (unsigned char)(network_number >> 24);
2747 sendpacket[44] = (unsigned char)((network_number & 0x00FF0000) >> 16);
2748 sendpacket[45] = (unsigned char)((network_number & 0x0000FF00) >> 8);
2749 sendpacket[46] = (unsigned char)(network_number & 0x000000FF);
2750
2751 return 1;
2752 }
2753
2754 /* If we get here, its an IPX-data packet so it'll get passed up the
2755 * stack.
2756 * switch the network numbers
2757 */
2758 switch_net_numbers(sendpacket, network_number ,1);
2759 return 0;
2760 }
2761 /*============================================================================
2762 * process_route
2763 *
2764 * Rationale:
2765 * If the interface goes down, or we receive an ARP request,
2766 * we have to change the network interface ip addresses.
2767 * This cannot be done within the interrupt.
2768 *
2769 * Description:
2770 *
2771 * This routine is called as a polling routine to dynamically
2772 * add/delete routes negotiated by inverse ARP. It is in this
2773 * "task" because we don't want routes to be added while in
2774 * interrupt context.
2775 *
2776 * Usage:
2777 * This function is called by fr_poll() polling funtion.
2778 */
2779
2780 static void process_route (netdevice_t *dev)
2781 {
2782 fr_channel_t *chan = dev->priv;
2783 sdla_t *card = chan->card;
2784
2785 #if defined(LINUX_2_1) || defined(LINUX_2_4)
2786
2787 struct ifreq if_info;
2788 struct sockaddr_in *if_data;
2789 mm_segment_t fs = get_fs();
2790 u32 ip_tmp;
2791 int err;
2792
2793
2794 switch(chan->route_flag){
2795
2796 case ADD_ROUTE:
2797
2798 /* Set remote addresses */
2799 memset(&if_info, 0, sizeof(if_info));
2800 strcpy(if_info.ifr_name, dev->name);
2801
2802 set_fs(get_ds()); /* get user space block */
2803
2804 if_data = (struct sockaddr_in *)&if_info.ifr_dstaddr;
2805 if_data->sin_addr.s_addr = chan->ip_remote;
2806 if_data->sin_family = AF_INET;
2807 err = devinet_ioctl( SIOCSIFDSTADDR, &if_info );
2808
2809 set_fs(fs); /* restore old block */
2810
2811 if (err) {
2812
2813 printk(KERN_INFO
2814 "%s: Route Add failed. Error: %d\n",
2815 card->devname,err);
2816 printk(KERN_INFO "%s: Address: %s\n",
2817 chan->name, in_ntoa(chan->ip_remote));
2818
2819 }else {
2820 printk(KERN_INFO "%s: Route Added Successfully: %s\n",
2821 card->devname,in_ntoa(chan->ip_remote));
2822 chan->route_flag = ROUTE_ADDED;
2823 }
2824 break;
2825
2826 case REMOVE_ROUTE:
2827
2828 /* Set remote addresses */
2829 memset(&if_info, 0, sizeof(if_info));
2830 strcpy(if_info.ifr_name, dev->name);
2831
2832 ip_tmp = get_ip_address(dev,WAN_POINTOPOINT_IP);
2833
2834 set_fs(get_ds()); /* get user space block */
2835
2836 if_data = (struct sockaddr_in *)&if_info.ifr_dstaddr;
2837 if_data->sin_addr.s_addr = 0;
2838 if_data->sin_family = AF_INET;
2839 err = devinet_ioctl( SIOCSIFDSTADDR, &if_info );
2840
2841 set_fs(fs);
2842
2843 if (err) {
2844
2845 printk(KERN_INFO
2846 "%s: Deleting of route failed. Error: %d\n",
2847 card->devname,err);
2848 printk(KERN_INFO "%s: Address: %s\n",
2849 dev->name,in_ntoa(chan->ip_remote) );
2850
2851 } else {
2852
2853 printk(KERN_INFO "%s: Route Removed Sucessfuly: %s\n",
2854 card->devname,in_ntoa(ip_tmp));
2855 chan->route_flag = NO_ROUTE;
2856 }
2857 break;
2858
2859 } /* Case Statement */
2860
2861 #else
2862 /* Dynamic Route adding/removing */
2863 struct rtentry route;
2864 int err = 0;
2865 unsigned long fs = get_fs();
2866
2867 memset(&route, 0, sizeof(route));
2868 route.rt_dev = dev->name;
2869 route.rt_flags = 0;
2870
2871 ((struct sockaddr_in *) &(route.rt_dst)) ->
2872 sin_addr.s_addr=dev->pa_dstaddr;
2873 ((struct sockaddr_in *) &(route.rt_dst)) ->
2874 sin_family = AF_INET;
2875 ((struct sockaddr_in *) &(route.rt_genmask)) ->
2876 sin_addr.s_addr = 0xFFFFFFFF;
2877 ((struct sockaddr_in *) &(route.rt_genmask)) ->
2878 sin_family = AF_INET;
2879 switch(chan->route_flag) {
2880
2881 case ADD_ROUTE:
2882
2883 set_fs(get_ds()); /* get user space block */
2884 err = ip_rt_new(&route);
2885 set_fs(fs); /* restore old block */
2886
2887 if (err) {
2888 printk(KERN_INFO "%s: Adding of route failed. Error: %d\n",
2889 card->devname,err);
2890 printk(KERN_INFO "%s: Address: %s\n",
2891 chan->name, in_ntoa(dev->pa_dstaddr) );
2892 }
2893 else {
2894 chan->route_flag = ROUTE_ADDED;
2895 }
2896 break;
2897
2898 case REMOVE_ROUTE:
2899
2900 set_fs(get_ds()); /* get user space block */
2901 err = ip_rt_kill(&route);
2902 set_fs(fs); /* restore old block */
2903
2904 if (err) {
2905
2906 printk(KERN_INFO "%s: Deleting of route failed. Error: %d\n",
2907 card->devname,err);
2908 printk(KERN_INFO "%s: Address: %s\n",
2909 dev->name,in_ntoa(dev->pa_dstaddr) );
2910 } else {
2911
2912 printk(KERN_INFO "%s: Removed route.\n",
2913 ((fr_channel_t*)dev->priv)->name);
2914 chan->route_flag = NO_ROUTE;
2915
2916 }
2917 break;
2918 }
2919
2920 #endif
2921
2922 }
2923
2924
2925
2926 /****** Frame Relay Firmware-Specific Functions *****************************/
2927
2928 /*============================================================================
2929 * Read firmware code version.
2930 * o fill string str with firmware version info.
2931 */
2932 static int fr_read_version (sdla_t* card, char* str)
2933 {
2934 fr_mbox_t* mbox = card->mbox;
2935 int retry = MAX_CMD_RETRY;
2936 int err;
2937
2938 do
2939 {
2940 mbox->cmd.command = FR_READ_CODE_VERSION;
2941 mbox->cmd.length = 0;
2942 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2943 } while (err && retry-- && fr_event(card, err, mbox));
2944
2945 if (!err && str) {
2946 int len = mbox->cmd.length;
2947 memcpy(str, mbox->data, len);
2948 str[len] = '\0';
2949 }
2950 return err;
2951 }
2952
2953 /*============================================================================
2954 * Set global configuration.
2955 */
2956 static int fr_configure (sdla_t* card, fr_conf_t *conf)
2957 {
2958 fr_mbox_t* mbox = card->mbox;
2959 int retry = MAX_CMD_RETRY;
2960 int dlci_num = card->u.f.dlci_num;
2961 int err, i;
2962
2963 do
2964 {
2965 memcpy(mbox->data, conf, sizeof(fr_conf_t));
2966
2967 if (dlci_num) for (i = 0; i < dlci_num; ++i)
2968 ((fr_conf_t*)mbox->data)->dlci[i] =
2969 card->u.f.node_dlci[i];
2970
2971 mbox->cmd.command = FR_SET_CONFIG;
2972 mbox->cmd.length =
2973 sizeof(fr_conf_t) + dlci_num * sizeof(short);
2974
2975 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
2976
2977 } while (err && retry-- && fr_event(card, err, mbox));
2978
2979 /*NC Oct 12 2000 */
2980 if (err != CMD_OK){
2981 printk(KERN_ERR "%s: Frame Relay Configuration Failed: rc=0x%x\n",
2982 card->devname,err);
2983 }
2984
2985 return err;
2986 }
2987
2988 /*============================================================================
2989 * Set DLCI configuration.
2990 */
2991 static int fr_dlci_configure (sdla_t* card, fr_dlc_conf_t *conf, unsigned dlci)
2992 {
2993 fr_mbox_t* mbox = card->mbox;
2994 int retry = MAX_CMD_RETRY;
2995 int err;
2996
2997 do
2998 {
2999 memcpy(mbox->data, conf, sizeof(fr_dlc_conf_t));
3000 mbox->cmd.dlci = (unsigned short) dlci;
3001 mbox->cmd.command = FR_SET_CONFIG;
3002 mbox->cmd.length = sizeof(fr_dlc_conf_t);
3003 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3004 } while (err && retry--);
3005
3006 return err;
3007 }
3008 /*============================================================================
3009 * Set interrupt mode.
3010 */
3011 static int fr_set_intr_mode (sdla_t* card, unsigned mode, unsigned mtu,
3012 unsigned short timeout)
3013 {
3014 fr_mbox_t* mbox = card->mbox;
3015 fr508_intr_ctl_t* ictl = (void*)mbox->data;
3016 int retry = MAX_CMD_RETRY;
3017 int err;
3018
3019 do
3020 {
3021 memset(ictl, 0, sizeof(fr508_intr_ctl_t));
3022 ictl->mode = mode;
3023 ictl->tx_len = mtu;
3024 ictl->irq = card->hw.irq;
3025
3026 /* indicate timeout on timer */
3027 if (mode & 0x20) ictl->timeout = timeout;
3028
3029 mbox->cmd.length = sizeof(fr508_intr_ctl_t);
3030 mbox->cmd.command = FR_SET_INTR_MODE;
3031 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3032
3033 } while (err && retry-- && fr_event(card, err, mbox));
3034
3035 return err;
3036 }
3037
3038 /*============================================================================
3039 * Enable communications.
3040 */
3041 static int fr_comm_enable (sdla_t* card)
3042 {
3043 fr_mbox_t* mbox = card->mbox;
3044 int retry = MAX_CMD_RETRY;
3045 int err;
3046
3047 do
3048 {
3049 mbox->cmd.command = FR_COMM_ENABLE;
3050 mbox->cmd.length = 0;
3051 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3052 } while (err && retry-- && fr_event(card, err, mbox));
3053
3054 return err;
3055 }
3056
3057 /*============================================================================
3058 * fr_comm_disable
3059 *
3060 * Warning: This functin is called by the shutdown() procedure. It is void
3061 * since dev->priv are has already been deallocated and no
3062 * error checking is possible using fr_event() function.
3063 */
3064 static void fr_comm_disable (sdla_t* card)
3065 {
3066 fr_mbox_t* mbox = card->mbox;
3067 int retry = MAX_CMD_RETRY;
3068 int err;
3069
3070 do {
3071 mbox->cmd.command = FR_SET_MODEM_STATUS;
3072 mbox->cmd.length = 1;
3073 mbox->data[0] = 0;
3074 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3075 } while (err && retry--);
3076
3077 retry = MAX_CMD_RETRY;
3078
3079 do
3080 {
3081 mbox->cmd.command = FR_COMM_DISABLE;
3082 mbox->cmd.length = 0;
3083 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3084 } while (err && retry--);
3085
3086 return;
3087 }
3088
3089
3090
3091 /*============================================================================
3092 * Get communications error statistics.
3093 */
3094 static int fr_get_err_stats (sdla_t* card)
3095 {
3096 fr_mbox_t* mbox = card->mbox;
3097 int retry = MAX_CMD_RETRY;
3098 int err;
3099
3100
3101 do
3102 {
3103 mbox->cmd.command = FR_READ_ERROR_STATS;
3104 mbox->cmd.length = 0;
3105 mbox->cmd.dlci = 0;
3106 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3107 } while (err && retry-- && fr_event(card, err, mbox));
3108
3109 if (!err) {
3110 fr_comm_stat_t* stats = (void*)mbox->data;
3111 card->wandev.stats.rx_over_errors = stats->rx_overruns;
3112 card->wandev.stats.rx_crc_errors = stats->rx_bad_crc;
3113 card->wandev.stats.rx_missed_errors = stats->rx_aborts;
3114 card->wandev.stats.rx_length_errors = stats->rx_too_long;
3115 card->wandev.stats.tx_aborted_errors = stats->tx_aborts;
3116
3117 }
3118
3119 return err;
3120 }
3121
3122 /*============================================================================
3123 * Get statistics.
3124 */
3125 static int fr_get_stats (sdla_t* card)
3126 {
3127 fr_mbox_t* mbox = card->mbox;
3128 int retry = MAX_CMD_RETRY;
3129 int err;
3130
3131
3132 do
3133 {
3134 mbox->cmd.command = FR_READ_STATISTICS;
3135 mbox->cmd.length = 0;
3136 mbox->cmd.dlci = 0;
3137 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3138 } while (err && retry-- && fr_event(card, err, mbox));
3139
3140 if (!err) {
3141 fr_link_stat_t* stats = (void*)mbox->data;
3142 card->wandev.stats.rx_frame_errors = stats->rx_bad_format;
3143 card->wandev.stats.rx_dropped =
3144 stats->rx_dropped + stats->rx_dropped2;
3145 }
3146
3147 return err;
3148 }
3149
3150 /*============================================================================
3151 * Add DLCI(s) (Access Node only!).
3152 * This routine will perform the ADD_DLCIs command for the specified DLCI.
3153 */
3154 static int fr_add_dlci (sdla_t* card, int dlci)
3155 {
3156 fr_mbox_t* mbox = card->mbox;
3157 int retry = MAX_CMD_RETRY;
3158 int err;
3159
3160 do
3161 {
3162 unsigned short* dlci_list = (void*)mbox->data;
3163
3164 mbox->cmd.length = sizeof(short);
3165 dlci_list[0] = dlci;
3166 mbox->cmd.command = FR_ADD_DLCI;
3167 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3168
3169 } while (err && retry-- && fr_event(card, err, mbox));
3170
3171 return err;
3172 }
3173
3174 /*============================================================================
3175 * Activate DLCI(s) (Access Node only!).
3176 * This routine will perform the ACTIVATE_DLCIs command with a DLCI number.
3177 */
3178 static int fr_activate_dlci (sdla_t* card, int dlci)
3179 {
3180 fr_mbox_t* mbox = card->mbox;
3181 int retry = MAX_CMD_RETRY;
3182 int err;
3183
3184 do
3185 {
3186 unsigned short* dlci_list = (void*)mbox->data;
3187
3188 mbox->cmd.length = sizeof(short);
3189 dlci_list[0] = dlci;
3190 mbox->cmd.command = FR_ACTIVATE_DLCI;
3191 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3192
3193 } while (err && retry-- && fr_event(card, err, mbox));
3194
3195 return err;
3196 }
3197
3198 /*============================================================================
3199 * Delete DLCI(s) (Access Node only!).
3200 * This routine will perform the DELETE_DLCIs command with a DLCI number.
3201 */
3202 static int fr_delete_dlci (sdla_t* card, int dlci)
3203 {
3204 fr_mbox_t* mbox = card->mbox;
3205 int retry = MAX_CMD_RETRY;
3206 int err;
3207
3208 do
3209 {
3210 unsigned short* dlci_list = (void*)mbox->data;
3211
3212 mbox->cmd.length = sizeof(short);
3213 dlci_list[0] = dlci;
3214 mbox->cmd.command = FR_DELETE_DLCI;
3215 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3216
3217 } while (err && retry-- && fr_event(card, err, mbox));
3218
3219 return err;
3220 }
3221
3222
3223
3224 /*============================================================================
3225 * Issue in-channel signalling frame.
3226 */
3227 static int fr_issue_isf (sdla_t* card, int isf)
3228 {
3229 fr_mbox_t* mbox = card->mbox;
3230 int retry = MAX_CMD_RETRY;
3231 int err;
3232
3233 do
3234 {
3235 mbox->data[0] = isf;
3236 mbox->cmd.length = 1;
3237 mbox->cmd.command = FR_ISSUE_IS_FRAME;
3238 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3239 } while (err && retry-- && fr_event(card, err, mbox));
3240
3241 return err;
3242 }
3243
3244
3245 static unsigned int fr_send_hdr (sdla_t*card, int dlci, unsigned int offset)
3246 {
3247 netdevice_t *dev = find_channel(card,dlci);
3248 fr_channel_t *chan;
3249
3250 if (!dev || !(chan=dev->priv))
3251 return offset;
3252
3253 if (chan->fr_header_len){
3254 sdla_poke(&card->hw, offset, chan->fr_header, chan->fr_header_len);
3255 }
3256
3257 return offset+chan->fr_header_len;
3258 }
3259
3260 /*============================================================================
3261 * Send a frame on a selected DLCI.
3262 */
3263 static int fr_send_data_header (sdla_t* card, int dlci, unsigned char attr, int len,
3264 void *buf, unsigned char hdr_len)
3265 {
3266 fr_mbox_t* mbox = card->mbox + 0x800;
3267 int retry = MAX_CMD_RETRY;
3268 int err;
3269
3270 do
3271 {
3272 mbox->cmd.dlci = dlci;
3273 mbox->cmd.attr = attr;
3274 mbox->cmd.length = len+hdr_len;
3275 mbox->cmd.command = FR_WRITE;
3276 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3277 } while (err && retry-- && fr_event(card, err, mbox));
3278
3279 if (!err) {
3280 fr_tx_buf_ctl_t* frbuf;
3281
3282 if(card->hw.type == SDLA_S514)
3283 frbuf = (void*)(*(unsigned long*)mbox->data +
3284 card->hw.dpmbase);
3285 else
3286 frbuf = (void*)(*(unsigned long*)mbox->data -
3287 FR_MB_VECTOR + card->hw.dpmbase);
3288
3289 sdla_poke(&card->hw, fr_send_hdr(card,dlci,frbuf->offset), buf, len);
3290 frbuf->flag = 0x01;
3291 }
3292
3293 return err;
3294 }
3295
3296 static int fr_send (sdla_t* card, int dlci, unsigned char attr, int len,
3297 void *buf)
3298 {
3299 fr_mbox_t* mbox = card->mbox + 0x800;
3300 int retry = MAX_CMD_RETRY;
3301 int err;
3302
3303 do
3304 {
3305 mbox->cmd.dlci = dlci;
3306 mbox->cmd.attr = attr;
3307 mbox->cmd.length = len;
3308 mbox->cmd.command = FR_WRITE;
3309 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3310 } while (err && retry-- && fr_event(card, err, mbox));
3311
3312 if (!err) {
3313 fr_tx_buf_ctl_t* frbuf;
3314
3315 if(card->hw.type == SDLA_S514)
3316 frbuf = (void*)(*(unsigned long*)mbox->data +
3317 card->hw.dpmbase);
3318 else
3319 frbuf = (void*)(*(unsigned long*)mbox->data -
3320 FR_MB_VECTOR + card->hw.dpmbase);
3321
3322 sdla_poke(&card->hw, frbuf->offset, buf, len);
3323 frbuf->flag = 0x01;
3324 }
3325
3326 return err;
3327 }
3328
3329
3330 /****** Firmware Asynchronous Event Handlers ********************************/
3331
3332 /*============================================================================
3333 * Main asyncronous event/error handler.
3334 * This routine is called whenever firmware command returns non-zero
3335 * return code.
3336 *
3337 * Return zero if previous command has to be cancelled.
3338 */
3339 static int fr_event (sdla_t *card, int event, fr_mbox_t* mbox)
3340 {
3341 fr508_flags_t* flags = card->flags;
3342 char *ptr = &flags->iflag;
3343 int i;
3344
3345 switch (event) {
3346
3347 case FRRES_MODEM_FAILURE:
3348 return fr_modem_failure(card, mbox);
3349
3350 case FRRES_CHANNEL_DOWN:
3351 {
3352 netdevice_t *dev;
3353
3354 /* Remove all routes from associated DLCI's */
3355 for (dev = card->wandev.dev; dev; dev = *((netdevice_t **)dev->priv)) {
3356 fr_channel_t *chan = dev->priv;
3357 if (chan->route_flag == ROUTE_ADDED) {
3358 chan->route_flag = REMOVE_ROUTE;
3359 }
3360
3361 if (chan->inarp == INARP_CONFIGURED) {
3362 chan->inarp = INARP_REQUEST;
3363 }
3364
3365 /* If the link becomes disconnected then,
3366 * all channels will be disconnected
3367 * as well.
3368 */
3369 set_chan_state(dev,WAN_DISCONNECTED);
3370 }
3371
3372 wanpipe_set_state(card, WAN_DISCONNECTED);
3373 return 1;
3374 }
3375
3376 case FRRES_CHANNEL_UP:
3377 {
3378 netdevice_t *dev;
3379
3380 /* FIXME: Only startup devices that are on the list */
3381
3382 for (dev = card->wandev.dev; dev; dev = *((netdevice_t **)dev->priv)) {
3383
3384 set_chan_state(dev,WAN_CONNECTED);
3385 }
3386
3387 wanpipe_set_state(card, WAN_CONNECTED);
3388 return 1;
3389 }
3390
3391 case FRRES_DLCI_CHANGE:
3392 return fr_dlci_change(card, mbox);
3393
3394 case FRRES_DLCI_MISMATCH:
3395 printk(KERN_INFO "%s: DLCI list mismatch!\n",
3396 card->devname);
3397 return 1;
3398
3399 case CMD_TIMEOUT:
3400 printk(KERN_ERR "%s: command 0x%02X timed out!\n",
3401 card->devname, mbox->cmd.command);
3402 printk(KERN_INFO "%s: ID Bytes = ",card->devname);
3403 for(i = 0; i < 8; i ++)
3404 printk(KERN_INFO "0x%02X ", *(ptr + 0x18 + i));
3405 printk(KERN_INFO "\n");
3406
3407 break;
3408
3409 case FRRES_DLCI_INACTIVE:
3410 break;
3411
3412 case FRRES_CIR_OVERFLOW:
3413 break;
3414
3415 case FRRES_BUFFER_OVERFLOW:
3416 break;
3417
3418 default:
3419 printk(KERN_INFO "%s: command 0x%02X returned 0x%02X!\n"
3420 , card->devname, mbox->cmd.command, event);
3421 }
3422
3423 return 0;
3424 }
3425
3426 /*============================================================================
3427 * Handle modem error.
3428 *
3429 * Return zero if previous command has to be cancelled.
3430 */
3431 static int fr_modem_failure (sdla_t *card, fr_mbox_t* mbox)
3432 {
3433 printk(KERN_INFO "%s: physical link down! (modem error 0x%02X)\n",
3434 card->devname, mbox->data[0]);
3435
3436 switch (mbox->cmd.command){
3437 case FR_WRITE:
3438
3439 case FR_READ:
3440 return 0;
3441 }
3442
3443 return 1;
3444 }
3445
3446 /*============================================================================
3447 * Handle DLCI status change.
3448 *
3449 * Return zero if previous command has to be cancelled.
3450 */
3451 static int fr_dlci_change (sdla_t *card, fr_mbox_t* mbox)
3452 {
3453 dlci_status_t* status = (void*)mbox->data;
3454 int cnt = mbox->cmd.length / sizeof(dlci_status_t);
3455 fr_channel_t *chan;
3456 netdevice_t* dev2;
3457
3458
3459 for (; cnt; --cnt, ++status) {
3460
3461 unsigned short dlci= status->dlci;
3462 netdevice_t* dev = find_channel(card, dlci);
3463
3464 if (dev == NULL){
3465 printk(KERN_INFO
3466 "%s: CPE contains unconfigured DLCI= %d\n",
3467 card->devname, dlci);
3468
3469 printk(KERN_INFO
3470 "%s: unconfigured DLCI %d reported by network\n"
3471 , card->devname, dlci);
3472
3473 }else{
3474 if (status->state == FR_LINK_INOPER) {
3475 printk(KERN_INFO
3476 "%s: DLCI %u is inactive!\n",
3477 card->devname, dlci);
3478
3479 if (dev && is_dev_running(dev))
3480 set_chan_state(dev, WAN_DISCONNECTED);
3481 }
3482
3483 if (status->state & FR_DLCI_DELETED) {
3484
3485 printk(KERN_INFO
3486 "%s: DLCI %u has been deleted!\n",
3487 card->devname, dlci);
3488
3489 if (dev && is_dev_running(dev)){
3490
3491 fr_channel_t *chan = dev->priv;
3492
3493 if (chan->route_flag == ROUTE_ADDED) {
3494 chan->route_flag = REMOVE_ROUTE;
3495 /* The state change will trigger
3496 * the fr polling routine */
3497 }
3498
3499 if (chan->inarp == INARP_CONFIGURED) {
3500 chan->inarp = INARP_REQUEST;
3501 }
3502
3503 set_chan_state(dev, WAN_DISCONNECTED);
3504 }
3505
3506 } else if (status->state & FR_DLCI_ACTIVE) {
3507
3508 chan = dev->priv;
3509
3510 /* This flag is used for configuring specific
3511 DLCI(s) when they become active.
3512 */
3513 chan->dlci_configured = DLCI_CONFIG_PENDING;
3514
3515 set_chan_state(dev, WAN_CONNECTED);
3516
3517 }
3518 }
3519 }
3520
3521 for (dev2 =card->wandev.dev; dev2; dev2 = *((netdevice_t **)dev2->priv)){
3522
3523 chan = dev2->priv;
3524
3525 if (chan->dlci_configured == DLCI_CONFIG_PENDING) {
3526 if (fr_init_dlci(card, chan)){
3527 return 1;
3528 }
3529 }
3530
3531 }
3532 return 1;
3533 }
3534
3535
3536 static int fr_init_dlci (sdla_t *card, fr_channel_t *chan)
3537 {
3538 fr_dlc_conf_t cfg;
3539
3540 memset(&cfg, 0, sizeof(cfg));
3541
3542 if ( chan->cir_status == CIR_DISABLED) {
3543
3544 cfg.cir_fwd = cfg.cir_bwd = 16;
3545 cfg.bc_fwd = cfg.bc_bwd = 16;
3546 cfg.conf_flags = 0x0001;
3547
3548 }else if (chan->cir_status == CIR_ENABLED) {
3549
3550 cfg.cir_fwd = cfg.cir_bwd = chan->cir;
3551 cfg.bc_fwd = cfg.bc_bwd = chan->bc;
3552 cfg.be_fwd = cfg.be_bwd = chan->be;
3553 cfg.conf_flags = 0x0000;
3554 }
3555
3556 if (fr_dlci_configure( card, &cfg , chan->dlci)){
3557 printk(KERN_INFO
3558 "%s: DLCI Configure failed for %d\n",
3559 card->devname, chan->dlci);
3560 return 1;
3561 }
3562
3563 chan->dlci_configured = DLCI_CONFIGURED;
3564
3565 /* Read the interface byte mapping into the channel
3566 * structure.
3567 */
3568 read_DLCI_IB_mapping( card, chan );
3569
3570 return 0;
3571 }
3572 /******* Miscellaneous ******************************************************/
3573
3574 /*============================================================================
3575 * Update channel state.
3576 */
3577 static int update_chan_state (netdevice_t* dev)
3578 {
3579 fr_channel_t* chan = dev->priv;
3580 sdla_t* card = chan->card;
3581 fr_mbox_t* mbox = card->mbox;
3582 int retry = MAX_CMD_RETRY;
3583 int err;
3584
3585 do
3586 {
3587 mbox->cmd.command = FR_LIST_ACTIVE_DLCI;
3588 mbox->cmd.length = 0;
3589 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
3590 } while (err && retry-- && fr_event(card, err, mbox));
3591
3592 if (!err) {
3593
3594 unsigned short* list = (void*)mbox->data;
3595 int cnt = mbox->cmd.length / sizeof(short);
3596
3597 err=1;
3598
3599 for (; cnt; --cnt, ++list) {
3600
3601 if (*list == chan->dlci) {
3602 set_chan_state(dev, WAN_CONNECTED);
3603
3604
3605 /* May 23 2000. NC
3606 * When a dlci is added or restarted,
3607 * the dlci_int_interface pointer must
3608 * be reinitialized. */
3609 if (!chan->dlci_int_interface){
3610 err=fr_init_dlci (card,chan);
3611 }
3612 break;
3613 }
3614 }
3615 }
3616
3617 return err;
3618 }
3619
3620 /*============================================================================
3621 * Set channel state.
3622 */
3623 static void set_chan_state (netdevice_t* dev, int state)
3624 {
3625 fr_channel_t* chan = dev->priv;
3626 sdla_t* card = chan->card;
3627
3628 if (chan->common.state != state) {
3629
3630 switch (state) {
3631
3632 case WAN_CONNECTED:
3633 printk(KERN_INFO
3634 "%s: Interface %s: DLCI %d connected\n",
3635 card->devname, dev->name, chan->dlci);
3636
3637 /* If the interface was previoulsy down,
3638 * bring it up, since the channel is active */
3639
3640 trigger_fr_poll (dev);
3641 trigger_fr_arp (dev);
3642 break;
3643
3644 case WAN_CONNECTING:
3645 printk(KERN_INFO
3646 "%s: Interface %s: DLCI %d connecting\n",
3647 card->devname, dev->name, chan->dlci);
3648 break;
3649
3650 case WAN_DISCONNECTED:
3651 printk (KERN_INFO
3652 "%s: Interface %s: DLCI %d disconnected!\n",
3653 card->devname, dev->name, chan->dlci);
3654
3655 /* If the interface is up, bring it down,
3656 * since the channel is now disconnected */
3657 trigger_fr_poll (dev);
3658 break;
3659 }
3660
3661 chan->common.state = state;
3662 }
3663
3664 chan->state_tick = jiffies;
3665 }
3666
3667 /*============================================================================
3668 * Find network device by its channel number.
3669 *
3670 * We need this critical flag because we change
3671 * the dlci_to_dev_map outside the interrupt.
3672 *
3673 * NOTE: del_if() functions updates this array, it uses
3674 * the spin locks to avoid corruption.
3675 */
3676 static netdevice_t* find_channel (sdla_t* card, unsigned dlci)
3677 {
3678 if(dlci > HIGHEST_VALID_DLCI)
3679 return NULL;
3680
3681 return(card->u.f.dlci_to_dev_map[dlci]);
3682 }
3683
3684 /*============================================================================
3685 * Check to see if a frame can be sent. If no transmit buffers available,
3686 * enable transmit interrupts.
3687 *
3688 * Return: 1 - Tx buffer(s) available
3689 * 0 - no buffers available
3690 */
3691 static int is_tx_ready (sdla_t* card, fr_channel_t* chan)
3692 {
3693 unsigned char sb;
3694
3695 if(card->hw.type == SDLA_S514)
3696 return 1;
3697
3698 sb = inb(card->hw.port);
3699 if (sb & 0x02)
3700 return 1;
3701
3702 return 0;
3703 }
3704
3705 /*============================================================================
3706 * Convert decimal string to unsigned integer.
3707 * If len != 0 then only 'len' characters of the string are converted.
3708 */
3709 static unsigned int dec_to_uint (unsigned char* str, int len)
3710 {
3711 unsigned val;
3712
3713 if (!len)
3714 len = strlen(str);
3715
3716 for (val = 0; len && is_digit(*str); ++str, --len)
3717 val = (val * 10) + (*str - (unsigned)'0');
3718
3719 return val;
3720 }
3721
3722
3723
3724 /*=============================================================================
3725 * Store a UDP management packet for later processing.
3726 */
3727
3728 static int store_udp_mgmt_pkt(int udp_type, char udp_pkt_src, sdla_t* card,
3729 struct sk_buff *skb, int dlci)
3730 {
3731 int udp_pkt_stored = 0;
3732
3733 netdevice_t *dev=find_channel(card,dlci);
3734 fr_channel_t *chan;
3735
3736 if (!dev || !(chan=dev->priv))
3737 return 1;
3738
3739 if(!card->u.f.udp_pkt_lgth && (skb->len <= MAX_LGTH_UDP_MGNT_PKT)){
3740 card->u.f.udp_pkt_lgth = skb->len + chan->fr_header_len;
3741 card->u.f.udp_type = udp_type;
3742 card->u.f.udp_pkt_src = udp_pkt_src;
3743 card->u.f.udp_dlci = dlci;
3744 memcpy(card->u.f.udp_pkt_data, skb->data, skb->len);
3745 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UDP;
3746 udp_pkt_stored = 1;
3747
3748 }else{
3749 printk(KERN_INFO "ERROR: UDP packet not stored for DLCI %d\n",
3750 dlci);
3751 }
3752
3753 if(udp_pkt_src == UDP_PKT_FRM_STACK){
3754 wan_dev_kfree_skb(skb, FREE_WRITE);
3755 }else{
3756 wan_dev_kfree_skb(skb, FREE_READ);
3757 }
3758
3759 return(udp_pkt_stored);
3760 }
3761
3762
3763 /*==============================================================================
3764 * Process UDP call of type FPIPE8ND
3765 */
3766 static int process_udp_mgmt_pkt(sdla_t* card)
3767 {
3768
3769 int c_retry = MAX_CMD_RETRY;
3770 unsigned char *buf;
3771 unsigned char frames;
3772 unsigned int len;
3773 unsigned short buffer_length;
3774 struct sk_buff *new_skb;
3775 fr_mbox_t* mbox = card->mbox;
3776 int err;
3777 struct timeval tv;
3778 int udp_mgmt_req_valid = 1;
3779 netdevice_t* dev;
3780 fr_channel_t* chan;
3781 fr_udp_pkt_t *fr_udp_pkt;
3782 unsigned short num_trc_els;
3783 fr_trc_el_t* ptr_trc_el;
3784 fr_trc_el_t trc_el;
3785 fpipemon_trc_t* fpipemon_trc;
3786
3787 char udp_pkt_src = card->u.f.udp_pkt_src;
3788 int dlci = card->u.f.udp_dlci;
3789
3790 /* Find network interface for this packet */
3791 dev = find_channel(card, dlci);
3792 if (!dev){
3793 card->u.f.udp_pkt_lgth = 0;
3794 return 1;
3795 }
3796 if ((chan = dev->priv) == NULL){
3797 card->u.f.udp_pkt_lgth = 0;
3798 return 1;
3799 }
3800
3801 /* If the UDP packet is from the network, we are going to have to
3802 transmit a response. Before doing so, we must check to see that
3803 we are not currently transmitting a frame (in 'if_send()') and
3804 that we are not already in a 'delayed transmit' state.
3805 */
3806 if(udp_pkt_src == UDP_PKT_FRM_NETWORK) {
3807 if (check_tx_status(card,dev)){
3808 card->u.f.udp_pkt_lgth = 0;
3809 return 1;
3810 }
3811 }
3812
3813 fr_udp_pkt = (fr_udp_pkt_t *)card->u.f.udp_pkt_data;
3814
3815 if(udp_pkt_src == UDP_PKT_FRM_NETWORK) {
3816
3817 switch(fr_udp_pkt->cblock.command) {
3818
3819 case FR_READ_MODEM_STATUS:
3820 case FR_READ_STATUS:
3821 case FPIPE_ROUTER_UP_TIME:
3822 case FR_READ_ERROR_STATS:
3823 case FPIPE_DRIVER_STAT_GEN:
3824 case FR_READ_STATISTICS:
3825 case FR_READ_ADD_DLC_STATS:
3826 case FR_READ_CONFIG:
3827 case FR_READ_CODE_VERSION:
3828 udp_mgmt_req_valid = 1;
3829 break;
3830 default:
3831 udp_mgmt_req_valid = 0;
3832 break;
3833 }
3834 }
3835
3836 if(!udp_mgmt_req_valid) {
3837 /* set length to 0 */
3838 fr_udp_pkt->cblock.length = 0;
3839 /* set return code */
3840 fr_udp_pkt->cblock.result = 0xCD;
3841
3842 chan->drvstats_gen.UDP_PIPE_mgmt_direction_err ++;
3843
3844 if (net_ratelimit()){
3845 printk(KERN_INFO
3846 "%s: Warning, Illegal UDP command attempted from network: %x\n",
3847 card->devname,fr_udp_pkt->cblock.command);
3848 }
3849
3850 } else {
3851
3852 switch(fr_udp_pkt->cblock.command) {
3853
3854 case FPIPE_ENABLE_TRACING:
3855 if(!card->TracingEnabled) {
3856 do {
3857 mbox->cmd.command = FR_SET_TRACE_CONFIG;
3858 mbox->cmd.length = 1;
3859 mbox->cmd.dlci = 0x00;
3860 mbox->data[0] = fr_udp_pkt->data[0] |
3861 RESET_TRC;
3862 err = sdla_exec(mbox) ?
3863 mbox->cmd.result : CMD_TIMEOUT;
3864 } while (err && c_retry-- && fr_event(card, err,
3865 mbox));
3866
3867 if(err) {
3868 card->TracingEnabled = 0;
3869 /* set the return code */
3870 fr_udp_pkt->cblock.result =
3871 mbox->cmd.result;
3872 mbox->cmd.length = 0;
3873 break;
3874 }
3875
3876 sdla_peek(&card->hw, NO_TRC_ELEMENTS_OFF,
3877 &num_trc_els, 2);
3878 sdla_peek(&card->hw, BASE_TRC_ELEMENTS_OFF,
3879 &card->u.f.trc_el_base, 4);
3880 card->u.f.curr_trc_el = card->u.f.trc_el_base;
3881 card->u.f.trc_el_last = card->u.f.curr_trc_el +
3882 ((num_trc_els - 1) *
3883 sizeof(fr_trc_el_t));
3884
3885 /* Calculate the maximum trace data area in */
3886 /* the UDP packet */
3887 card->u.f.trc_bfr_space=(MAX_LGTH_UDP_MGNT_PKT -
3888 //sizeof(fr_encap_hdr_t) -
3889 sizeof(ip_pkt_t) -
3890 sizeof(udp_pkt_t) -
3891 sizeof(wp_mgmt_t) -
3892 sizeof(cblock_t));
3893
3894 /* set return code */
3895 fr_udp_pkt->cblock.result = 0;
3896
3897 } else {
3898 /* set return code to line trace already
3899 enabled */
3900 fr_udp_pkt->cblock.result = 1;
3901 }
3902
3903 mbox->cmd.length = 0;
3904 card->TracingEnabled = 1;
3905 break;
3906
3907
3908 case FPIPE_DISABLE_TRACING:
3909 if(card->TracingEnabled) {
3910
3911 do {
3912 mbox->cmd.command = FR_SET_TRACE_CONFIG;
3913 mbox->cmd.length = 1;
3914 mbox->cmd.dlci = 0x00;
3915 mbox->data[0] = ~ACTIVATE_TRC;
3916 err = sdla_exec(mbox) ?
3917 mbox->cmd.result : CMD_TIMEOUT;
3918 } while (err && c_retry-- && fr_event(card, err, mbox));
3919 }
3920
3921 /* set return code */
3922 fr_udp_pkt->cblock.result = 0;
3923 mbox->cmd.length = 0;
3924 card->TracingEnabled = 0;
3925 break;
3926
3927 case FPIPE_GET_TRACE_INFO:
3928
3929 /* Line trace cannot be performed on the 502 */
3930 if(!card->TracingEnabled) {
3931 /* set return code */
3932 fr_udp_pkt->cblock.result = 1;
3933 mbox->cmd.length = 0;
3934 break;
3935 }
3936
3937 (void *)ptr_trc_el = card->u.f.curr_trc_el;
3938
3939 buffer_length = 0;
3940 fr_udp_pkt->data[0x00] = 0x00;
3941
3942 for(frames = 0; frames < MAX_FRMS_TRACED; frames ++) {
3943
3944 sdla_peek(&card->hw, (unsigned long)ptr_trc_el,
3945 (void *)&trc_el.flag,
3946 sizeof(fr_trc_el_t));
3947 if(trc_el.flag == 0x00) {
3948 break;
3949 }
3950 if((card->u.f.trc_bfr_space - buffer_length)
3951 < sizeof(fpipemon_trc_hdr_t)) {
3952 fr_udp_pkt->data[0x00] |= MORE_TRC_DATA;
3953 break;
3954 }
3955
3956 fpipemon_trc =
3957 (fpipemon_trc_t *)&fr_udp_pkt->data[buffer_length];
3958 fpipemon_trc->fpipemon_trc_hdr.status =
3959 trc_el.attr;
3960 fpipemon_trc->fpipemon_trc_hdr.tmstamp =
3961 trc_el.tmstamp;
3962 fpipemon_trc->fpipemon_trc_hdr.length =
3963 trc_el.length;
3964
3965 if(!trc_el.offset || !trc_el.length) {
3966
3967 fpipemon_trc->fpipemon_trc_hdr.data_passed = 0x00;
3968
3969 }else if((trc_el.length + sizeof(fpipemon_trc_hdr_t) + 1) >
3970 (card->u.f.trc_bfr_space - buffer_length)){
3971
3972 fpipemon_trc->fpipemon_trc_hdr.data_passed = 0x00;
3973 fr_udp_pkt->data[0x00] |= MORE_TRC_DATA;
3974
3975 }else {
3976 fpipemon_trc->fpipemon_trc_hdr.data_passed = 0x01;
3977 sdla_peek(&card->hw, trc_el.offset,
3978 fpipemon_trc->data,
3979 trc_el.length);
3980 }
3981
3982 trc_el.flag = 0x00;
3983 sdla_poke(&card->hw, (unsigned long)ptr_trc_el,
3984 &trc_el.flag, 1);
3985
3986 ptr_trc_el ++;
3987 if((void *)ptr_trc_el > card->u.f.trc_el_last)
3988 (void*)ptr_trc_el = card->u.f.trc_el_base;
3989
3990 buffer_length += sizeof(fpipemon_trc_hdr_t);
3991 if(fpipemon_trc->fpipemon_trc_hdr.data_passed) {
3992 buffer_length += trc_el.length;
3993 }
3994
3995 if(fr_udp_pkt->data[0x00] & MORE_TRC_DATA) {
3996 break;
3997 }
3998 }
3999
4000 if(frames == MAX_FRMS_TRACED) {
4001 fr_udp_pkt->data[0x00] |= MORE_TRC_DATA;
4002 }
4003
4004 card->u.f.curr_trc_el = (void *)ptr_trc_el;
4005
4006 /* set the total number of frames passed */
4007 fr_udp_pkt->data[0x00] |=
4008 ((frames << 1) & (MAX_FRMS_TRACED << 1));
4009
4010 /* set the data length and return code */
4011 fr_udp_pkt->cblock.length = mbox->cmd.length = buffer_length;
4012 fr_udp_pkt->cblock.result = 0;
4013 break;
4014
4015 case FPIPE_FT1_READ_STATUS:
4016 sdla_peek(&card->hw, 0xF020,
4017 &fr_udp_pkt->data[0x00] , 2);
4018 fr_udp_pkt->cblock.length = mbox->cmd.length = 2;
4019 fr_udp_pkt->cblock.result = 0;
4020 break;
4021
4022 case FPIPE_FLUSH_DRIVER_STATS:
4023 init_chan_statistics(chan);
4024 init_global_statistics(card);
4025 mbox->cmd.length = 0;
4026 break;
4027
4028 case FPIPE_ROUTER_UP_TIME:
4029 do_gettimeofday(&tv);
4030 chan->router_up_time = tv.tv_sec -
4031 chan->router_start_time;
4032 *(unsigned long *)&fr_udp_pkt->data =
4033 chan->router_up_time;
4034 mbox->cmd.length = fr_udp_pkt->cblock.length = 4;
4035 fr_udp_pkt->cblock.result = 0;
4036 break;
4037
4038 case FPIPE_DRIVER_STAT_IFSEND:
4039 memcpy(fr_udp_pkt->data,
4040 &chan->drvstats_if_send.if_send_entry,
4041 sizeof(if_send_stat_t));
4042 mbox->cmd.length = fr_udp_pkt->cblock.length =sizeof(if_send_stat_t);
4043 fr_udp_pkt->cblock.result = 0;
4044 break;
4045
4046 case FPIPE_DRIVER_STAT_INTR:
4047
4048 memcpy(fr_udp_pkt->data,
4049 &card->statistics.isr_entry,
4050 sizeof(global_stats_t));
4051
4052 memcpy(&fr_udp_pkt->data[sizeof(global_stats_t)],
4053 &chan->drvstats_rx_intr.rx_intr_no_socket,
4054 sizeof(rx_intr_stat_t));
4055
4056 mbox->cmd.length = fr_udp_pkt->cblock.length =
4057 sizeof(global_stats_t) +
4058 sizeof(rx_intr_stat_t);
4059 fr_udp_pkt->cblock.result = 0;
4060 break;
4061
4062 case FPIPE_DRIVER_STAT_GEN:
4063 memcpy(fr_udp_pkt->data,
4064 &chan->drvstats_gen.UDP_PIPE_mgmt_kmalloc_err,
4065 sizeof(pipe_mgmt_stat_t));
4066
4067 memcpy(&fr_udp_pkt->data[sizeof(pipe_mgmt_stat_t)],
4068 &card->statistics, sizeof(global_stats_t));
4069
4070 mbox->cmd.length = fr_udp_pkt->cblock.length = sizeof(global_stats_t)+
4071 sizeof(rx_intr_stat_t);
4072 fr_udp_pkt->cblock.result = 0;
4073 break;
4074
4075
4076 case FR_FT1_STATUS_CTRL:
4077 if(fr_udp_pkt->data[0] == 1) {
4078 if(rCount++ != 0 ){
4079 fr_udp_pkt->cblock.result = 0;
4080 mbox->cmd.length = 1;
4081 break;
4082 }
4083 }
4084
4085 /* Disable FT1 MONITOR STATUS */
4086 if(fr_udp_pkt->data[0] == 0) {
4087 if( --rCount != 0) {
4088 fr_udp_pkt->cblock.result = 0;
4089 mbox->cmd.length = 1;
4090 break;
4091 }
4092 }
4093 goto udp_mgmt_dflt;
4094
4095
4096 default:
4097 udp_mgmt_dflt:
4098 do {
4099 memcpy(&mbox->cmd,
4100 &fr_udp_pkt->cblock.command,
4101 sizeof(fr_cmd_t));
4102 if(mbox->cmd.length) {
4103 memcpy(&mbox->data,
4104 (char *)fr_udp_pkt->data,
4105 mbox->cmd.length);
4106 }
4107
4108 err = sdla_exec(mbox) ? mbox->cmd.result :
4109 CMD_TIMEOUT;
4110 } while (err && c_retry-- && fr_event(card, err, mbox));
4111
4112 if(!err)
4113 chan->drvstats_gen.
4114 UDP_PIPE_mgmt_adptr_cmnd_OK ++;
4115 else
4116 chan->drvstats_gen.
4117 UDP_PIPE_mgmt_adptr_cmnd_timeout ++;
4118
4119 /* copy the result back to our buffer */
4120 memcpy(&fr_udp_pkt->cblock.command,
4121 &mbox->cmd, sizeof(fr_cmd_t));
4122
4123 if(mbox->cmd.length) {
4124 memcpy(&fr_udp_pkt->data,
4125 &mbox->data, mbox->cmd.length);
4126 }
4127 }
4128 }
4129
4130 /* Fill UDP TTL */
4131 fr_udp_pkt->ip_pkt.ttl = card->wandev.ttl;
4132 len = reply_udp(card->u.f.udp_pkt_data, mbox->cmd.length);
4133
4134 if(udp_pkt_src == UDP_PKT_FRM_NETWORK) {
4135
4136 chan->fr_header_len=2;
4137 chan->fr_header[0]=Q922_UI;
4138 chan->fr_header[1]=NLPID_IP;
4139
4140 err = fr_send_data_header(card, dlci, 0, len,
4141 card->u.f.udp_pkt_data,chan->fr_header_len);
4142 if (err){
4143 chan->drvstats_gen.UDP_PIPE_mgmt_adptr_send_passed ++;
4144 }else{
4145 chan->drvstats_gen.UDP_PIPE_mgmt_adptr_send_failed ++;
4146 }
4147
4148 } else {
4149 /* Allocate socket buffer */
4150 if((new_skb = dev_alloc_skb(len)) != NULL) {
4151
4152 /* copy data into new_skb */
4153 buf = skb_put(new_skb, len);
4154 memcpy(buf, card->u.f.udp_pkt_data, len);
4155
4156 chan->drvstats_gen.
4157 UDP_PIPE_mgmt_passed_to_stack ++;
4158 new_skb->dev = dev;
4159 new_skb->protocol = htons(ETH_P_IP);
4160 new_skb->mac.raw = new_skb->data;
4161 netif_rx(new_skb);
4162
4163 } else {
4164 chan->drvstats_gen.UDP_PIPE_mgmt_no_socket ++;
4165 printk(KERN_INFO
4166 "%s: UDP mgmt cmnd, no socket buffers available!\n",
4167 card->devname);
4168 }
4169 }
4170
4171 card->u.f.udp_pkt_lgth = 0;
4172
4173 return 1;
4174 }
4175
4176 /*==============================================================================
4177 * Send Inverse ARP Request
4178 */
4179
4180 int send_inarp_request(sdla_t *card, netdevice_t *dev)
4181 {
4182 int err=0;
4183
4184 #if defined(LINUX_2_1) || defined(LINUX_2_4)
4185
4186 arphdr_1490_t *ArpPacket;
4187 arphdr_fr_t *arphdr;
4188 fr_channel_t *chan = dev->priv;
4189 struct in_device *in_dev;
4190
4191 in_dev = dev->ip_ptr;
4192
4193 if(in_dev != NULL ) {
4194
4195 ArpPacket = kmalloc(sizeof(arphdr_1490_t) + sizeof(arphdr_fr_t), GFP_ATOMIC);
4196 /* SNAP Header indicating ARP */
4197 ArpPacket->control = 0x03;
4198 ArpPacket->pad = 0x00;
4199 ArpPacket->NLPID = 0x80;
4200 ArpPacket->OUI[0] = 0;
4201 ArpPacket->OUI[1] = 0;
4202 ArpPacket->OUI[2] = 0;
4203 ArpPacket->PID = 0x0608;
4204
4205 arphdr = (arphdr_fr_t *)(ArpPacket + 1); // Go to ARP Packet
4206
4207 /* InARP request */
4208 arphdr->ar_hrd = 0x0F00; /* Frame Relay HW type */
4209 arphdr->ar_pro = 0x0008; /* IP Protocol */
4210 arphdr->ar_hln = 2; /* HW addr length */
4211 arphdr->ar_pln = 4; /* IP addr length */
4212 arphdr->ar_op = htons(0x08); /* InARP Request */
4213 arphdr->ar_sha = 0; /* src HW DLCI - Doesn't matter */
4214 if(in_dev->ifa_list != NULL)
4215 arphdr->ar_sip = in_dev->ifa_list->ifa_local; /* Local Address */else
4216 arphdr->ar_sip = 0;
4217 arphdr->ar_tha = 0; /* dst HW DLCI - Doesn't matter */
4218 arphdr->ar_tip = 0; /* Remote Address -- what we want */
4219
4220 err = fr_send(card, chan->dlci, 0, sizeof(arphdr_1490_t) + sizeof(arphdr_fr_t),
4221 (void *)ArpPacket);
4222
4223 if (!err){
4224 printk(KERN_INFO "\n%s: Sending InARP request on DLCI %d.\n",
4225 card->devname, chan->dlci);
4226 clear_bit(ARP_CRIT,&card->wandev.critical);
4227 }
4228
4229 kfree(ArpPacket);
4230 }else{
4231 printk(KERN_INFO "%s: INARP ERROR: %s doesn't have a local IP address!\n",
4232 card->devname,dev->name);
4233 return 1;
4234 }
4235
4236 #else
4237 arphdr_1490_t *ArpPacket;
4238 arphdr_fr_t *arphdr;
4239 fr_channel_t *chan = dev->priv;
4240
4241 ArpPacket = kmalloc(sizeof(arphdr_1490_t) + sizeof(arphdr_fr_t), GFP_ATOMIC);
4242 /* SNAP Header indicating ARP */
4243 ArpPacket->control = 0x03;
4244 ArpPacket->pad = 0x00;
4245 ArpPacket->NLPID = 0x80;
4246 ArpPacket->OUI[0] = 0;
4247 ArpPacket->OUI[1] = 0;
4248 ArpPacket->OUI[2] = 0;
4249 ArpPacket->PID = 0x0608;
4250
4251 arphdr = (arphdr_fr_t *)(ArpPacket + 1); // Go to ARP Packet
4252 /* InARP request */
4253 arphdr->ar_hrd = 0x0F00; /* Frame Relay HW type */
4254 arphdr->ar_pro = 0x0008; /* IP Protocol */
4255 arphdr->ar_hln = 2; /* HW addr length */
4256 arphdr->ar_pln = 4; /* IP addr length */
4257 arphdr->ar_op = htons(0x08); /* InARP Request */
4258 arphdr->ar_sha = 0; /* src HW DLCI - Doesn't matter */
4259 arphdr->ar_sip = dev->pa_addr; /* Local Address */
4260 arphdr->ar_tha = 0; /* dst HW DLCI - Doesn't matter */
4261 arphdr->ar_tip = 0; /* Remote Address -- what we want */
4262
4263 printk(KERN_INFO "%s: Sending InARP request on DLCI %d.\n", card->devname, chan->dlci);
4264 err = fr_send(card, chan->dlci, 0,
4265 sizeof(arphdr_1490_t) + sizeof(arphdr_fr_t),
4266 (void *)ArpPacket);
4267
4268 if (!err){
4269 printk(KERN_INFO "\n%s: Sending InARP request on DLCI %d.\n",
4270 card->devname, chan->dlci);
4271 clear_bit(ARP_CRIT,&card->wandev.critical);
4272 }
4273
4274 kfree(ArpPacket);
4275 #endif
4276
4277 return 0;
4278 }
4279
4280
4281 /*==============================================================================
4282 * Check packet for ARP Type
4283 */
4284
4285 int is_arp(void *buf)
4286 {
4287 arphdr_1490_t *arphdr = (arphdr_1490_t *)buf;
4288
4289 if (arphdr->pad == 0x00 &&
4290 arphdr->NLPID == 0x80 &&
4291 arphdr->PID == 0x0608)
4292 return 1;
4293 else return 0;
4294 }
4295
4296 /*==============================================================================
4297 * Process ARP Packet Type
4298 */
4299
4300 int process_ARP(arphdr_1490_t *ArpPacket, sdla_t *card, netdevice_t* dev)
4301 {
4302
4303
4304 #if defined(LINUX_2_1) || defined(LINUX_2_4)
4305 arphdr_fr_t *arphdr = (arphdr_fr_t *)(ArpPacket + 1); /* Skip header */
4306 fr_rx_buf_ctl_t* frbuf = card->rxmb;
4307 struct in_device *in_dev;
4308 fr_channel_t *chan = dev->priv;
4309 #else
4310 arphdr_fr_t *arphdr = (arphdr_fr_t *)(ArpPacket + 1); /* Skip header */
4311 fr_rx_buf_ctl_t* frbuf = card->rxmb;
4312 #endif
4313
4314 /* Before we transmit ARP packet, we must check
4315 * to see that we are not currently transmitting a
4316 * frame (in 'if_send()') and that we are not
4317 * already in a 'delayed transmit' state. */
4318 if (check_tx_status(card,dev)){
4319 if (net_ratelimit()){
4320 printk(KERN_INFO "%s: Disabling comminication to process ARP\n",
4321 card->devname);
4322 }
4323 set_bit(ARP_CRIT,&card->wandev.critical);
4324 return 0;
4325 }
4326
4327 #if defined(LINUX_2_1) || defined(LINUX_2_4)
4328
4329 in_dev = dev->ip_ptr;
4330
4331 /* Check that IP addresses exist for our network address */
4332 if (in_dev == NULL || in_dev->ifa_list == NULL)
4333 return -1;
4334
4335 switch (ntohs(arphdr->ar_op)) {
4336
4337 case 0x08: // Inverse ARP request -- Send Reply, add route.
4338
4339 /* Check for valid Address */
4340 printk(KERN_INFO "%s: Recvd PtP addr -InArp Req: %s\n",
4341 card->devname, in_ntoa(arphdr->ar_sip));
4342
4343
4344 /* Check that the network address is the same as ours, only
4345 * if the netowrk mask is not 255.255.255.255. Otherwise
4346 * this check would not make sense */
4347
4348 if (in_dev->ifa_list->ifa_mask != 0xFFFFFFFF &&
4349 (in_dev->ifa_list->ifa_mask & arphdr->ar_sip) !=
4350 (in_dev->ifa_list->ifa_mask & in_dev->ifa_list->ifa_local)){
4351
4352 printk(KERN_INFO
4353 "%s: Invalid PtP address. %s InARP ignored.\n",
4354 card->devname,in_ntoa(arphdr->ar_sip));
4355
4356 printk(KERN_INFO "%s: mask %s\n",
4357 card->devname, in_ntoa(in_dev->ifa_list->ifa_mask));
4358 printk(KERN_INFO "%s: local %s\n",
4359 card->devname,in_ntoa(in_dev->ifa_list->ifa_local));
4360 return -1;
4361 }
4362
4363 if (in_dev->ifa_list->ifa_local == arphdr->ar_sip){
4364 printk(KERN_INFO
4365 "%s: Local addr = PtP addr. InARP ignored.\n",
4366 card->devname);
4367 return -1;
4368 }
4369
4370 arphdr->ar_op = htons(0x09); /* InARP Reply */
4371
4372 /* Set addresses */
4373 arphdr->ar_tip = arphdr->ar_sip;
4374 arphdr->ar_sip = in_dev->ifa_list->ifa_local;
4375
4376 chan->ip_local = in_dev->ifa_list->ifa_local;
4377 chan->ip_remote = arphdr->ar_sip;
4378
4379 fr_send(card, frbuf->dlci, 0, frbuf->length, (void *)ArpPacket);
4380
4381 if (test_bit(ARP_CRIT,&card->wandev.critical)){
4382 if (net_ratelimit()){
4383 printk(KERN_INFO "%s: ARP Processed Enabling Communication!\n",
4384 card->devname);
4385 }
4386 }
4387 clear_bit(ARP_CRIT,&card->wandev.critical);
4388
4389 chan->ip_local = in_dev->ifa_list->ifa_local;
4390 chan->ip_remote = arphdr->ar_sip;
4391
4392 /* Add Route Flag */
4393 /* The route will be added in the polling routine so
4394 that it is not interrupt context. */
4395
4396 chan->route_flag = ADD_ROUTE;
4397 trigger_fr_poll (dev);
4398
4399 break;
4400
4401 case 0x09: // Inverse ARP reply
4402
4403 /* Check for valid Address */
4404 printk(KERN_INFO "%s: Recvd PtP addr %s -InArp Reply\n",
4405 card->devname, in_ntoa(arphdr->ar_sip));
4406
4407
4408 /* Compare network addresses, only if network mask
4409 * is not 255.255.255.255 It would not make sense
4410 * to perform this test if the mask was all 1's */
4411
4412 if (in_dev->ifa_list->ifa_mask != 0xffffffff &&
4413 (in_dev->ifa_list->ifa_mask & arphdr->ar_sip) !=
4414 (in_dev->ifa_list->ifa_mask & in_dev->ifa_list->ifa_local)) {
4415
4416 printk(KERN_INFO "%s: Invalid PtP address. InARP ignored.\n",
4417 card->devname);
4418 return -1;
4419 }
4420
4421 /* Make sure that the received IP address is not
4422 * the same as our own local address */
4423 if (in_dev->ifa_list->ifa_local == arphdr->ar_sip) {
4424 printk(KERN_INFO "%s: Local addr = PtP addr. InARP ignored.\n",
4425 card->devname);
4426 return -1;
4427 }
4428
4429 chan->ip_local = in_dev->ifa_list->ifa_local;
4430 chan->ip_remote = arphdr->ar_sip;
4431
4432 /* Add Route Flag */
4433 /* The route will be added in the polling routine so
4434 that it is not interrupt context. */
4435
4436 chan->route_flag = ADD_ROUTE;
4437 chan->inarp = INARP_CONFIGURED;
4438 trigger_fr_poll(dev);
4439
4440 break;
4441 default:
4442 break; // ARP's and RARP's -- Shouldn't happen.
4443 }
4444
4445 return 0;
4446 #else
4447
4448 switch (ntohs(arphdr->ar_op)) {
4449
4450 case 0x08: // Inverse ARP request -- Send Reply, add route.
4451
4452 /* Check for valid Address */
4453 printk(KERN_INFO "%s: Recvd PtP addr %s -InArp Req\n",
4454 ((fr_channel_t *)dev->priv)->name, in_ntoa(arphdr->ar_sip));
4455
4456
4457 if (dev->pa_mask != 0xFFFFFFFF){
4458
4459 if ((dev->pa_mask & arphdr->ar_sip) != (dev->pa_mask & dev->pa_addr)) {
4460 printk(KERN_INFO "%s: Invalid PtP address. InARP ignored.\n",
4461 card->devname);
4462 return -1;
4463 }
4464 }
4465
4466 if (dev->pa_addr == arphdr->ar_sip) {
4467 printk(KERN_INFO "%s: Local addr = PtP addr. InARP ignored.\n",
4468 card->devname);
4469 return -1;
4470 }
4471
4472 arphdr->ar_op = htons(0x09); /* InARP Reply */
4473
4474 /* Set addresses */
4475 arphdr->ar_tip = arphdr->ar_sip;
4476 arphdr->ar_sip = dev->pa_addr;
4477
4478 fr_send(card, frbuf->dlci, 0, frbuf->length, (void *)ArpPacket);
4479
4480 clear_bit(ARP_CRIT,&card->wandev.critical);
4481
4482 /* Modify Point-to-Point Address */
4483 dev->pa_dstaddr = arphdr->ar_tip;
4484
4485 /* Add Route Flag */
4486 /* The route will be added in the polling routine so
4487 that it is not interrupt context. */
4488 ((fr_channel_t *) dev->priv)->route_flag = ADD_ROUTE;
4489 trigger_fr_poll(dev);
4490
4491 break;
4492 case 0x09: // Inverse ARP reply
4493
4494 /* Check for valid Address */
4495 printk(KERN_INFO "%s: Recvd PtP addr %s -InArp Reply\n",
4496 ((fr_channel_t *)dev->priv)->name, in_ntoa(arphdr->ar_sip));
4497
4498 if ((dev->pa_mask & arphdr->ar_sip) != (dev->pa_mask & dev->pa_addr)) {
4499 printk(KERN_INFO "%s: Invalid PtP address. InARP ignored.\n",
4500 card->devname);
4501 return -1;
4502 }
4503
4504 if (dev->pa_addr == arphdr->ar_sip) {
4505 printk(KERN_INFO "%s: Local addr = PtP addr. InARP ignored.\n",
4506 card->devname);
4507 return -1;
4508 }
4509
4510 /* Modify Point-to-Point Address */
4511 dev->pa_dstaddr = arphdr->ar_sip;
4512 /* Add Route Flag */
4513 /* The route will be added in the polling routine so
4514 that it is not interrupt context. */
4515
4516 ((fr_channel_t *) dev->priv)->route_flag = ADD_ROUTE;
4517 ((fr_channel_t *) dev->priv)->inarp = INARP_CONFIGURED;
4518 trigger_fr_poll(dev);
4519
4520 break;
4521 default: // ARP's and RARP's -- Shouldn't happen.
4522 }
4523
4524 return 0;
4525
4526 #endif
4527 }
4528
4529
4530 /*============================================================
4531 * trigger_fr_arp
4532 *
4533 * Description:
4534 * Add an fr_arp() task into a arp
4535 * timer handler for a specific dlci/interface.
4536 * This will kick the fr_arp() routine
4537 * within the specified time interval.
4538 *
4539 * Usage:
4540 * This timer is used to send ARP requests at
4541 * certain time intervals.
4542 * Called by an interrupt to request an action
4543 * at a later date.
4544 */
4545
4546 static void trigger_fr_arp (netdevice_t *dev)
4547 {
4548 fr_channel_t* chan = dev->priv;
4549
4550 del_timer(&chan->fr_arp_timer);
4551 chan->fr_arp_timer.expires = jiffies + (chan->inarp_interval * HZ);
4552 add_timer(&chan->fr_arp_timer);
4553 return;
4554 }
4555
4556
4557
4558 /*==============================================================================
4559 * ARP Request Action
4560 *
4561 * This funciton is called by timer interrupt to send an arp request
4562 * to the remote end.
4563 */
4564
4565 static void fr_arp (unsigned long data)
4566 {
4567 netdevice_t *dev = (netdevice_t *)data;
4568 fr_channel_t *chan = dev->priv;
4569 volatile sdla_t *card = chan->card;
4570 fr508_flags_t* flags = card->flags;
4571
4572 /* Send ARP packets for all devs' until
4573 * ARP state changes to CONFIGURED */
4574
4575 if (chan->inarp == INARP_REQUEST &&
4576 chan->common.state == WAN_CONNECTED &&
4577 card->wandev.state == WAN_CONNECTED){
4578 set_bit(0,&chan->inarp_ready);
4579 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_ARP;
4580 flags->imask |= FR_INTR_TIMER;
4581 }
4582
4583 return;
4584 }
4585
4586
4587 /*==============================================================================
4588 * Perform the Interrupt Test by running the READ_CODE_VERSION command MAX_INTR_
4589 * TEST_COUNTER times.
4590 */
4591 static int intr_test( sdla_t* card )
4592 {
4593 fr_mbox_t* mb = card->mbox;
4594 int err,i;
4595
4596 err = fr_set_intr_mode(card, FR_INTR_READY, card->wandev.mtu, 0 );
4597
4598 if (err == CMD_OK) {
4599
4600 for ( i = 0; i < MAX_INTR_TEST_COUNTER; i++ ) {
4601 /* Run command READ_CODE_VERSION */
4602 mb->cmd.length = 0;
4603 mb->cmd.command = FR_READ_CODE_VERSION;
4604 err = sdla_exec(mb) ? mb->cmd.result : CMD_TIMEOUT;
4605 if (err != CMD_OK)
4606 fr_event(card, err, mb);
4607 }
4608
4609 } else {
4610 return err;
4611 }
4612
4613 err = fr_set_intr_mode( card, 0, card->wandev.mtu, 0 );
4614
4615 if( err != CMD_OK )
4616 return err;
4617
4618 return 0;
4619 }
4620
4621 /*==============================================================================
4622 * Determine what type of UDP call it is. FPIPE8ND ?
4623 */
4624 static int udp_pkt_type( struct sk_buff *skb, sdla_t* card )
4625 {
4626 fr_udp_pkt_t *fr_udp_pkt = (fr_udp_pkt_t *)skb->data;
4627
4628 /* Quick HACK */
4629
4630
4631 if((fr_udp_pkt->ip_pkt.protocol == UDPMGMT_UDP_PROTOCOL) &&
4632 (fr_udp_pkt->ip_pkt.ver_inet_hdr_length == 0x45) &&
4633 (fr_udp_pkt->udp_pkt.udp_dst_port ==
4634 ntohs(card->wandev.udp_port)) &&
4635 (fr_udp_pkt->wp_mgmt.request_reply ==
4636 UDPMGMT_REQUEST)) {
4637 if(!strncmp(fr_udp_pkt->wp_mgmt.signature,
4638 UDPMGMT_FPIPE_SIGNATURE, 8)){
4639 return UDP_FPIPE_TYPE;
4640 }
4641 }
4642 return UDP_INVALID_TYPE;
4643 }
4644
4645
4646 /*==============================================================================
4647 * Initializes the Statistics values in the fr_channel structure.
4648 */
4649 void init_chan_statistics( fr_channel_t* chan)
4650 {
4651 memset(&chan->drvstats_if_send.if_send_entry, 0,
4652 sizeof(if_send_stat_t));
4653 memset(&chan->drvstats_rx_intr.rx_intr_no_socket, 0,
4654 sizeof(rx_intr_stat_t));
4655 memset(&chan->drvstats_gen.UDP_PIPE_mgmt_kmalloc_err, 0,
4656 sizeof(pipe_mgmt_stat_t));
4657 }
4658
4659 /*==============================================================================
4660 * Initializes the Statistics values in the Sdla_t structure.
4661 */
4662 void init_global_statistics( sdla_t* card )
4663 {
4664 /* Intialize global statistics for a card */
4665 memset(&card->statistics.isr_entry, 0, sizeof(global_stats_t));
4666 }
4667
4668 static void read_DLCI_IB_mapping( sdla_t* card, fr_channel_t* chan )
4669 {
4670 fr_mbox_t* mbox = card->mbox;
4671 int retry = MAX_CMD_RETRY;
4672 dlci_IB_mapping_t* result;
4673 int err, counter, found;
4674
4675 do {
4676 mbox->cmd.command = FR_READ_DLCI_IB_MAPPING;
4677 mbox->cmd.length = 0;
4678 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
4679 } while (err && retry-- && fr_event(card, err, mbox));
4680
4681 if( mbox->cmd.result != 0){
4682 printk(KERN_INFO "%s: Read DLCI IB Mapping failed\n",
4683 chan->name);
4684 }
4685
4686 counter = mbox->cmd.length / sizeof(dlci_IB_mapping_t);
4687 result = (void *)mbox->data;
4688
4689 found = 0;
4690 for (; counter; --counter, ++result) {
4691 if ( result->dlci == chan->dlci ) {
4692 chan->IB_addr = result->addr_value;
4693 if(card->hw.type == SDLA_S514){
4694 chan->dlci_int_interface =
4695 (void*)(card->hw.dpmbase +
4696 chan->IB_addr);
4697 }else{
4698 chan->dlci_int_interface =
4699 (void*)(card->hw.dpmbase +
4700 (chan->IB_addr & 0x00001FFF));
4701
4702 }
4703 found = 1;
4704 break;
4705 }
4706 }
4707 if (!found)
4708 printk( KERN_INFO "%s: DLCI %d not found by IB MAPPING cmd\n",
4709 card->devname, chan->dlci);
4710 }
4711
4712
4713
4714 void s508_s514_lock(sdla_t *card, unsigned long *smp_flags)
4715 {
4716 if (card->hw.type != SDLA_S514){
4717
4718 #if defined(__SMP__) || defined(LINUX_2_4)
4719 spin_lock_irqsave(&card->wandev.lock, *smp_flags);
4720 #else
4721 disable_irq(card->hw.irq);
4722 #endif
4723 }else{
4724 #if defined(__SMP__) || defined(LINUX_2_4)
4725 spin_lock(&card->u.f.if_send_lock);
4726 #endif
4727 }
4728 return;
4729 }
4730
4731
4732 void s508_s514_unlock(sdla_t *card, unsigned long *smp_flags)
4733 {
4734 if (card->hw.type != SDLA_S514){
4735
4736 #if defined(__SMP__) || defined(LINUX_2_4)
4737 spin_unlock_irqrestore (&card->wandev.lock, *smp_flags);
4738 #else
4739 enable_irq(card->hw.irq);
4740 #endif
4741 }else{
4742 #if defined(__SMP__) || defined(LINUX_2_4)
4743 spin_unlock(&card->u.f.if_send_lock);
4744 #endif
4745 }
4746 return;
4747 }
4748
4749
4750
4751 #if defined(LINUX_2_1) || defined(LINUX_2_4)
4752
4753 /*----------------------------------------------------------------------
4754 RECEIVE INTERRUPT: BOTTOM HALF HANDLERS
4755 ----------------------------------------------------------------------*/
4756
4757
4758 /*========================================================
4759 * bh_enqueue
4760 *
4761 * Description:
4762 * Insert a received packed into a circular
4763 * rx queue. This packed will be picked up
4764 * by fr_bh() and sent up the stack to the
4765 * user.
4766 *
4767 * Usage:
4768 * This function is called by rx interrupt,
4769 * in API mode.
4770 *
4771 */
4772
4773 static int bh_enqueue (netdevice_t *dev, struct sk_buff *skb)
4774 {
4775 /* Check for full */
4776 fr_channel_t* chan = dev->priv;
4777 sdla_t *card = chan->card;
4778
4779
4780 if (atomic_read(&chan->bh_buff_used) == MAX_BH_BUFF){
4781 ++card->wandev.stats.rx_dropped;
4782 wan_dev_kfree_skb(skb, FREE_READ);
4783 return 1;
4784 }
4785
4786 ((bh_data_t *)&chan->bh_head[chan->bh_write])->skb = skb;
4787
4788 if (chan->bh_write == (MAX_BH_BUFF-1)){
4789 chan->bh_write=0;
4790 }else{
4791 ++chan->bh_write;
4792 }
4793
4794 atomic_inc(&chan->bh_buff_used);
4795
4796 return 0;
4797 }
4798
4799
4800 /*========================================================
4801 * trigger_fr_bh
4802 *
4803 * Description:
4804 * Kick the fr_bh() handler
4805 *
4806 * Usage:
4807 * rx interrupt calls this function during
4808 * the API mode.
4809 */
4810
4811 static void trigger_fr_bh (fr_channel_t *chan)
4812 {
4813 if (!test_and_set_bit(0,&chan->tq_working)){
4814 wanpipe_queue_tq(&chan->common.wanpipe_task);
4815 wanpipe_mark_bh();
4816 }
4817 }
4818
4819
4820 /*========================================================
4821 * fr_bh
4822 *
4823 * Description:
4824 * Frame relay receive BH handler.
4825 * Dequeue data from the BH circular
4826 * buffer and pass it up the API sock.
4827 *
4828 * Rationale:
4829 * This fuction is used to offload the
4830 * rx_interrupt during API operation mode.
4831 * The fr_bh() function executes for each
4832 * dlci/interface.
4833 *
4834 * Once receive interrupt copies data from the
4835 * card into an skb buffer, the skb buffer
4836 * is appended to a circular BH buffer.
4837 * Then the interrupt kicks fr_bh() to finish the
4838 * job at a later time (no within the interrupt).
4839 *
4840 * Usage:
4841 * Interrupts use this to defer a taks to
4842 * a polling routine.
4843 *
4844 */
4845
4846 static void fr_bh (netdevice_t * dev)
4847 {
4848 fr_channel_t* chan = dev->priv;
4849 sdla_t *card = chan->card;
4850 struct sk_buff *skb;
4851
4852 if (atomic_read(&chan->bh_buff_used) == 0){
4853 clear_bit(0, &chan->tq_working);
4854 return;
4855 }
4856
4857 while (atomic_read(&chan->bh_buff_used)){
4858
4859 if (chan->common.sk == NULL || chan->common.func == NULL){
4860 clear_bit(0, &chan->tq_working);
4861 return;
4862 }
4863
4864 skb = ((bh_data_t *)&chan->bh_head[chan->bh_read])->skb;
4865
4866 if (skb != NULL){
4867
4868 if (chan->common.sk == NULL || chan->common.func == NULL){
4869 ++card->wandev.stats.rx_dropped;
4870 ++chan->ifstats.rx_dropped;
4871 wan_dev_kfree_skb(skb, FREE_READ);
4872 fr_bh_cleanup(dev);
4873 continue;
4874 }
4875
4876 if (chan->common.func(skb,dev,chan->common.sk) != 0){
4877 /* Sock full cannot send, queue us for
4878 * another try */
4879 atomic_set(&chan->common.receive_block,1);
4880 return;
4881 }else{
4882 fr_bh_cleanup(dev);
4883 }
4884 }else{
4885 fr_bh_cleanup(dev);
4886 }
4887 }
4888 clear_bit(0, &chan->tq_working);
4889
4890 return;
4891 }
4892
4893 static int fr_bh_cleanup (netdevice_t *dev)
4894 {
4895 fr_channel_t* chan = dev->priv;
4896
4897 ((bh_data_t *)&chan->bh_head[chan->bh_read])->skb = NULL;
4898
4899 if (chan->bh_read == (MAX_BH_BUFF-1)){
4900 chan->bh_read=0;
4901 }else{
4902 ++chan->bh_read;
4903 }
4904
4905 atomic_dec(&chan->bh_buff_used);
4906 return 0;
4907 }
4908 #endif
4909
4910
4911 /*----------------------------------------------------------------------
4912 POLL BH HANDLERS AND KICK ROUTINES
4913 ----------------------------------------------------------------------*/
4914
4915 /*============================================================
4916 * trigger_fr_poll
4917 *
4918 * Description:
4919 * Add a fr_poll() task into a tq_scheduler bh handler
4920 * for a specific dlci/interface. This will kick
4921 * the fr_poll() routine at a later time.
4922 *
4923 * Usage:
4924 * Interrupts use this to defer a taks to
4925 * a polling routine.
4926 *
4927 */
4928 static void trigger_fr_poll (netdevice_t *dev)
4929 {
4930 fr_channel_t* chan = dev->priv;
4931 #ifdef LINUX_2_4
4932 schedule_task(&chan->fr_poll_task);
4933 #else
4934 queue_task(&chan->fr_poll_task, &tq_scheduler);
4935 #endif
4936 return;
4937 }
4938
4939
4940 /*============================================================
4941 * fr_poll
4942 *
4943 * Rationale:
4944 * We cannot manipulate the routing tables, or
4945 * ip addresses withing the interrupt. Therefore
4946 * we must perform such actons outside an interrupt
4947 * at a later time.
4948 *
4949 * Description:
4950 * Frame relay polling routine, responsible for
4951 * shutting down interfaces upon disconnect
4952 * and adding/removing routes.
4953 *
4954 * Usage:
4955 * This function is executed for each frame relay
4956 * dlci/interface through a tq_schedule bottom half.
4957 *
4958 * trigger_fr_poll() function is used to kick
4959 * the fr_poll routine.
4960 */
4961
4962 static void fr_poll (netdevice_t *dev)
4963 {
4964
4965 fr_channel_t* chan;
4966 sdla_t *card;
4967 u8 check_gateway=0;
4968
4969 if (!dev || (chan = dev->priv) == NULL)
4970 return;
4971
4972 card = chan->card;
4973
4974 /* (Re)Configuraiton is in progress, stop what you are
4975 * doing and get out */
4976 if (test_bit(PERI_CRIT,&card->wandev.critical)){
4977 return;
4978 }
4979
4980 switch (chan->common.state){
4981
4982 case WAN_DISCONNECTED:
4983
4984 if (test_bit(DYN_OPT_ON,&chan->interface_down) &&
4985 !test_bit(DEV_DOWN, &chan->interface_down) &&
4986 dev->flags&IFF_UP){
4987
4988 printk(KERN_INFO "%s: Interface %s is Down.\n",
4989 card->devname,dev->name);
4990 change_dev_flags(dev,dev->flags&~IFF_UP);
4991 set_bit(DEV_DOWN, &chan->interface_down);
4992 chan->route_flag = NO_ROUTE;
4993
4994 }else{
4995 if (chan->inarp != INARP_NONE)
4996 process_route(dev);
4997 }
4998 break;
4999
5000 case WAN_CONNECTED:
5001
5002 if (test_bit(DYN_OPT_ON,&chan->interface_down) &&
5003 test_bit(DEV_DOWN, &chan->interface_down) &&
5004 !(dev->flags&IFF_UP)){
5005
5006 printk(KERN_INFO "%s: Interface %s is Up.\n",
5007 card->devname,dev->name);
5008
5009 change_dev_flags(dev,dev->flags|IFF_UP);
5010 clear_bit(DEV_DOWN, &chan->interface_down);
5011 check_gateway=1;
5012 }
5013
5014 if (chan->inarp != INARP_NONE){
5015 process_route(dev);
5016 check_gateway=1;
5017 }
5018
5019 if (chan->gateway && check_gateway)
5020 add_gateway(card,dev);
5021
5022 break;
5023
5024 }
5025
5026 return;
5027 }
5028
5029 /*==============================================================
5030 * check_tx_status
5031 *
5032 * Rationale:
5033 * We cannot transmit from an interrupt while
5034 * the if_send is transmitting data. Therefore,
5035 * we must check whether the tx buffers are
5036 * begin used, before we transmit from an
5037 * interrupt.
5038 *
5039 * Description:
5040 * Checks whether it's safe to use the transmit
5041 * buffers.
5042 *
5043 * Usage:
5044 * ARP and UDP handling routines use this function
5045 * because, they need to transmit data during
5046 * an interrupt.
5047 */
5048
5049 static int check_tx_status(sdla_t *card, netdevice_t *dev)
5050 {
5051
5052 if (card->hw.type == SDLA_S514){
5053 if (test_bit(SEND_CRIT, (void*)&card->wandev.critical) ||
5054 test_bit(SEND_TXIRQ_CRIT, (void*)&card->wandev.critical)) {
5055 return 1;
5056 }
5057 }
5058
5059 if (is_queue_stopped(dev) || (card->u.f.tx_interrupts_pending))
5060 return 1;
5061
5062 return 0;
5063 }
5064
5065 /*===============================================================
5066 * move_dev_to_next
5067 *
5068 * Description:
5069 * Move the dev pointer to the next location in the
5070 * link list. Check if we are at the end of the
5071 * list, if so start from the begining.
5072 *
5073 * Usage:
5074 * Timer interrupt uses this function to efficiently
5075 * step through the devices that need to send ARP data.
5076 *
5077 */
5078
5079 netdevice_t * move_dev_to_next (sdla_t *card, netdevice_t *dev)
5080 {
5081 if (card->wandev.new_if_cnt != 1){
5082 if (*((netdevice_t **)dev->priv) == NULL){
5083 return card->wandev.dev;
5084 }else{
5085 return *((netdevice_t **)dev->priv);
5086 }
5087 }
5088 return dev;
5089 }
5090
5091 /*==============================================================
5092 * trigger_config_fr
5093 *
5094 * Rationale:
5095 * All commands must be performed inside of a
5096 * interrupt.
5097 *
5098 * Description:
5099 * Kick the config_fr() routine throught the
5100 * timer interrupt.
5101 */
5102
5103
5104 static void trigger_config_fr (sdla_t *card)
5105 {
5106 fr508_flags_t* flags = card->flags;
5107
5108 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_CONFIG;
5109 flags->imask |= FR_INTR_TIMER;
5110 }
5111
5112
5113 /*==============================================================
5114 * config_fr
5115 *
5116 * Rationale:
5117 * All commands must be performed inside of a
5118 * interrupt.
5119 &
5120 * Description:
5121 * Configure a DLCI. This function is executed
5122 * by a timer_interrupt. The if_open() function
5123 * triggers it.
5124 *
5125 * Usage:
5126 * new_if() collects all data necessary to
5127 * configure the DLCI. It sets the chan->dlci_ready
5128 * bit. When the if_open() function is executed
5129 * it checks this bit, and if its set it triggers
5130 * the timer interrupt to execute the config_fr()
5131 * function.
5132 */
5133
5134 static void config_fr (sdla_t *card)
5135 {
5136 netdevice_t *dev;
5137 fr_channel_t *chan;
5138
5139 for (dev=card->wandev.dev; dev; dev=*((netdevice_t **)dev->priv)){
5140
5141 if ((chan=dev->priv) == NULL)
5142 continue;
5143
5144 if (!test_bit(0,&chan->config_dlci))
5145 continue;
5146
5147 clear_bit(0,&chan->config_dlci);
5148
5149 /* If signalling is set to NO, then setup
5150 * DLCI addresses right away. Don't have to wait for
5151 * link to connect.
5152 */
5153 if (card->wandev.signalling == WANOPT_NO){
5154 printk(KERN_INFO "%s: Signalling set to NO: Mapping DLCI's\n",
5155 card->wandev.name);
5156 if (fr_init_dlci(card,chan)){
5157 printk(KERN_INFO "%s: ERROR: Failed to configure DLCI %i !\n",
5158 card->devname, chan->dlci);
5159 return;
5160 }
5161 }
5162
5163 if (card->wandev.station == WANOPT_CPE) {
5164
5165 update_chan_state(dev);
5166
5167 /* CPE: issue full status enquiry */
5168 fr_issue_isf(card, FR_ISF_FSE);
5169
5170 } else {
5171 /* FR switch: activate DLCI(s) */
5172
5173 /* For Switch emulation we have to ADD and ACTIVATE
5174 * the DLCI(s) that were configured with the SET_DLCI_
5175 * CONFIGURATION command. Add and Activate will fail if
5176 * DLCI specified is not included in the list.
5177 *
5178 * Also If_open is called once for each interface. But
5179 * it does not get in here for all the interface. So
5180 * we have to pass the entire list of DLCI(s) to add
5181 * activate routines.
5182 */
5183
5184 if (!check_dlci_config (card, chan)){
5185 fr_add_dlci(card, chan->dlci);
5186 fr_activate_dlci(card, chan->dlci);
5187 }
5188 }
5189
5190 card->u.f.dlci_to_dev_map[chan->dlci] = dev;
5191 }
5192 return;
5193 }
5194
5195
5196 /*==============================================================
5197 * config_fr
5198 *
5199 * Rationale:
5200 * All commands must be executed during an interrupt.
5201 *
5202 * Description:
5203 * Trigger uncofig_fr() function through
5204 * the timer interrupt.
5205 *
5206 */
5207
5208 static void trigger_unconfig_fr (netdevice_t *dev)
5209 {
5210 fr_channel_t *chan = dev->priv;
5211 volatile sdla_t *card = chan->card;
5212 u32 timeout;
5213 fr508_flags_t* flags = card->flags;
5214 int reset_critical=0;
5215
5216 if (test_bit(PERI_CRIT,(void*)&card->wandev.critical)){
5217 clear_bit(PERI_CRIT,(void*)&card->wandev.critical);
5218 reset_critical=1;
5219 }
5220
5221 /* run unconfig_dlci() function
5222 * throught the timer interrupt */
5223 set_bit(0,(void*)&chan->unconfig_dlci);
5224 card->u.f.timer_int_enabled |= TMR_INT_ENABLED_UNCONFIG;
5225 flags->imask |= FR_INTR_TIMER;
5226
5227 /* Wait for the command to complete */
5228 timeout = jiffies;
5229 for(;;) {
5230
5231 if(!(card->u.f.timer_int_enabled & TMR_INT_ENABLED_UNCONFIG))
5232 break;
5233
5234 if ((jiffies - timeout) > (1 * HZ)){
5235 card->u.f.timer_int_enabled &= ~TMR_INT_ENABLED_UNCONFIG;
5236 printk(KERN_INFO "%s: Failed to delete DLCI %i\n",
5237 card->devname,chan->dlci);
5238 break;
5239 }
5240 }
5241
5242 if (reset_critical){
5243 set_bit(PERI_CRIT,(void*)&card->wandev.critical);
5244 }
5245 }
5246
5247 /*==============================================================
5248 * unconfig_fr
5249 *
5250 * Rationale:
5251 * All commands must be executed during an interrupt.
5252 *
5253 * Description:
5254 * Remove the dlci from firmware.
5255 * This funciton is used in NODE shutdown.
5256 */
5257
5258 static void unconfig_fr (sdla_t *card)
5259 {
5260 netdevice_t *dev;
5261 fr_channel_t *chan;
5262
5263 for (dev=card->wandev.dev; dev; dev=*((netdevice_t **)dev->priv)){
5264
5265 if ((chan=dev->priv) == NULL)
5266 continue;
5267
5268 if (!test_bit(0,&chan->unconfig_dlci))
5269 continue;
5270
5271 clear_bit(0,&chan->unconfig_dlci);
5272
5273 if (card->wandev.station == WANOPT_NODE){
5274 printk(KERN_INFO "%s: Unconfiguring DLCI %i\n",
5275 card->devname,chan->dlci);
5276 fr_delete_dlci(card,chan->dlci);
5277 }
5278 card->u.f.dlci_to_dev_map[chan->dlci] = NULL;
5279 }
5280 }
5281
5282 static int setup_fr_header(struct sk_buff ** skb_orig, netdevice_t* dev, char op_mode)
5283 {
5284 struct sk_buff *skb = *skb_orig;
5285 fr_channel_t *chan=dev->priv;
5286
5287 if (op_mode == WANPIPE){
5288
5289 chan->fr_header[0]=Q922_UI;
5290
5291 switch (htons(skb->protocol)){
5292
5293 case ETH_P_IP:
5294 chan->fr_header[1]=NLPID_IP;
5295 break;
5296 default:
5297 return -EINVAL;
5298 }
5299
5300 return 2;
5301 }
5302
5303 /* If we are in bridging mode, we must apply
5304 * an Ethernet header */
5305 if (op_mode == BRIDGE || op_mode == BRIDGE_NODE){
5306
5307 #if defined(LINUX_2_1) || defined(LINUX_2_4)
5308
5309 /* Encapsulate the packet as a bridged Ethernet frame. */
5310 #ifdef DEBUG
5311 printk(KERN_INFO "%s: encapsulating skb for frame relay\n",
5312 dev->name);
5313 #endif
5314
5315 chan->fr_header[0] = 0x03;
5316 chan->fr_header[1] = 0x00;
5317 chan->fr_header[2] = 0x80;
5318 chan->fr_header[3] = 0x00;
5319 chan->fr_header[4] = 0x80;
5320 chan->fr_header[5] = 0xC2;
5321 chan->fr_header[6] = 0x00;
5322 chan->fr_header[7] = 0x07;
5323
5324 /* Yuck. */
5325 skb->protocol = ETH_P_802_3;
5326 return 8;
5327
5328 #else
5329
5330 /* BRIDGING is not supported in 2.0.X */
5331 return -EINVAL;
5332
5333 #endif
5334 }
5335
5336 return 0;
5337 }
5338
5339
5340 static int check_dlci_config (sdla_t *card, fr_channel_t *chan)
5341 {
5342 fr_mbox_t* mbox = card->mbox;
5343 int err=0;
5344 fr_conf_t *conf=NULL;
5345 unsigned short dlci_num = chan->dlci;
5346 int dlci_offset=0;
5347 netdevice_t *dev=NULL;
5348
5349 mbox->cmd.command = FR_READ_CONFIG;
5350 mbox->cmd.length = 0;
5351 mbox->cmd.dlci = dlci_num;
5352
5353 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
5354
5355 if (err == CMD_OK){
5356 return 0;
5357 }
5358
5359 for (dev=card->wandev.dev; dev; dev=*((netdevice_t**)dev->priv)){
5360 set_chan_state(dev,WAN_DISCONNECTED);
5361 }
5362
5363 printk(KERN_INFO "DLCI %i Not configured, configuring\n",dlci_num);
5364
5365 mbox->cmd.command = FR_COMM_DISABLE;
5366 mbox->cmd.length = 0;
5367 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
5368 if (err != CMD_OK){
5369 fr_event(card, err, mbox);
5370 return 2;
5371 }
5372
5373 printk(KERN_INFO "Disabled Communications \n");
5374
5375 mbox->cmd.command = FR_READ_CONFIG;
5376 mbox->cmd.length = 0;
5377 mbox->cmd.dlci = 0;
5378
5379 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
5380
5381 if (err != CMD_OK){
5382 fr_event(card, err, mbox);
5383 return 2;
5384 }
5385
5386 conf = (fr_conf_t *)mbox->data;
5387
5388 dlci_offset=0;
5389 for (dev=card->wandev.dev; dev; dev=*((netdevice_t**)dev->priv)){
5390 fr_channel_t *chan_tmp = dev->priv;
5391 conf->dlci[dlci_offset] = chan_tmp->dlci;
5392 dlci_offset++;
5393 }
5394
5395 printk(KERN_INFO "Got Fr configuration Buffer Length is %x Dlci %i Dlci Off %i\n",
5396 mbox->cmd.length,
5397 mbox->cmd.length > 0x20 ? conf->dlci[0] : -1,
5398 dlci_offset );
5399
5400 mbox->cmd.length = 0x20 + dlci_offset*2;
5401
5402 mbox->cmd.command = FR_SET_CONFIG;
5403 mbox->cmd.dlci = 0;
5404
5405 err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT;
5406
5407 if (err != CMD_OK){
5408 fr_event(card, err, mbox);
5409 return 2;
5410 }
5411
5412 initialize_rx_tx_buffers (card);
5413
5414
5415 printk(KERN_INFO "Configuraiton Succeded for new DLCI %i\n",dlci_num);
5416
5417 if (fr_comm_enable (card)){
5418 return 2;
5419 }
5420
5421 printk(KERN_INFO "Enabling Communications \n");
5422
5423 for (dev=card->wandev.dev; dev; dev=*((netdevice_t**)dev->priv)){
5424 fr_channel_t *chan_tmp = dev->priv;
5425 fr_init_dlci(card,chan_tmp);
5426 fr_add_dlci(card, chan_tmp->dlci);
5427 fr_activate_dlci(card, chan_tmp->dlci);
5428 }
5429
5430 printk(KERN_INFO "END OF CONFIGURAITON %i\n",dlci_num);
5431
5432 return 1;
5433 }
5434
5435 static void initialize_rx_tx_buffers (sdla_t *card)
5436 {
5437 fr_buf_info_t* buf_info;
5438
5439 if (card->hw.type == SDLA_S514) {
5440
5441 buf_info = (void*)(card->hw.dpmbase + FR_MB_VECTOR +
5442 FR508_RXBC_OFFS);
5443
5444 card->rxmb = (void*)(buf_info->rse_next + card->hw.dpmbase);
5445
5446 card->u.f.rxmb_base =
5447 (void*)(buf_info->rse_base + card->hw.dpmbase);
5448
5449 card->u.f.rxmb_last =
5450 (void*)(buf_info->rse_base +
5451 (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) +
5452 card->hw.dpmbase);
5453 }else{
5454 buf_info = (void*)(card->hw.dpmbase + FR508_RXBC_OFFS);
5455
5456 card->rxmb = (void*)(buf_info->rse_next -
5457 FR_MB_VECTOR + card->hw.dpmbase);
5458
5459 card->u.f.rxmb_base =
5460 (void*)(buf_info->rse_base -
5461 FR_MB_VECTOR + card->hw.dpmbase);
5462
5463 card->u.f.rxmb_last =
5464 (void*)(buf_info->rse_base +
5465 (buf_info->rse_num - 1) * sizeof(fr_rx_buf_ctl_t) -
5466 FR_MB_VECTOR + card->hw.dpmbase);
5467 }
5468
5469 card->u.f.rx_base = buf_info->buf_base;
5470 card->u.f.rx_top = buf_info->buf_top;
5471
5472 card->u.f.tx_interrupts_pending = 0;
5473
5474 return;
5475 }
5476
5477
5478
5479 MODULE_LICENSE("GPL");
5480
5481 /****** End *****************************************************************/
5482