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