?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
The LDT fixes in particular fix some potentially random strange behaviour.
[davej-history.git] / drivers / net / wan / sdla_chdlc.c
blobefdf2069d56106ab57e75433aee86dbf281498dd
1 /*****************************************************************************
2 * sdla_chdlc.c WANPIPE(tm) Multiprotocol WAN Link Driver. Cisco HDLC module.
3 *
4 * Authors: Nenad Corbic <ncorbic@sangoma.com>
5 * Gideon Hack
6 *
7 * Copyright: (c) 1995-1999 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 * Feb 28, 2000 Jeff Garzik softnet updates
15 * Nov 20, 1999 Nenad Corbic Fixed zero length API bug.
16 * Sep 30, 1999 Nenad Corbic Fixed dynamic IP and route setup.
17 * Sep 23, 1999 Nenad Corbic Added SMP support, fixed tracing
18 * Sep 13, 1999 Nenad Corbic Split up Port 0 and 1 into separate devices.
19 * Jun 02, 1999 Gideon Hack Added support for the S514 adapter.
20 * Oct 30, 1998 Jaspreet Singh Added Support for CHDLC API (HDLC STREAMING).
21 * Oct 28, 1998 Jaspreet Singh Added Support for Dual Port CHDLC.
22 * Aug 07, 1998 David Fong Initial version.
23 *****************************************************************************/
24
25 #include <linux/config.h>
26 #include <linux/version.h>
27 #include <linux/kernel.h> /* printk(), and other useful stuff */
28 #include <linux/stddef.h> /* offsetof(), etc. */
29 #include <linux/errno.h> /* return codes */
30 #include <linux/string.h> /* inline memset(), etc. */
31 #include <linux/malloc.h> /* kmalloc(), kfree() */
32 #include <linux/wanrouter.h> /* WAN router definitions */
33 #include <linux/wanpipe.h> /* WANPIPE common user API definitions */
34 #include <linux/if_arp.h> /* ARPHRD_* defines */
35 #include <linux/inetdevice.h>
36 #include <asm/uaccess.h>
37 #include <linux/in.h> /* sockaddr_in */
38 #include <linux/inet.h>
39 #include <linux/if.h>
40 #include <asm/byteorder.h> /* htons(), etc. */
41 #include <linux/sdlapci.h>
42 #include <asm/io.h>
43
44 #include <linux/sdla_chdlc.h> /* CHDLC firmware API definitions */
45
46 /****** Defines & Macros ****************************************************/
47
48 #ifdef _DEBUG_
49 #define STATIC
50 #else
51 #define STATIC static
52 #endif
53
54 /* reasons for enabling the timer interrupt on the adapter */
55 #define TMR_INT_ENABLED_UDP 0x0001
56 #define TMR_INT_ENABLED_UPDATE 0x0002
57
58 #define CHDLC_DFLT_DATA_LEN 1500 /* default MTU */
59 #define CHDLC_HDR_LEN 1
60
61 #define IFF_POINTTOPOINT 0x10
62
63 #define WANPIPE 0x00
64 #define API 0x01
65 #define CHDLC_API 0x01
66
67 #define PORT(x) (x == 0 ? "PRIMARY" : "SECONDARY" )
68
69 #define TX_TIMEOUT (5*HZ)
70
71 /******Data Structures*****************************************************/
72
73 /* This structure is placed in the private data area of the device structure.
74 * The card structure used to occupy the private area but now the following
75 * structure will incorporate the card structure along with CHDLC specific data
76 */
77
78 typedef struct chdlc_private_area
79 {
80 /* This member must be first. */
81 struct net_device *slave; /* WAN slave */
82
83 sdla_t *card;
84 int TracingEnabled; /* For enabling Tracing */
85 unsigned long curr_trace_addr; /* Used for Tracing */
86 unsigned long start_trace_addr;
87 unsigned long end_trace_addr;
88 unsigned long base_addr_trace_buffer;
89 unsigned long end_addr_trace_buffer;
90 unsigned short number_trace_elements;
91 unsigned available_buffer_space;
92 unsigned long router_start_time;
93 unsigned char route_status;
94 unsigned char route_removed;
95 unsigned long tick_counter; /* For 5s timeout counter */
96 unsigned long router_up_time;
97 u32 IP_address; /* IP addressing */
98 u32 IP_netmask;
99 unsigned char mc; /* Mulitcast support on/off */
100 unsigned short udp_pkt_lgth; /* udp packet processing */
101 char udp_pkt_src;
102 char udp_pkt_data[MAX_LGTH_UDP_MGNT_PKT];
103 unsigned short timer_int_enabled;
104 char update_comms_stats; /* updating comms stats */
105 //FIXME: add driver stats as per frame relay!
106
107 } chdlc_private_area_t;
108
109 /* Route Status options */
110 #define NO_ROUTE 0x00
111 #define ADD_ROUTE 0x01
112 #define ROUTE_ADDED 0x02
113 #define REMOVE_ROUTE 0x03
114
115
116 /* variable for keeping track of enabling/disabling FT1 monitor status */
117 static int rCount = 0;
118
119 /* variable for tracking how many interfaces to open for WANPIPE on the
120 two ports */
121
122 extern void disable_irq(unsigned int);
123 extern void enable_irq(unsigned int);
124
125 /****** Function Prototypes *************************************************/
126 /* WAN link driver entry points. These are called by the WAN router module. */
127 static int update (wan_device_t* wandev);
128 static int new_if (wan_device_t* wandev, struct net_device* dev,
129 wanif_conf_t* conf);
130 static int del_if (wan_device_t* wandev, struct net_device* dev);
131
132 /* Network device interface */
133 static int if_init (struct net_device* dev);
134 static int if_open (struct net_device* dev);
135 static int if_close (struct net_device* dev);
136 static void if_tx_timeout (struct net_device *dev);
137 static int if_header (struct sk_buff* skb, struct net_device* dev,
138 unsigned short type, void* daddr, void* saddr, unsigned len);
139 #ifdef LINUX_2_1
140 static int if_rebuild_hdr (struct sk_buff *skb);
141 #else
142 static int if_rebuild_hdr (void* hdr, struct net_device* dev, unsigned long raddr,
143 struct sk_buff* skb);
144 #endif
145 static int if_send (struct sk_buff* skb, struct net_device* dev);
146 static struct net_device_stats* if_stats (struct net_device* dev);
147
148 /* CHDLC Firmware interface functions */
149 static int chdlc_configure (sdla_t* card, void* data);
150 static int chdlc_comm_enable (sdla_t* card);
151 static int chdlc_comm_disable (sdla_t* card);
152 static int chdlc_read_version (sdla_t* card, char* str);
153 static int chdlc_set_intr_mode (sdla_t* card, unsigned mode);
154 static int chdlc_send (sdla_t* card, void* data, unsigned len);
155 static int chdlc_read_comm_err_stats (sdla_t* card);
156 static int chdlc_read_op_stats (sdla_t* card);
157
158
159 /* Miscellaneous CHDLC Functions */
160 static int set_chdlc_config (sdla_t* card);
161 static void init_chdlc_tx_rx_buff( sdla_t* card, struct net_device *dev );
162 static int chdlc_error (sdla_t *card, int err, CHDLC_MAILBOX_STRUCT *mb);
163 static int process_chdlc_exception(sdla_t *card);
164 static int process_global_exception(sdla_t *card);
165 static int update_comms_stats(sdla_t* card,
166 chdlc_private_area_t* chdlc_priv_area);
167 static int configure_ip (sdla_t* card);
168 static int unconfigure_ip (sdla_t* card);
169 static void process_route(sdla_t *card);
170 static void port_set_state (sdla_t *card, int);
171
172
173 /* Interrupt handlers */
174 static void wpc_isr (sdla_t* card);
175 static void rx_intr (sdla_t* card);
176 static void timer_intr(sdla_t *);
177
178 /* Miscellaneous functions */
179 static int chk_bcast_mcast_addr(sdla_t* card, struct net_device* dev,
180 struct sk_buff *skb);
181 static int reply_udp( unsigned char *data, unsigned int mbox_len );
182 static int intr_test( sdla_t* card, struct net_device *dev );
183 static int udp_pkt_type( struct sk_buff *skb , sdla_t* card);
184 static int store_udp_mgmt_pkt(char udp_pkt_src, sdla_t* card,
185 struct sk_buff *skb, struct net_device* dev,
186 chdlc_private_area_t* chdlc_priv_area);
187 static int process_udp_mgmt_pkt(sdla_t* card, struct net_device* dev,
188 chdlc_private_area_t* chdlc_priv_area);
189 static unsigned short calc_checksum (char *, int);
190 static void s508_lock (sdla_t *card, unsigned long *smp_flags);
191 static void s508_unlock (sdla_t *card, unsigned long *smp_flags);
192
193
194 static int Intr_test_counter;
195 /****** Public Functions ****************************************************/
196
197 /*============================================================================
198 * Cisco HDLC protocol initialization routine.
199 *
200 * This routine is called by the main WANPIPE module during setup. At this
201 * point adapter is completely initialized and firmware is running.
202 * o read firmware version (to make sure it's alive)
203 * o configure adapter
204 * o initialize protocol-specific fields of the adapter data space.
205 *
206 * Return: 0 o.k.
207 * < 0 failure.
208 */
209 int wpc_init (sdla_t* card, wandev_conf_t* conf)
210 {
211 unsigned char port_num;
212 int err;
213 unsigned long max_permitted_baud = 0;
214
215 union
216 {
217 char str[80];
218 } u;
219 volatile CHDLC_MAILBOX_STRUCT* mb;
220 CHDLC_MAILBOX_STRUCT* mb1;
221 unsigned long timeout;
222
223 /* Verify configuration ID */
224 if (conf->config_id != WANCONFIG_CHDLC) {
225 printk(KERN_INFO "%s: invalid configuration ID %u!\n",
226 card->devname, conf->config_id);
227 return -EINVAL;
228 }
229
230 /* Find out which Port to use */
231 if ((conf->comm_port == WANOPT_PRI) || (conf->comm_port == WANOPT_SEC)){
232 if (card->next){
233
234 if (conf->comm_port != card->next->u.c.comm_port){
235 card->u.c.comm_port = conf->comm_port;
236 }else{
237 printk(KERN_ERR "%s: ERROR - %s port used!\n",
238 card->wandev.name, PORT(conf->comm_port));
239 return -EINVAL;
240 }
241 }else{
242 card->u.c.comm_port = conf->comm_port;
243 }
244 }else{
245 printk(KERN_ERR "%s: ERROR - Invalid Port Selected!\n",
246 card->wandev.name);
247 return -EINVAL;
248 }
249
250
251 /* Initialize protocol-specific fields */
252 if(card->hw.type != SDLA_S514){
253
254 if (card->u.c.comm_port == WANOPT_PRI){
255 card->mbox = (void *) card->hw.dpmbase;
256 }else{
257 card->mbox = (void *) card->hw.dpmbase +
258 SEC_BASE_ADDR_MB_STRUCT - PRI_BASE_ADDR_MB_STRUCT;
259 }
260 }else{
261 /* for a S514 adapter, set a pointer to the actual mailbox in the */
262 /* allocated virtual memory area */
263 if (card->u.c.comm_port == WANOPT_PRI){
264 card->mbox = (void *) card->hw.dpmbase + PRI_BASE_ADDR_MB_STRUCT;
265 }else{
266 card->mbox = (void *) card->hw.dpmbase + SEC_BASE_ADDR_MB_STRUCT;
267 }
268 }
269
270 mb = mb1 = card->mbox;
271
272 if (!card->configured){
273
274 /* The board will place an 'I' in the return code to indicate that it is
275 ready to accept commands. We expect this to be completed in less
276 than 1 second. */
277
278 timeout = jiffies;
279 while (mb->return_code != 'I') /* Wait 1s for board to initialize */
280 if ((jiffies - timeout) > 1*HZ) break;
281
282 if (mb->return_code != 'I') {
283 printk(KERN_INFO
284 "%s: Initialization not completed by adapter\n",
285 card->devname);
286 printk(KERN_INFO "Please contact Sangoma representative.\n");
287 return -EIO;
288 }
289 }
290
291 /* Read firmware version. Note that when adapter initializes, it
292 * clears the mailbox, so it may appear that the first command was
293 * executed successfully when in fact it was merely erased. To work
294 * around this, we execute the first command twice.
295 */
296
297 if (chdlc_read_version(card, u.str))
298 return -EIO;
299
300 printk(KERN_INFO "%s: Running Cisco HDLC firmware v%s\n",
301 card->devname, u.str);
302
303 card->isr = &wpc_isr;
304 card->poll = NULL;
305 card->exec = NULL;
306 card->wandev.update = &update;
307 card->wandev.new_if = &new_if;
308 card->wandev.del_if = &del_if;
309 card->wandev.state = WAN_DUALPORT;
310 card->wandev.udp_port = conf->udp_port;
311
312 card->wandev.new_if_cnt = 0;
313
314 /* This is for the ports link state */
315 card->u.c.state = WAN_DISCONNECTED;
316
317 /* reset the number of times the 'update()' proc has been called */
318 card->u.c.update_call_count = 0;
319
320 card->wandev.ttl = conf->ttl;
321 card->wandev.interface = conf->interface;
322
323 if ((card->u.c.comm_port == WANOPT_SEC && conf->interface == WANOPT_V35)&&
324 card->hw.type != SDLA_S514){
325 printk(KERN_INFO "%s: ERROR - V35 Interface not supported on S508 %s port \n",
326 card->devname, PORT(card->u.c.comm_port));
327 return -EIO;
328 }
329
330 card->wandev.clocking = conf->clocking;
331
332 port_num = card->u.c.comm_port;
333
334 /* Setup Port Bps */
335
336 if(card->wandev.clocking) {
337
338 if(port_num == WANOPT_PRI) {
339 /* For Primary Port 0 */
340 max_permitted_baud =
341 (card->hw.type == SDLA_S514) ?
342 PRI_MAX_BAUD_RATE_S514 :
343 PRI_MAX_BAUD_RATE_S508;
344 }
345 else if(port_num == WANOPT_SEC) {
346 /* For Secondary Port 1 */
347 max_permitted_baud =
348 (card->hw.type == SDLA_S514) ?
349 SEC_MAX_BAUD_RATE_S514 :
350 SEC_MAX_BAUD_RATE_S508;
351 }
352
353 if(conf->bps > max_permitted_baud) {
354 conf->bps = max_permitted_baud;
355 printk(KERN_INFO "%s: Baud too high!\n",
356 card->wandev.name);
357 printk(KERN_INFO "%s: Baud rate set to %lu bps\n",
358 card->wandev.name, max_permitted_baud);
359 }
360
361 card->wandev.bps = conf->bps;
362 }else{
363 card->wandev.bps = 0;
364 }
365
366 /* Setup the Port MTU */
367 if(port_num == WANOPT_PRI) {
368 /* For Primary Port 0 */
369 card->wandev.mtu =
370 (conf->mtu >= MIN_LGTH_CHDLC_DATA_CFG) ?
371 min(conf->mtu, PRI_MAX_NO_DATA_BYTES_IN_FRAME) :
372 CHDLC_DFLT_DATA_LEN;
373 } else if(port_num == WANOPT_SEC) {
374 /* For Secondary Port 1 */
375 card->wandev.mtu =
376 (conf->mtu >= MIN_LGTH_CHDLC_DATA_CFG) ?
377 min(conf->mtu, SEC_MAX_NO_DATA_BYTES_IN_FRAME) :
378 CHDLC_DFLT_DATA_LEN;
379 }
380
381 /* Set up the interrupt status area */
382 /* Read the CHDLC Configuration and obtain:
383 * Ptr to shared memory infor struct
384 * Use this pointer to calculate the value of card->u.c.flags !
385 */
386 mb1->buffer_length = 0;
387 mb1->command = READ_CHDLC_CONFIGURATION;
388 err = sdla_exec(mb1) ? mb1->return_code : CMD_TIMEOUT;
389 if(err != COMMAND_OK) {
390 clear_bit(1, (void*)&card->wandev.critical);
391
392 if(card->hw.type != SDLA_S514)
393 enable_irq(card->hw.irq);
394
395 chdlc_error(card, err, mb1);
396 return -EIO;
397 }
398
399 if(card->hw.type == SDLA_S514){
400 card->u.c.flags = (void *)(card->hw.dpmbase +
401 (((CHDLC_CONFIGURATION_STRUCT *)mb1->data)->
402 ptr_shared_mem_info_struct));
403 }else{
404 card->u.c.flags = (void *)(card->hw.dpmbase +
405 (((CHDLC_CONFIGURATION_STRUCT *)mb1->data)->
406 ptr_shared_mem_info_struct % SDLA_WINDOWSIZE));
407 }
408
409 return 0;
410 }
411
412 /******* WAN Device Driver Entry Points *************************************/
413
414 /*============================================================================
415 * Update device status & statistics
416 * This procedure is called when updating the PROC file system and returns
417 * various communications statistics. These statistics are accumulated from 3
418 * different locations:
419 * 1) The 'if_stats' recorded for the device.
420 * 2) Communication error statistics on the adapter.
421 * 3) CHDLC operational statistics on the adapter.
422 * The board level statistics are read during a timer interrupt. Note that we
423 * read the error and operational statistics during consecitive timer ticks so
424 * as to minimize the time that we are inside the interrupt handler.
425 *
426 */
427 static int update (wan_device_t* wandev)
428 {
429 sdla_t* card = wandev->private;
430 struct net_device* dev = card->wandev.dev;
431 volatile chdlc_private_area_t* chdlc_priv_area = dev->priv;
432 SHARED_MEMORY_INFO_STRUCT *flags;
433 unsigned long timeout;
434
435 /* sanity checks */
436 if((wandev == NULL) || (wandev->private == NULL))
437 return -EFAULT;
438
439 if(wandev->state == WAN_UNCONFIGURED)
440 return -ENODEV;
441
442 /* more sanity checks */
443 if(!card->u.c.flags)
444 return -ENODEV;
445 if(test_bit(1, (void*)&card->wandev.critical))
446 return -EAGAIN;
447
448 if(!netif_running(dev))
449 return -ENODEV;
450
451 flags = card->u.c.flags;
452 if(chdlc_priv_area->update_comms_stats){
453 return -EAGAIN;
454 }
455
456 /* we will need 2 timer interrupts to complete the */
457 /* reading of the statistics */
458 chdlc_priv_area->update_comms_stats = 2;
459 flags->interrupt_info_struct.interrupt_permission |= APP_INT_ON_TIMER;
460 chdlc_priv_area->timer_int_enabled = TMR_INT_ENABLED_UPDATE;
461
462 /* wait a maximum of 1 second for the statistics to be updated */
463 timeout = jiffies;
464 for(;;) {
465 if(chdlc_priv_area->update_comms_stats == 0)
466 break;
467 if ((jiffies - timeout) > (1 * HZ)){
468 chdlc_priv_area->update_comms_stats = 0;
469 chdlc_priv_area->timer_int_enabled &=
470 ~TMR_INT_ENABLED_UPDATE;
471 return -EAGAIN;
472 }
473 }
474
475 return 0;
476 }
477
478
479 /*============================================================================
480 * Create new logical channel.
481 * This routine is called by the router when ROUTER_IFNEW IOCTL is being
482 * handled.
483 * o parse media- and hardware-specific configuration
484 * o make sure that a new channel can be created
485 * o allocate resources, if necessary
486 * o prepare network device structure for registaration.
487 *
488 * Return: 0 o.k.
489 * < 0 failure (channel will not be created)
490 */
491 static int new_if (wan_device_t* wandev, struct net_device* dev, wanif_conf_t* conf)
492 {
493 sdla_t* card = wandev->private;
494 chdlc_private_area_t* chdlc_priv_area;
495
496 if ((conf->name[0] == '\0') || (strlen(conf->name) > WAN_IFNAME_SZ)) {
497 printk(KERN_INFO "%s: invalid interface name!\n",
498 card->devname);
499 return -EINVAL;
500 }
501
502 /* allocate and initialize private data */
503 chdlc_priv_area = kmalloc(sizeof(chdlc_private_area_t), GFP_KERNEL);
504
505 if(chdlc_priv_area == NULL)
506 return -ENOMEM;
507
508 memset(chdlc_priv_area, 0, sizeof(chdlc_private_area_t));
509
510 chdlc_priv_area->card = card;
511
512 /* initialize data */
513 strcpy(card->u.c.if_name, conf->name);
514
515 if(card->wandev.new_if_cnt > 0) {
516 kfree(chdlc_priv_area);
517 return -EEXIST;
518 }
519
520 card->wandev.new_if_cnt++;
521
522 chdlc_priv_area->TracingEnabled = 0;
523 chdlc_priv_area->route_status = NO_ROUTE;
524 chdlc_priv_area->route_removed = 0;
525
526 /* Setup protocol options */
527
528 card->u.c.protocol_options = 0;
529
530 if (conf->ignore_dcd == WANOPT_YES){
531 card->u.c.protocol_options |= IGNORE_DCD_FOR_LINK_STAT;
532 }
533
534 if (conf->ignore_cts == WANOPT_YES){
535 card->u.c.protocol_options |= IGNORE_CTS_FOR_LINK_STAT;
536 }
537
538 if (conf->ignore_keepalive == WANOPT_YES) {
539 card->u.c.protocol_options |= IGNORE_KPALV_FOR_LINK_STAT;
540 card->u.c.kpalv_tx = MIN_Tx_KPALV_TIMER;
541 card->u.c.kpalv_rx = MIN_Rx_KPALV_TIMER;
542 card->u.c.kpalv_err = MIN_KPALV_ERR_TOL;
543
544 } else { /* Do not ignore keepalives */
545
546 card->u.c.kpalv_tx =
547 (conf->keepalive_tx_tmr - MIN_Tx_KPALV_TIMER) >= 0 ?
548 min (conf->keepalive_tx_tmr, MAX_Tx_KPALV_TIMER) :
549 DEFAULT_Tx_KPALV_TIMER;
550
551 card->u.c.kpalv_rx =
552 (conf->keepalive_rx_tmr - MIN_Rx_KPALV_TIMER) >= 0 ?
553 min (conf->keepalive_rx_tmr, MAX_Rx_KPALV_TIMER) :
554 DEFAULT_Rx_KPALV_TIMER;
555
556 card->u.c.kpalv_err =
557 (conf->keepalive_err_margin - MIN_KPALV_ERR_TOL) >= 0 ?
558 min (conf->keepalive_err_margin, MAX_KPALV_ERR_TOL) :
559 DEFAULT_KPALV_ERR_TOL;
560 }
561
562
563 /* Setup slarp timer to control delay between slarps
564 */
565 card->u.c.slarp_timer =
566 (conf->slarp_timer - MIN_SLARP_REQ_TIMER) >=0 ?
567 min (conf->slarp_timer, MAX_SLARP_REQ_TIMER) :
568 DEFAULT_SLARP_REQ_TIMER;
569
570
571 /* If HDLC_STRAMING is enabled then IGNORE DCD, CTS and KEEPALIVES
572 * are automatically ignored
573 */
574 if (conf->hdlc_streaming == WANOPT_YES) {
575 printk(KERN_INFO "%s: Enabling HDLC STREAMING Mode\n",
576 wandev->name);
577 card->u.c.protocol_options = HDLC_STREAMING_MODE;
578 }
579
580
581 /* Setup wanpipe as a router (WANPIPE) or as an API */
582 if( strcmp(conf->usedby, "WANPIPE") == 0) {
583 printk(KERN_INFO "%s: Running in WANPIPE mode !\n",wandev->name);
584 card->u.c.usedby = WANPIPE;
585
586 } else if( strcmp(conf->usedby, "API") == 0){
587
588 #ifdef CHDLC_API
589 card->u.c.usedby = API;
590 printk(KERN_INFO "%s: Running in API mode !\n",wandev->name);
591 #else
592 printk(KERN_INFO "%s: API Mode is not supported!\n",
593 wandev->name);
594 printk(KERN_INFO "%s: Chdlc API patch can be obtained from Sangoma Tech.\n",
595 wandev->name);
596 kfree(chdlc_priv_area);
597 return -EINVAL;
598 #endif
599 }
600
601
602 /* Get Multicast Information */
603 chdlc_priv_area->mc = conf->mc;
604
605 /* prepare network device data space for registration */
606 strcpy(dev->name, card->u.c.if_name);
607 dev->init = &if_init;
608 dev->priv = chdlc_priv_area;
609
610 return 0;
611 }
612
613 /*============================================================================
614 * Delete logical channel.
615 */
616 static int del_if (wan_device_t* wandev, struct net_device* dev)
617 {
618
619 /* FIXME: This code generates kernel panic during
620 router stop!. Investigate futher.
621 (Error is dereferencing a NULL pointer)
622
623 if(dev->priv){
624
625 kfree(dev->priv);
626 dev->priv = NULL;
627
628 }
629 */
630 return 0;
631 }
632
633
634 /****** Network Device Interface ********************************************/
635
636 /*============================================================================
637 * Initialize Linux network interface.
638 *
639 * This routine is called only once for each interface, during Linux network
640 * interface registration. Returning anything but zero will fail interface
641 * registration.
642 */
643 static int if_init (struct net_device* dev)
644 {
645 chdlc_private_area_t* chdlc_priv_area = dev->priv;
646 sdla_t* card = chdlc_priv_area->card;
647 wan_device_t* wandev = &card->wandev;
648 #ifndef LINUX_2_1
649 int i;
650 #endif
651
652 /* Initialize device driver entry points */
653 dev->open = &if_open;
654 dev->stop = &if_close;
655 dev->hard_header = &if_header;
656 dev->rebuild_header = &if_rebuild_hdr;
657 dev->hard_start_xmit = &if_send;
658 dev->get_stats = &if_stats;
659 dev->tx_timeout = &if_tx_timeout;
660 dev->watchdog_timeo = TX_TIMEOUT;
661
662 /* Initialize media-specific parameters */
663 dev->flags |= IFF_POINTTOPOINT;
664
665 /* Enable Mulitcasting if user selected */
666 if (chdlc_priv_area->mc == WANOPT_YES){
667 dev->flags |= IFF_MULTICAST;
668 }
669
670 #ifndef LINUX_2_1
671 dev->family = AF_INET;
672 #endif
673 dev->type = ARPHRD_PPP; /* ARP hw type -- dummy value */
674 dev->mtu = card->wandev.mtu;
675 dev->hard_header_len = CHDLC_HDR_LEN;
676
677 /* Initialize hardware parameters */
678 dev->irq = wandev->irq;
679 dev->dma = wandev->dma;
680 dev->base_addr = wandev->ioport;
681 dev->mem_start = wandev->maddr;
682 dev->mem_end = wandev->maddr + wandev->msize - 1;
683
684 /* Set transmit buffer queue length
685 * If too low packets will not be retransmitted
686 * by stack.
687 */
688 dev->tx_queue_len = 100;
689
690 /* Initialize socket buffers */
691 #ifdef LINUX_2_1
692 dev_init_buffers(dev);
693 #else
694 for (i = 0; i < DEV_NUMBUFFS; ++i)
695 skb_queue_head_init(&dev->buffs[i]);
696 #endif
697
698 return 0;
699 }
700
701 /*============================================================================
702 * Open network interface.
703 * o enable communications and interrupts.
704 * o prevent module from unloading by incrementing use count
705 *
706 * Return 0 if O.k. or errno.
707 */
708 static int if_open (struct net_device* dev)
709 {
710 chdlc_private_area_t* chdlc_priv_area = dev->priv;
711 sdla_t* card = chdlc_priv_area->card;
712 SHARED_MEMORY_INFO_STRUCT* flags = card->u.c.flags;
713 struct timeval tv;
714 int err = 0;
715
716 /* Only one open per interface is allowed */
717
718 if(netif_running(dev))
719 return -EBUSY;
720
721 if(test_and_set_bit(1, (void*)&card->wandev.critical)) {
722 return -EAGAIN;
723 }
724
725 /* Setup the Board for CHDLC */
726 if (set_chdlc_config(card)) {
727 clear_bit(1, (void*)&card->wandev.critical);
728 return -EIO;
729 }
730
731 if (!card->configured && !card->wandev.piggyback){
732 /* Perform interrupt testing */
733 err = intr_test(card, dev);
734
735 if(err || (Intr_test_counter < MAX_INTR_TEST_COUNTER)) {
736 printk(KERN_ERR "%s: Interrupt test failed (%i)\n",
737 card->devname, Intr_test_counter);
738 printk(KERN_ERR "%s: Please choose another interrupt\n",
739 card->devname);
740 clear_bit(1, (void*)&card->wandev.critical);
741 return -EIO;
742 }
743
744 printk(KERN_INFO "%s: Interrupt test passed (%i)\n",
745 card->devname, Intr_test_counter);
746 card->configured = 1;
747 }else{
748 printk(KERN_INFO "%s: Card configured, skip interrupt test\n",
749 card->devname);
750 }
751
752 /* Initialize Rx/Tx buffer control fields */
753 init_chdlc_tx_rx_buff(card, dev);
754
755 /* Set interrupt mode and mask */
756 if (chdlc_set_intr_mode(card, APP_INT_ON_RX_FRAME |
757 APP_INT_ON_GLOBAL_EXCEP_COND |
758 APP_INT_ON_TX_FRAME |
759 APP_INT_ON_CHDLC_EXCEP_COND | APP_INT_ON_TIMER)){
760
761 clear_bit(1, (void*)&card->wandev.critical);
762 return -EIO;
763 }
764
765
766 /* Mask the Transmit and Timer interrupt */
767 flags->interrupt_info_struct.interrupt_permission &=
768 ~(APP_INT_ON_TX_FRAME | APP_INT_ON_TIMER);
769
770
771 /* Enable communications */
772 if (chdlc_comm_enable(card)) {
773 clear_bit(1, (void*)&card->wandev.critical);
774 return -EIO;
775 }
776
777 clear_bit(1, (void*)&card->wandev.critical);
778
779 port_set_state(card, WAN_CONNECTING);
780 do_gettimeofday(&tv);
781 chdlc_priv_area->router_start_time = tv.tv_sec;
782
783 netif_start_queue(dev);
784 dev->flags |= IFF_POINTTOPOINT;
785 wanpipe_open(card);
786
787 return err;
788 }
789
790 /*============================================================================
791 * Close network interface.
792 * o if this is the last close, then disable communications and interrupts.
793 * o reset flags.
794 */
795 static int if_close (struct net_device* dev)
796 {
797 chdlc_private_area_t* chdlc_priv_area = dev->priv;
798 sdla_t* card = chdlc_priv_area->card;
799
800 if(test_and_set_bit(1, (void*)&card->wandev.critical))
801 return -EAGAIN;
802
803 netif_stop_queue(dev);
804 wanpipe_close(card);
805 port_set_state(card, WAN_DISCONNECTED);
806 chdlc_set_intr_mode(card, 0);
807 chdlc_comm_disable(card);
808
809 clear_bit(1, (void*)&card->wandev.critical);
810
811 return 0;
812 }
813
814 /*============================================================================
815 * Build media header.
816 *
817 * The trick here is to put packet type (Ethertype) into 'protocol' field of
818 * the socket buffer, so that we don't forget it. If packet type is not
819 * supported, set skb->protocol to 0 and discard packet later.
820 *
821 * Return: media header length.
822 */
823 static int if_header (struct sk_buff* skb, struct net_device* dev,
824 unsigned short type, void* daddr, void* saddr, unsigned len)
825 {
826 skb->protocol = htons(type);
827
828 return CHDLC_HDR_LEN;
829 }
830
831 /*============================================================================
832 * Re-build media header.
833 *
834 * Return: 1 physical address resolved.
835 * 0 physical address not resolved
836 */
837 #ifdef LINUX_2_1
838 static int if_rebuild_hdr (struct sk_buff *skb)
839 {
840 return 1;
841 }
842 #else
843 static int if_rebuild_hdr (void* hdr, struct net_device* dev, unsigned long raddr,
844 struct sk_buff* skb)
845 {
846 return 1;
847 }
848 #endif
849
850
851 /*============================================================================
852 * Handle transmit timeout event from netif watchdog
853 */
854 static void if_tx_timeout (struct net_device *dev)
855 {
856 chdlc_private_area_t *chdlc_priv_area = dev->priv;
857 sdla_t *card = chdlc_priv_area->card;
858
859 /* If our device stays busy for at least 5 seconds then we will
860 * kick start the device by making dev->tbusy = 0. We expect
861 * that our device never stays busy more than 5 seconds. So this
862 * is only used as a last resort.
863 */
864 ++card->wandev.stats.collisions;
865
866 printk (KERN_INFO "%s: Transmit timeout !\n",
867 card->devname);
868
869 /* unbusy the interface */
870 netif_start_queue (dev);
871 }
872
873
874 /*============================================================================
875 * Send a packet on a network interface.
876 * o set tbusy flag (marks start of the transmission) to block a timer-based
877 * transmit from overlapping.
878 * o check link state. If link is not up, then drop the packet.
879 * o execute adapter send command.
880 * o free socket buffer
881 *
882 * Return: 0 complete (socket buffer must be freed)
883 * non-0 packet may be re-transmitted (tbusy must be set)
884 *
885 * Notes:
886 * 1. This routine is called either by the protocol stack or by the "net
887 * bottom half" (with interrupts enabled).
888 * 2. Setting tbusy flag will inhibit further transmit requests from the
889 * protocol stack and can be used for flow control with protocol layer.
890 */
891 static int if_send (struct sk_buff* skb, struct net_device* dev)
892 {
893 chdlc_private_area_t *chdlc_priv_area = dev->priv;
894 sdla_t *card = chdlc_priv_area->card;
895 SHARED_MEMORY_INFO_STRUCT *flags = card->u.c.flags;
896 INTERRUPT_INFORMATION_STRUCT *chdlc_int = &flags->interrupt_info_struct;
897 int udp_type = 0;
898 unsigned long smp_flags;
899
900 if(skb == NULL) {
901 /* If we get here, some higher layer thinks we've missed an
902 * tx-done interrupt.
903 */
904 printk(KERN_INFO "%s: interface %s got kicked!\n",
905 card->devname, dev->name);
906 netif_wake_queue(dev);
907 return 0;
908 }
909
910 if(ntohs(skb->protocol) != 0x16) {
911
912 /* check the udp packet type */
913 udp_type = udp_pkt_type(skb, card);
914 if(udp_type == UDP_CPIPE_TYPE) {
915 if(store_udp_mgmt_pkt(UDP_PKT_FRM_STACK, card, skb, dev,
916 chdlc_priv_area))
917 chdlc_int->interrupt_permission |=
918 APP_INT_ON_TIMER;
919 return 0;
920 }
921
922 /* check to see if the source IP address is a broadcast or */
923 /* multicast IP address */
924 if(chk_bcast_mcast_addr(card, dev, skb))
925 return 0;
926 }
927
928 /* Lock the 508 Card: SMP is supported */
929 if(card->hw.type != SDLA_S514){
930 s508_lock(card,&smp_flags);
931 }
932
933 if(test_and_set_bit(0, (void*)&card->wandev.critical)) {
934
935 printk(KERN_INFO "%s: Critical in if_send: %x\n",
936 card->wandev.name,card->wandev.critical);
937 ++card->wandev.stats.tx_dropped;
938 #ifdef LINUX_2_1
939 dev_kfree_skb(skb);
940 #else
941 dev_kfree_skb(skb, FREE_WRITE);
942 #endif
943 if(card->hw.type != SDLA_S514){
944 s508_unlock(card,&smp_flags);
945 }
946 return 0;
947 }
948
949 if(card->u.c.state != WAN_CONNECTED)
950 ++card->wandev.stats.tx_dropped;
951
952 else if(!skb->protocol)
953 ++card->wandev.stats.tx_errors;
954
955 else {
956 void* data = skb->data;
957 unsigned len = skb->len;
958 unsigned char attr;
959
960 /* If it's an API packet pull off the API
961 * header. Also check that the packet size
962 * is larger than the API header
963 */
964 if (card->u.c.usedby == API){
965 api_tx_hdr_t* api_tx_hdr;
966
967 if (len <= sizeof(api_tx_hdr_t)){
968 #ifdef LINUX_2_1
969 dev_kfree_skb(skb);
970 #else
971 dev_kfree_skb(skb, FREE_WRITE);
972 #endif
973 ++card->wandev.stats.tx_dropped;
974 clear_bit(0, (void*)&card->wandev.critical);
975 if(card->hw.type != SDLA_S514){
976 s508_unlock(card,&smp_flags);
977 }
978 return 0;
979 }
980
981 api_tx_hdr = (api_tx_hdr_t *)data;
982 attr = api_tx_hdr->attr;
983 data += sizeof(api_tx_hdr_t);
984 len -= sizeof(api_tx_hdr_t);
985 }
986
987 if(chdlc_send(card, data, len)) {
988 netif_stop_queue(dev);
989 chdlc_priv_area->tick_counter = jiffies;
990 chdlc_int->interrupt_permission |= APP_INT_ON_TX_FRAME;
991 }
992 else {
993 ++card->wandev.stats.tx_packets;
994 card->wandev.stats.tx_bytes += len;
995 }
996 }
997
998 if (!netif_queue_stopped(dev))
999 dev_kfree_skb(skb);
1000
1001 clear_bit(0, (void*)&card->wandev.critical);
1002 if(card->hw.type != SDLA_S514){
1003 s508_unlock(card,&smp_flags);
1004 }
1005 return netif_queue_stopped(dev);
1006 }
1007
1008
1009 /*============================================================================
1010 * Check to see if the packet to be transmitted contains a broadcast or
1011 * multicast source IP address.
1012 */
1013
1014 static int chk_bcast_mcast_addr(sdla_t *card, struct net_device* dev,
1015 struct sk_buff *skb)
1016 {
1017 u32 src_ip_addr;
1018 u32 broadcast_ip_addr = 0;
1019 #ifdef LINUX_2_1
1020 struct in_device *in_dev;
1021 #endif
1022 /* read the IP source address from the outgoing packet */
1023 src_ip_addr = *(u32 *)(skb->data + 12);
1024
1025 /* read the IP broadcast address for the device */
1026 #ifdef LINUX_2_1
1027 in_dev = dev->ip_ptr;
1028 if(in_dev != NULL) {
1029 struct in_ifaddr *ifa= in_dev->ifa_list;
1030 if(ifa != NULL)
1031 broadcast_ip_addr = ifa->ifa_broadcast;
1032 else
1033 return 0;
1034 }
1035 #else
1036 broadcast_ip_addr = dev->pa_brdaddr;
1037 #endif
1038
1039 /* check if the IP Source Address is a Broadcast address */
1040 if((dev->flags & IFF_BROADCAST) && (src_ip_addr == broadcast_ip_addr)) {
1041 printk(KERN_INFO "%s: Broadcast Source Address silently discarded\n",
1042 card->devname);
1043 #ifdef LINUX_2_1
1044 dev_kfree_skb(skb);
1045 #else
1046 dev_kfree_skb(skb, FREE_WRITE);
1047 #endif
1048 ++card->wandev.stats.tx_dropped;
1049 return 1;
1050 }
1051
1052 /* check if the IP Source Address is a Multicast address */
1053 if((ntohl(src_ip_addr) >= 0xE0000001) &&
1054 (ntohl(src_ip_addr) <= 0xFFFFFFFE)) {
1055 printk(KERN_INFO "%s: Multicast Source Address silently discarded\n",
1056 card->devname);
1057 #ifdef LINUX_2_1
1058 dev_kfree_skb(skb);
1059 #else
1060 dev_kfree_skb(skb, FREE_WRITE);
1061 #endif
1062 ++card->wandev.stats.tx_dropped;
1063 return 1;
1064 }
1065
1066 return 0;
1067 }
1068
1069
1070 /*============================================================================
1071 * Reply to UDP Management system.
1072 * Return length of reply.
1073 */
1074 static int reply_udp( unsigned char *data, unsigned int mbox_len )
1075 {
1076
1077 unsigned short len, udp_length, temp, ip_length;
1078 unsigned long ip_temp;
1079 int even_bound = 0;
1080 chdlc_udp_pkt_t *c_udp_pkt = (chdlc_udp_pkt_t *)data;
1081
1082 /* Set length of packet */
1083 len = sizeof(ip_pkt_t)+
1084 sizeof(udp_pkt_t)+
1085 sizeof(wp_mgmt_t)+
1086 sizeof(cblock_t)+
1087 sizeof(trace_info_t)+
1088 mbox_len;
1089
1090 /* fill in UDP reply */
1091 c_udp_pkt->wp_mgmt.request_reply = UDPMGMT_REPLY;
1092
1093 /* fill in UDP length */
1094 udp_length = sizeof(udp_pkt_t)+
1095 sizeof(wp_mgmt_t)+
1096 sizeof(cblock_t)+
1097 sizeof(trace_info_t)+
1098 mbox_len;
1099
1100 /* put it on an even boundary */
1101 if ( udp_length & 0x0001 ) {
1102 udp_length += 1;
1103 len += 1;
1104 even_bound = 1;
1105 }
1106
1107 temp = (udp_length<<8)|(udp_length>>8);
1108 c_udp_pkt->udp_pkt.udp_length = temp;
1109
1110 /* swap UDP ports */
1111 temp = c_udp_pkt->udp_pkt.udp_src_port;
1112 c_udp_pkt->udp_pkt.udp_src_port =
1113 c_udp_pkt->udp_pkt.udp_dst_port;
1114 c_udp_pkt->udp_pkt.udp_dst_port = temp;
1115
1116 /* add UDP pseudo header */
1117 temp = 0x1100;
1118 *((unsigned short *)(c_udp_pkt->data+mbox_len+even_bound)) = temp;
1119 temp = (udp_length<<8)|(udp_length>>8);
1120 *((unsigned short *)(c_udp_pkt->data+mbox_len+even_bound+2)) = temp;
1121
1122
1123 /* calculate UDP checksum */
1124 c_udp_pkt->udp_pkt.udp_checksum = 0;
1125 c_udp_pkt->udp_pkt.udp_checksum = calc_checksum(&data[UDP_OFFSET],udp_length+UDP_OFFSET);
1126
1127 /* fill in IP length */
1128 ip_length = len;
1129 temp = (ip_length<<8)|(ip_length>>8);
1130 c_udp_pkt->ip_pkt.total_length = temp;
1131
1132 /* swap IP addresses */
1133 ip_temp = c_udp_pkt->ip_pkt.ip_src_address;
1134 c_udp_pkt->ip_pkt.ip_src_address = c_udp_pkt->ip_pkt.ip_dst_address;
1135 c_udp_pkt->ip_pkt.ip_dst_address = ip_temp;
1136
1137 /* fill in IP checksum */
1138 c_udp_pkt->ip_pkt.hdr_checksum = 0;
1139 c_udp_pkt->ip_pkt.hdr_checksum = calc_checksum(data,sizeof(ip_pkt_t));
1140
1141 return len;
1142
1143 } /* reply_udp */
1144
1145 unsigned short calc_checksum (char *data, int len)
1146 {
1147 unsigned short temp;
1148 unsigned long sum=0;
1149 int i;
1150
1151 for( i = 0; i <len; i+=2 ) {
1152 memcpy(&temp,&data[i],2);
1153 sum += (unsigned long)temp;
1154 }
1155
1156 while (sum >> 16 ) {
1157 sum = (sum & 0xffffUL) + (sum >> 16);
1158 }
1159
1160 temp = (unsigned short)sum;
1161 temp = ~temp;
1162
1163 if( temp == 0 )
1164 temp = 0xffff;
1165
1166 return temp;
1167 }
1168
1169
1170 /*============================================================================
1171 * Get ethernet-style interface statistics.
1172 * Return a pointer to struct net_device_stats.
1173 */
1174 #ifdef LINUX_2_1
1175 static struct net_device_stats* if_stats (struct net_device* dev)
1176 {
1177 sdla_t *my_card;
1178 chdlc_private_area_t* chdlc_priv_area = dev->priv;
1179
1180 my_card = chdlc_priv_area->card;
1181 return &my_card->wandev.stats;
1182 }
1183 #else
1184 static struct net_device_stats* if_stats (struct net_device* dev)
1185 {
1186 sdla_t *my_card;
1187 chdlc_private_area_t* chdlc_priv_area = dev->priv;
1188
1189 my_card = chdlc_priv_area->card;
1190 return &my_card->wandev.stats;
1191 }
1192 #endif
1193
1194 /****** Cisco HDLC Firmware Interface Functions *******************************/
1195
1196 /*============================================================================
1197 * Read firmware code version.
1198 * Put code version as ASCII string in str.
1199 */
1200 static int chdlc_read_version (sdla_t* card, char* str)
1201 {
1202 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1203 int len;
1204 char err;
1205 mb->buffer_length = 0;
1206 mb->command = READ_CHDLC_CODE_VERSION;
1207 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1208
1209 if(err != COMMAND_OK) {
1210 chdlc_error(card,err,mb);
1211 }
1212 else if (str) { /* is not null */
1213 len = mb->buffer_length;
1214 memcpy(str, mb->data, len);
1215 str[len] = '\0';
1216 }
1217 return (err);
1218 }
1219
1220 /*-----------------------------------------------------------------------------
1221 * Configure CHDLC firmware.
1222 */
1223 static int chdlc_configure (sdla_t* card, void* data)
1224 {
1225 int err;
1226 CHDLC_MAILBOX_STRUCT *mailbox = card->mbox;
1227 int data_length = sizeof(CHDLC_CONFIGURATION_STRUCT);
1228
1229 mailbox->buffer_length = data_length;
1230 memcpy(mailbox->data, data, data_length);
1231 mailbox->command = SET_CHDLC_CONFIGURATION;
1232 err = sdla_exec(mailbox) ? mailbox->return_code : CMD_TIMEOUT;
1233
1234 if (err != COMMAND_OK) chdlc_error (card, err, mailbox);
1235
1236 return err;
1237 }
1238
1239
1240 /*============================================================================
1241 * Set interrupt mode -- HDLC Version.
1242 */
1243
1244 static int chdlc_set_intr_mode (sdla_t* card, unsigned mode)
1245 {
1246 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1247 CHDLC_INT_TRIGGERS_STRUCT* int_data =
1248 (CHDLC_INT_TRIGGERS_STRUCT *)mb->data;
1249 int err;
1250
1251 int_data->CHDLC_interrupt_triggers = mode;
1252 int_data->IRQ = card->hw.irq;
1253 int_data->interrupt_timer = 1;
1254
1255 mb->buffer_length = sizeof(CHDLC_INT_TRIGGERS_STRUCT);
1256 mb->command = SET_CHDLC_INTERRUPT_TRIGGERS;
1257 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1258 if (err != COMMAND_OK)
1259 chdlc_error (card, err, mb);
1260 return err;
1261 }
1262
1263
1264 /*============================================================================
1265 * Enable communications.
1266 */
1267
1268 static int chdlc_comm_enable (sdla_t* card)
1269 {
1270 int err;
1271 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1272
1273 mb->buffer_length = 0;
1274 mb->command = ENABLE_CHDLC_COMMUNICATIONS;
1275 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1276 if (err != COMMAND_OK)
1277 chdlc_error(card, err, mb);
1278 return err;
1279 }
1280
1281 /*============================================================================
1282 * Disable communications and Drop the Modem lines (DCD and RTS).
1283 */
1284 static int chdlc_comm_disable (sdla_t* card)
1285 {
1286 int err;
1287 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1288
1289 mb->buffer_length = 0;
1290 mb->command = DISABLE_CHDLC_COMMUNICATIONS;
1291 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1292 if (err != COMMAND_OK)
1293 chdlc_error(card,err,mb);
1294
1295 mb->command = SET_MODEM_STATUS;
1296 mb->buffer_length = 1;
1297 mb->data[0] = 0;
1298 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1299 if (err != COMMAND_OK)
1300 chdlc_error(card,err,mb);
1301
1302 return err;
1303 }
1304
1305 /*============================================================================
1306 * Read communication error statistics.
1307 */
1308 static int chdlc_read_comm_err_stats (sdla_t* card)
1309 {
1310 int err;
1311 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1312
1313 mb->buffer_length = 0;
1314 mb->command = READ_COMMS_ERROR_STATS;
1315 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1316 if (err != COMMAND_OK)
1317 chdlc_error(card,err,mb);
1318 return err;
1319 }
1320
1321
1322 /*============================================================================
1323 * Read CHDLC operational statistics.
1324 */
1325 static int chdlc_read_op_stats (sdla_t* card)
1326 {
1327 int err;
1328 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1329
1330 mb->buffer_length = 0;
1331 mb->command = READ_CHDLC_OPERATIONAL_STATS;
1332 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1333 if (err != COMMAND_OK)
1334 chdlc_error(card,err,mb);
1335 return err;
1336 }
1337
1338
1339 /*============================================================================
1340 * Update communications error and general packet statistics.
1341 */
1342 static int update_comms_stats(sdla_t* card,
1343 chdlc_private_area_t* chdlc_priv_area)
1344 {
1345 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1346 COMMS_ERROR_STATS_STRUCT* err_stats;
1347 CHDLC_OPERATIONAL_STATS_STRUCT *op_stats;
1348
1349 /* on the first timer interrupt, read the comms error statistics */
1350 if(chdlc_priv_area->update_comms_stats == 2) {
1351 if(chdlc_read_comm_err_stats(card))
1352 return 1;
1353 err_stats = (COMMS_ERROR_STATS_STRUCT *)mb->data;
1354 card->wandev.stats.rx_over_errors =
1355 err_stats->Rx_overrun_err_count;
1356 card->wandev.stats.rx_crc_errors =
1357 err_stats->CRC_err_count;
1358 card->wandev.stats.rx_frame_errors =
1359 err_stats->Rx_abort_count;
1360 card->wandev.stats.rx_fifo_errors =
1361 err_stats->Rx_dis_pri_bfrs_full_count;
1362 card->wandev.stats.rx_missed_errors =
1363 card->wandev.stats.rx_fifo_errors;
1364 card->wandev.stats.tx_aborted_errors =
1365 err_stats->sec_Tx_abort_count;
1366 }
1367
1368 /* on the second timer interrupt, read the operational statistics */
1369 else {
1370 if(chdlc_read_op_stats(card))
1371 return 1;
1372 op_stats = (CHDLC_OPERATIONAL_STATS_STRUCT *)mb->data;
1373 card->wandev.stats.rx_length_errors =
1374 (op_stats->Rx_Data_discard_short_count +
1375 op_stats->Rx_Data_discard_long_count);
1376 }
1377
1378 return 0;
1379 }
1380
1381 /*============================================================================
1382 * Send packet.
1383 * Return: 0 - o.k.
1384 * 1 - no transmit buffers available
1385 */
1386 static int chdlc_send (sdla_t* card, void* data, unsigned len)
1387 {
1388 CHDLC_DATA_TX_STATUS_EL_STRUCT *txbuf = card->u.c.txbuf;
1389
1390 if (txbuf->opp_flag)
1391 return 1;
1392
1393 sdla_poke(&card->hw, txbuf->ptr_data_bfr, data, len);
1394
1395 txbuf->frame_length = len;
1396 txbuf->opp_flag = 1; /* start transmission */
1397
1398 /* Update transmit buffer control fields */
1399 card->u.c.txbuf = ++txbuf;
1400
1401 if ((void*)txbuf > card->u.c.txbuf_last)
1402 card->u.c.txbuf = card->u.c.txbuf_base;
1403
1404 return 0;
1405 }
1406
1407 /****** Firmware Error Handler **********************************************/
1408
1409 /*============================================================================
1410 * Firmware error handler.
1411 * This routine is called whenever firmware command returns non-zero
1412 * return code.
1413 *
1414 * Return zero if previous command has to be cancelled.
1415 */
1416 static int chdlc_error (sdla_t *card, int err, CHDLC_MAILBOX_STRUCT *mb)
1417 {
1418 unsigned cmd = mb->command;
1419
1420 switch (err) {
1421
1422 case CMD_TIMEOUT:
1423 printk(KERN_ERR "%s: command 0x%02X timed out!\n",
1424 card->devname, cmd);
1425 break;
1426
1427 case S514_BOTH_PORTS_SAME_CLK_MODE:
1428 if(cmd == SET_CHDLC_CONFIGURATION) {
1429 printk(KERN_INFO
1430 "%s: Configure both ports for the same clock source\n",
1431 card->devname);
1432 break;
1433 }
1434
1435 default:
1436 printk(KERN_INFO "%s: command 0x%02X returned 0x%02X!\n",
1437 card->devname, cmd, err);
1438 }
1439
1440 return 0;
1441 }
1442
1443 /****** Interrupt Handlers **************************************************/
1444
1445 /*============================================================================
1446 * Cisco HDLC interrupt service routine.
1447 */
1448 STATIC void wpc_isr (sdla_t* card)
1449 {
1450 struct net_device* dev;
1451 chdlc_private_area_t* chdlc_priv_area;
1452 SHARED_MEMORY_INFO_STRUCT* flags = NULL;
1453 int i, interrupt_serviced = 0;
1454 sdla_t *my_card;
1455
1456
1457 /* Check for which port the interrupt has been generated
1458 * Since Secondary Port is piggybacking on the Primary
1459 * the check must be done here.
1460 */
1461
1462 flags = card->u.c.flags;
1463 if (!flags->interrupt_info_struct.interrupt_type){
1464 /* Check for a second port (piggybacking) */
1465 if((my_card = card->next)){
1466 flags = my_card->u.c.flags;
1467 if (flags->interrupt_info_struct.interrupt_type){
1468 card = my_card;
1469 }
1470 }
1471 }
1472
1473 dev = card->wandev.dev;
1474
1475 card->in_isr = 1;
1476
1477 /* if critical due to peripheral operations
1478 * ie. update() or getstats() then reset the interrupt and
1479 * wait for the board to retrigger.
1480 */
1481 if(test_bit(1, (void*)&card->wandev.critical)) {
1482 if(card->u.c.flags != NULL) {
1483 flags = card->u.c.flags;
1484 if(flags->interrupt_info_struct.
1485 interrupt_type) {
1486 flags->interrupt_info_struct.
1487 interrupt_type = 0;
1488 }
1489 }
1490 card->in_isr = 0;
1491 return;
1492 }
1493
1494
1495 /* On a 508 Card, if critical due to if_send
1496 * Major Error !!!
1497 */
1498 if(card->hw.type != SDLA_S514) {
1499 if(test_and_set_bit(0, (void*)&card->wandev.critical)) {
1500 printk(KERN_INFO "%s: Critical while in ISR: %x\n",
1501 card->devname, card->wandev.critical);
1502 card->in_isr = 0;
1503 return;
1504 }
1505 }
1506
1507 /* FIXME: Take this check out later in the future */
1508 if(card->u.c.flags != NULL) {
1509
1510 flags = card->u.c.flags;
1511
1512 switch(flags->interrupt_info_struct.interrupt_type) {
1513
1514 case RX_APP_INT_PEND: /* 0x01: receive interrupt */
1515 interrupt_serviced = 1;
1516 rx_intr(card);
1517 break;
1518
1519 case TX_APP_INT_PEND: /* 0x02: transmit interrupt */
1520 interrupt_serviced = 1;
1521 flags->interrupt_info_struct.interrupt_permission &=
1522 ~APP_INT_ON_TX_FRAME;
1523
1524 chdlc_priv_area = dev->priv;
1525 netif_wake_queue(dev);
1526 break;
1527
1528 case COMMAND_COMPLETE_APP_INT_PEND:/* 0x04: cmd cplt */
1529 interrupt_serviced = 1;
1530 ++ Intr_test_counter;
1531 break;
1532
1533 case CHDLC_EXCEP_COND_APP_INT_PEND: /* 0x20 */
1534 interrupt_serviced = 1;
1535 process_chdlc_exception(card);
1536 break;
1537
1538 case GLOBAL_EXCEP_COND_APP_INT_PEND:
1539 interrupt_serviced = 1;
1540 process_global_exception(card);
1541 break;
1542
1543 case TIMER_APP_INT_PEND:
1544 interrupt_serviced = 1;
1545 timer_intr(card);
1546 break;
1547
1548 default:
1549 break;
1550 }
1551 }
1552
1553 if(!interrupt_serviced) {
1554 printk(KERN_INFO "%s: spurious interrupt 0x%02X!\n",
1555 card->devname,
1556 flags->interrupt_info_struct.interrupt_type);
1557 printk(KERN_INFO "Code name: ");
1558 for(i = 0; i < 4; i ++)
1559 printk(KERN_INFO "%c",
1560 flags->global_info_struct.codename[i]);
1561 printk(KERN_INFO "\nCode version: ");
1562 for(i = 0; i < 4; i ++)
1563 printk(KERN_INFO "%c",
1564 flags->global_info_struct.codeversion[i]);
1565 printk(KERN_INFO "\n");
1566 }
1567
1568 card->in_isr = 0;
1569 flags->interrupt_info_struct.interrupt_type = 0;
1570 if(card->hw.type != SDLA_S514){
1571 clear_bit(0, (void*)&card->wandev.critical);
1572 }
1573
1574 }
1575
1576 /*============================================================================
1577 * Receive interrupt handler.
1578 */
1579 static void rx_intr (sdla_t* card)
1580 {
1581 struct net_device *dev;
1582 chdlc_private_area_t *chdlc_priv_area;
1583 SHARED_MEMORY_INFO_STRUCT *flags = card->u.c.flags;
1584 CHDLC_DATA_RX_STATUS_EL_STRUCT *rxbuf = card->u.c.rxmb;
1585 struct sk_buff *skb;
1586 unsigned len;
1587 void *buf;
1588 int i,udp_type;
1589
1590 if (rxbuf->opp_flag != 0x01) {
1591 printk(KERN_INFO
1592 "%s: corrupted Rx buffer @ 0x%X, flag = 0x%02X!\n",
1593 card->devname, (unsigned)rxbuf, rxbuf->opp_flag);
1594 printk(KERN_INFO "Code name: ");
1595 for(i = 0; i < 4; i ++)
1596 printk(KERN_INFO "%c",
1597 flags->global_info_struct.codename[i]);
1598 printk(KERN_INFO "\nCode version: ");
1599 for(i = 0; i < 4; i ++)
1600 printk(KERN_INFO "%c",
1601 flags->global_info_struct.codeversion[i]);
1602 printk(KERN_INFO "\n");
1603 return;
1604 }
1605
1606 dev = card->wandev.dev;
1607 chdlc_priv_area = dev->priv;
1608
1609 if(dev && netif_running(dev)) {
1610
1611 len = rxbuf->frame_length;
1612
1613 /* Allocate socket buffer */
1614 skb = dev_alloc_skb(len);
1615
1616 if (skb != NULL) {
1617 /* Copy data to the socket buffer */
1618 unsigned addr = rxbuf->ptr_data_bfr;
1619
1620 if((addr + len) >
1621 card->u.c.rx_top + 1) {
1622 unsigned tmp =
1623 card->u.c.rx_top - addr + 1;
1624 buf = skb_put(skb, tmp);
1625 sdla_peek(&card->hw, addr, buf, tmp);
1626 addr = card->u.c.rx_base;
1627 len -= tmp;
1628 }
1629
1630 buf = skb_put(skb, len);
1631 sdla_peek(&card->hw, addr, buf, len);
1632
1633 /* Decapsulate packet */
1634 skb->protocol = htons(ETH_P_IP);
1635
1636 card->wandev.stats.rx_packets ++;
1637 #ifdef LINUX_2_1
1638 card->wandev.stats.rx_bytes += skb->len;
1639 #endif
1640 udp_type = udp_pkt_type( skb, card );
1641
1642 if(udp_type == UDP_CPIPE_TYPE) {
1643 if(store_udp_mgmt_pkt(UDP_PKT_FRM_NETWORK,
1644 card, skb, dev, chdlc_priv_area)) {
1645 flags->interrupt_info_struct.
1646 interrupt_permission |=
1647 APP_INT_ON_TIMER;
1648 }
1649
1650 } else {
1651
1652 if(card->u.c.usedby == API) {
1653 api_rx_hdr_t* api_rx_hdr;
1654 skb_push(skb, sizeof(api_rx_hdr_t));
1655 api_rx_hdr =
1656 (api_rx_hdr_t*)&skb->data[0x00];
1657 api_rx_hdr->error_flag =
1658 rxbuf->error_flag;
1659 api_rx_hdr->time_stamp =
1660 rxbuf->time_stamp;
1661 skb->protocol = htons(0x16);
1662 skb->pkt_type = PACKET_HOST;
1663 }
1664
1665 /* FIXME: we should check to see if the received packet is a multicast packet so that we can increment the multicast statistic
1666 ++ chdlc_priv_area->if_stats.multicast;
1667 */
1668 /* Pass it up the protocol stack */
1669 skb->dev = dev;
1670 skb->mac.raw = skb->data;
1671 netif_rx(skb);
1672 }
1673
1674 } else {
1675 printk(KERN_INFO
1676 "%s: no socket buffers available!\n",
1677 card->devname);
1678 ++card->wandev.stats.rx_dropped;
1679 }
1680 }
1681
1682 /* Release buffer element and calculate a pointer to the next one */
1683 rxbuf->opp_flag = 0x00;
1684 card->u.c.rxmb = ++ rxbuf;
1685 if((void*)rxbuf > card->u.c.rxbuf_last)
1686 card->u.c.rxmb = card->u.c.rxbuf_base;
1687 }
1688
1689 /*============================================================================
1690 * Timer interrupt handler.
1691 * The timer interrupt is used for two purposes:
1692 * 1) Processing udp calls from 'cpipemon'.
1693 * 2) Reading board-level statistics for updating the proc file system.
1694 */
1695 void timer_intr(sdla_t *card)
1696 {
1697 struct net_device* dev;
1698 chdlc_private_area_t* chdlc_priv_area = NULL;
1699 SHARED_MEMORY_INFO_STRUCT* flags = NULL;
1700
1701 dev = card->wandev.dev;
1702 chdlc_priv_area = dev->priv;
1703
1704 /* process a udp call if pending */
1705 if(chdlc_priv_area->timer_int_enabled & TMR_INT_ENABLED_UDP) {
1706 process_udp_mgmt_pkt(card, dev,
1707 chdlc_priv_area);
1708 chdlc_priv_area->timer_int_enabled &= ~TMR_INT_ENABLED_UDP;
1709 }
1710
1711 /* read the communications statistics if required */
1712 if(chdlc_priv_area->timer_int_enabled & TMR_INT_ENABLED_UPDATE) {
1713 update_comms_stats(card, chdlc_priv_area);
1714 if(!(-- chdlc_priv_area->update_comms_stats)) {
1715 chdlc_priv_area->timer_int_enabled &=
1716 ~TMR_INT_ENABLED_UPDATE;
1717 }
1718 }
1719
1720 /* only disable the timer interrupt if there are no udp or statistic */
1721 /* updates pending */
1722 if(!chdlc_priv_area->timer_int_enabled) {
1723 flags = card->u.c.flags;
1724 flags->interrupt_info_struct.interrupt_permission &=
1725 ~APP_INT_ON_TIMER;
1726 }
1727 }
1728
1729 /*------------------------------------------------------------------------------
1730 Miscellaneous Functions
1731 - set_chdlc_config() used to set configuration options on the board
1732 ------------------------------------------------------------------------------*/
1733
1734 static int set_chdlc_config(sdla_t* card)
1735 {
1736
1737 struct net_device * dev = card->wandev.dev;
1738 chdlc_private_area_t *chdlc_priv_area = dev->priv;
1739 CHDLC_CONFIGURATION_STRUCT cfg;
1740
1741 memset(&cfg, 0, sizeof(CHDLC_CONFIGURATION_STRUCT));
1742
1743 if(card->wandev.clocking)
1744 cfg.baud_rate = card->wandev.bps;
1745
1746 cfg.line_config_options = (card->wandev.interface == WANOPT_RS232) ?
1747 INTERFACE_LEVEL_RS232 : INTERFACE_LEVEL_V35;
1748
1749 cfg.modem_config_options = 0;
1750 cfg.modem_status_timer = 100;
1751
1752 cfg.CHDLC_protocol_options = card->u.c.protocol_options;
1753 cfg.percent_data_buffer_for_Tx = 50;
1754 cfg.CHDLC_statistics_options = (CHDLC_TX_DATA_BYTE_COUNT_STAT |
1755 CHDLC_RX_DATA_BYTE_COUNT_STAT);
1756 cfg.max_CHDLC_data_field_length = card->wandev.mtu;
1757 cfg.transmit_keepalive_timer = card->u.c.kpalv_tx;
1758 cfg.receive_keepalive_timer = card->u.c.kpalv_rx;
1759 cfg.keepalive_error_tolerance = card->u.c.kpalv_err;
1760 cfg.SLARP_request_timer = card->u.c.slarp_timer;
1761
1762 if (cfg.SLARP_request_timer) {
1763 cfg.IP_address = 0;
1764 cfg.IP_netmask = 0;
1765 }
1766 else {
1767 #ifdef LINUX_2_1
1768 struct in_device *in_dev = dev->ip_ptr;
1769
1770 if(in_dev != NULL) {
1771 struct in_ifaddr *ifa = in_dev->ifa_list;
1772
1773 if (ifa != NULL ) {
1774 cfg.IP_address = ntohl(ifa->ifa_local);
1775 cfg.IP_netmask = ntohl(ifa->ifa_mask);
1776 chdlc_priv_area->IP_address =
1777 ntohl(ifa->ifa_local);
1778 chdlc_priv_area->IP_netmask =
1779 ntohl(ifa->ifa_mask);
1780 }
1781 }
1782 #else
1783 cfg.IP_address = ntohl(dev->pa_addr);
1784 cfg.IP_netmask = ntohl(dev->pa_mask);
1785 chdlc_priv_area->IP_address = ntohl(dev->pa_addr);
1786 chdlc_priv_area->IP_netmask = ntohl(dev->pa_mask);
1787 #endif
1788
1789 /* FIXME: We must re-think this message in next release
1790 if((cfg.IP_address & 0x000000FF) > 2) {
1791 printk(KERN_WARNING "\n");
1792 printk(KERN_WARNING " WARNING:%s configured with an\n",
1793 card->devname);
1794 printk(KERN_WARNING " invalid local IP address.\n");
1795 printk(KERN_WARNING " Slarp pragmatics will fail.\n");
1796 printk(KERN_WARNING " IP address should be of the\n");
1797 printk(KERN_WARNING " format A.B.C.1 or A.B.C.2.\n");
1798 }
1799 */
1800 }
1801
1802 return chdlc_configure(card, &cfg);
1803 }
1804
1805
1806
1807 /*============================================================================
1808 * Process global exception condition
1809 */
1810 static int process_global_exception(sdla_t *card)
1811 {
1812 CHDLC_MAILBOX_STRUCT* mbox = card->mbox;
1813 int err;
1814
1815 mbox->buffer_length = 0;
1816 mbox->command = READ_GLOBAL_EXCEPTION_CONDITION;
1817 err = sdla_exec(mbox) ? mbox->return_code : CMD_TIMEOUT;
1818
1819 if(err != CMD_TIMEOUT ){
1820
1821 switch(mbox->return_code) {
1822
1823 case EXCEP_MODEM_STATUS_CHANGE:
1824
1825 printk(KERN_INFO "%s: Modem status change\n",
1826 card->devname);
1827
1828 switch(mbox->data[0] & (DCD_HIGH | CTS_HIGH)) {
1829 case (DCD_HIGH):
1830 printk(KERN_INFO "%s: DCD high, CTS low\n",card->devname);
1831 break;
1832 case (CTS_HIGH):
1833 printk(KERN_INFO "%s: DCD low, CTS high\n",card->devname); break;
1834 case ((DCD_HIGH | CTS_HIGH)):
1835 printk(KERN_INFO "%s: DCD high, CTS high\n",card->devname);
1836 break;
1837 default:
1838 printk(KERN_INFO "%s: DCD low, CTS low\n",card->devname);
1839 break;
1840 }
1841 break;
1842
1843 case EXCEP_TRC_DISABLED:
1844 printk(KERN_INFO "%s: Line trace disabled\n",
1845 card->devname);
1846 break;
1847
1848 case EXCEP_IRQ_TIMEOUT:
1849 printk(KERN_INFO "%s: IRQ timeout occurred\n",
1850 card->devname);
1851 break;
1852
1853 default:
1854 printk(KERN_INFO "%s: Global exception %x\n",
1855 card->devname, mbox->return_code);
1856 break;
1857 }
1858 }
1859 return 0;
1860 }
1861
1862
1863 /*============================================================================
1864 * Process chdlc exception condition
1865 */
1866 static int process_chdlc_exception(sdla_t *card)
1867 {
1868 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1869 int err;
1870
1871 mb->buffer_length = 0;
1872 mb->command = READ_CHDLC_EXCEPTION_CONDITION;
1873 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1874 if(err != CMD_TIMEOUT) {
1875
1876 switch (err) {
1877
1878 case EXCEP_LINK_ACTIVE:
1879 port_set_state(card, WAN_CONNECTED);
1880 break;
1881
1882 case EXCEP_LINK_INACTIVE_MODEM:
1883 port_set_state(card, WAN_DISCONNECTED);
1884 unconfigure_ip(card);
1885 break;
1886
1887 case EXCEP_LINK_INACTIVE_KPALV:
1888 port_set_state(card, WAN_DISCONNECTED);
1889 printk(KERN_INFO "%s: Keepalive timer expired.\n",
1890 card->devname);
1891 unconfigure_ip(card);
1892 break;
1893
1894 case EXCEP_IP_ADDRESS_DISCOVERED:
1895 if (configure_ip(card))
1896 return -1;
1897 break;
1898
1899 case EXCEP_LOOPBACK_CONDITION:
1900 printk(KERN_INFO "%s: Loopback Condition Detected.\n",
1901 card->devname);
1902 break;
1903
1904 case NO_CHDLC_EXCEP_COND_TO_REPORT:
1905 printk(KERN_INFO "%s: No exceptions reported.\n",
1906 card->devname);
1907 break;
1908 }
1909
1910 }
1911 return 0;
1912 }
1913
1914
1915 /*============================================================================
1916 * Configure IP from SLARP negotiation
1917 * This adds dynamic routes when SLARP has provided valid addresses
1918 */
1919
1920 static int configure_ip (sdla_t* card)
1921 {
1922 struct net_device *dev = card->wandev.dev;
1923 chdlc_private_area_t *chdlc_priv_area = dev->priv;
1924 char err;
1925
1926 /* set to discover */
1927 if(card->u.c.slarp_timer != 0x00) {
1928 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1929 CHDLC_CONFIGURATION_STRUCT *cfg;
1930
1931 mb->buffer_length = 0;
1932 mb->command = READ_CHDLC_CONFIGURATION;
1933 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1934
1935 if(err != COMMAND_OK) {
1936 chdlc_error(card,err,mb);
1937 return -1;
1938 }
1939
1940 cfg = (CHDLC_CONFIGURATION_STRUCT *)mb->data;
1941 chdlc_priv_area->IP_address = cfg->IP_address;
1942 chdlc_priv_area->IP_netmask = cfg->IP_netmask;
1943 }
1944
1945 /* Set flag to add route */
1946 chdlc_priv_area->route_status = ADD_ROUTE;
1947
1948 /* The idea here is to add the route in the poll routine.
1949 This way, we aren't in interrupt context when adding routes */
1950 card->poll = process_route;
1951
1952 return 0;
1953 }
1954
1955
1956 /*============================================================================
1957 * Un-Configure IP negotiated by SLARP
1958 * This removes dynamic routes when the link becomes inactive.
1959 */
1960
1961 static int unconfigure_ip (sdla_t* card)
1962 {
1963 struct net_device *dev = card->wandev.dev;
1964 chdlc_private_area_t *chdlc_priv_area= dev->priv;
1965
1966 if (chdlc_priv_area->route_status == ROUTE_ADDED) {
1967 chdlc_priv_area->route_status = REMOVE_ROUTE;
1968 /* The idea here is to delete the route in
1969 * the poll routine.
1970 * This way, we aren't in interrupt context
1971 * when adding routes
1972 */
1973 card->poll = process_route;
1974 }
1975 return 0;
1976 }
1977
1978 /*============================================================================
1979 * Routine to add/remove routes
1980 * Called like a polling routine when Routes are flagged to be added/removed.
1981 */
1982
1983 static void process_route (sdla_t *card)
1984 {
1985 struct net_device *dev = card->wandev.dev;
1986 unsigned char port_num;
1987 chdlc_private_area_t *chdlc_priv_area = NULL;
1988 u32 local_IP_addr = 0;
1989 u32 remote_IP_addr = 0;
1990 u32 IP_netmask, IP_addr;
1991 int err = 0;
1992 #ifdef LINUX_2_1
1993 struct in_device *in_dev;
1994 mm_segment_t fs;
1995 struct ifreq if_info;
1996 struct sockaddr_in *if_data1, *if_data2;
1997 #else
1998 unsigned long fs = 0;
1999 struct rtentry route;
2000 #endif
2001
2002 chdlc_priv_area = dev->priv;
2003 port_num = card->u.c.comm_port;
2004
2005 if((chdlc_priv_area->route_status == ADD_ROUTE) &&
2006 ((chdlc_priv_area->IP_address & 0x000000FF) > 2)) {
2007 printk(KERN_INFO "%s: Dynamic route failure.\n",card->devname);
2008 if(card->u.c.slarp_timer) {
2009 printk(KERN_INFO "%s: Bad IP address %s received\n",
2010 card->devname,
2011 in_ntoa(ntohl(chdlc_priv_area->IP_address)));
2012 printk(KERN_INFO "%s: from remote station.\n",
2013 card->devname);
2014 }else{
2015 printk(KERN_INFO "%s: Bad IP address %s issued\n",
2016 card->devname,
2017 in_ntoa(ntohl(chdlc_priv_area->IP_address)));
2018 printk(KERN_INFO "%s: to remote station. Local\n",
2019 card->devname);
2020 printk(KERN_INFO "%s: IP address must be A.B.C.1\n",
2021 card->devname);
2022 printk(KERN_INFO "%s: or A.B.C.2.\n",card->devname);
2023 }
2024
2025 /* remove the route due to the IP address error condition */
2026 chdlc_priv_area->route_status = REMOVE_ROUTE;
2027 err = 1;
2028 }
2029
2030 /* If we are removing a route with bad IP addressing, then use the */
2031 /* locally configured IP addresses */
2032 if((chdlc_priv_area->route_status == REMOVE_ROUTE) && err) {
2033
2034 /* do not remove a bad route that has already been removed */
2035 if(chdlc_priv_area->route_removed) {
2036 card->poll = NULL;
2037 return;
2038 }
2039
2040 #ifdef LINUX_2_1
2041 in_dev = dev->ip_ptr;
2042
2043 if(in_dev != NULL) {
2044 struct in_ifaddr *ifa = in_dev->ifa_list;
2045 if (ifa != NULL ) {
2046 local_IP_addr = ifa->ifa_local;
2047 IP_netmask = ifa->ifa_mask;
2048 }
2049 }
2050 #else
2051 local_IP_addr = dev->pa_addr;
2052 remote_IP_addr = dev->pa_dstaddr;
2053 IP_netmask = dev->pa_mask;
2054 #endif
2055 }else{
2056 /* According to Cisco HDLC, if the point-to-point address is
2057 A.B.C.1, then we are the opposite (A.B.C.2), and vice-versa.
2058 */
2059 IP_netmask = ntohl(chdlc_priv_area->IP_netmask);
2060 remote_IP_addr = ntohl(chdlc_priv_area->IP_address);
2061 local_IP_addr = (remote_IP_addr & ntohl(0xFFFFFF00)) +
2062 (~remote_IP_addr & ntohl(0x0003));
2063
2064 if(!card->u.c.slarp_timer) {
2065 IP_addr = local_IP_addr;
2066 local_IP_addr = remote_IP_addr;
2067 remote_IP_addr = IP_addr;
2068 }
2069 }
2070
2071 fs = get_fs(); /* Save file system */
2072 set_fs(get_ds()); /* Get user space block */
2073
2074 #ifdef LINUX_2_1
2075 /* Setup a structure for adding/removing routes */
2076 memset(&if_info, 0, sizeof(if_info));
2077 strcpy(if_info.ifr_name, dev->name);
2078
2079 #else
2080 /* Setup a structure for adding/removing routes */
2081 dev->pa_mask = IP_netmask;
2082 dev->pa_dstaddr = remote_IP_addr;
2083 dev->pa_addr = local_IP_addr;
2084
2085 memset(&route, 0, sizeof(route));
2086 route.rt_dev = dev->name;
2087 route.rt_flags = 0;
2088 ((struct sockaddr_in *)&(route.rt_dst))->sin_addr.s_addr =
2089 dev->pa_dstaddr;
2090 ((struct sockaddr_in *)&(route.rt_dst))->sin_family = AF_INET;
2091 ((struct sockaddr_in *)&(route.rt_genmask))->sin_addr.s_addr =
2092 0xFFFFFFFF;
2093 ((struct sockaddr_in *)&(route.rt_genmask))->sin_family =
2094 AF_INET;
2095 #endif
2096
2097 switch (chdlc_priv_area->route_status) {
2098
2099 case ADD_ROUTE:
2100
2101 if(!card->u.c.slarp_timer) {
2102 #ifdef LINUX_2_1
2103 if_data2 = (struct sockaddr_in *)&if_info.ifr_dstaddr;
2104 if_data2->sin_addr.s_addr = remote_IP_addr;
2105 if_data2->sin_family = AF_INET;
2106 err = devinet_ioctl(SIOCSIFDSTADDR, &if_info);
2107 #else
2108 err = ip_rt_new(&route);
2109 #endif
2110 } else {
2111 #ifdef LINUX_2_1
2112 if_data1 = (struct sockaddr_in *)&if_info.ifr_addr;
2113 if_data1->sin_addr.s_addr = local_IP_addr;
2114 if_data1->sin_family = AF_INET;
2115 if(!(err = devinet_ioctl(SIOCSIFADDR, &if_info))){
2116 if_data2 = (struct sockaddr_in *)&if_info.ifr_dstaddr;
2117 if_data2->sin_addr.s_addr = remote_IP_addr;
2118 if_data2->sin_family = AF_INET;
2119 err = devinet_ioctl(SIOCSIFDSTADDR, &if_info);
2120 }
2121 #else
2122 err = ip_rt_new(&route);
2123 #endif
2124 }
2125
2126 if(err) {
2127 printk(KERN_INFO "%s: Add route %s failed (%d)\n",
2128 card->devname, in_ntoa(remote_IP_addr), err);
2129 } else {
2130 ((chdlc_private_area_t *)dev->priv)->route_status = ROUTE_ADDED;
2131 printk(KERN_INFO "%s: Dynamic route added.\n",
2132 card->devname);
2133 printk(KERN_INFO "%s: Local IP addr : %s\n",
2134 card->devname, in_ntoa(local_IP_addr));
2135 printk(KERN_INFO "%s: Remote IP addr: %s\n",
2136 card->devname, in_ntoa(remote_IP_addr));
2137 chdlc_priv_area->route_removed = 0;
2138 }
2139 break;
2140
2141
2142 case REMOVE_ROUTE:
2143
2144 #ifdef LINUX_2_1
2145 /* Change the local ip address of the interface to 0.
2146 * This will also delete the destination route.
2147 */
2148 if(!card->u.c.slarp_timer) {
2149 if_data2 = (struct sockaddr_in *)&if_info.ifr_dstaddr;
2150 if_data2->sin_addr.s_addr = 0;
2151 if_data2->sin_family = AF_INET;
2152 err = devinet_ioctl(SIOCSIFDSTADDR, &if_info);
2153 } else {
2154 if_data1 = (struct sockaddr_in *)&if_info.ifr_addr;
2155 if_data1->sin_addr.s_addr = 0;
2156 if_data1->sin_family = AF_INET;
2157 err = devinet_ioctl(SIOCSIFADDR,&if_info);
2158
2159 }
2160 #else
2161 /* set the point-to-point IP address to 0.0.0.0 */
2162 dev->pa_dstaddr = 0;
2163 err = ip_rt_kill(&route);
2164 #endif
2165 if(err) {
2166 printk(KERN_INFO
2167 "%s: Remove route %s failed, (err %d)\n",
2168 card->devname, in_ntoa(remote_IP_addr),
2169 err);
2170 } else {
2171 ((chdlc_private_area_t *)dev->priv)->route_status =
2172 NO_ROUTE;
2173 printk(KERN_INFO "%s: Dynamic route removed: %s\n",
2174 card->devname, in_ntoa(local_IP_addr));
2175 chdlc_priv_area->route_removed = 1;
2176 }
2177 break;
2178 }
2179
2180 set_fs(fs); /* Restore file system */
2181
2182 /* Once we've processed the route, stop polling */
2183 card->poll = NULL;
2184
2185 }
2186
2187
2188 /*=============================================================================
2189 * Store a UDP management packet for later processing.
2190 */
2191
2192 static int store_udp_mgmt_pkt(char udp_pkt_src, sdla_t* card,
2193 struct sk_buff *skb, struct net_device* dev,
2194 chdlc_private_area_t* chdlc_priv_area )
2195 {
2196 int udp_pkt_stored = 0;
2197
2198 if(!chdlc_priv_area->udp_pkt_lgth &&
2199 (skb->len <= MAX_LGTH_UDP_MGNT_PKT)) {
2200 chdlc_priv_area->udp_pkt_lgth = skb->len;
2201 chdlc_priv_area->udp_pkt_src = udp_pkt_src;
2202 memcpy(chdlc_priv_area->udp_pkt_data, skb->data, skb->len);
2203 chdlc_priv_area->timer_int_enabled = TMR_INT_ENABLED_UDP;
2204 udp_pkt_stored = 1;
2205 }
2206
2207 #ifdef LINUX_2_1
2208 dev_kfree_skb(skb);
2209 #else
2210 if(udp_pkt_src == UDP_PKT_FRM_STACK)
2211 dev_kfree_skb(skb, FREE_WRITE);
2212 else
2213 dev_kfree_skb(skb, FREE_READ);
2214 #endif
2215
2216 return(udp_pkt_stored);
2217 }
2218
2219
2220 /*=============================================================================
2221 * Process UDP management packet.
2222 */
2223
2224 static int process_udp_mgmt_pkt(sdla_t* card, struct net_device* dev,
2225 chdlc_private_area_t* chdlc_priv_area )
2226 {
2227 unsigned char *buf;
2228 unsigned int frames, len;
2229 struct sk_buff *new_skb;
2230 unsigned short buffer_length, real_len;
2231 unsigned long data_ptr;
2232 unsigned data_length;
2233 int udp_mgmt_req_valid = 1;
2234 CHDLC_MAILBOX_STRUCT *mb = card->mbox;
2235 SHARED_MEMORY_INFO_STRUCT *flags = card->u.c.flags;
2236 chdlc_udp_pkt_t *chdlc_udp_pkt;
2237 struct timeval tv;
2238 int err;
2239 char ut_char;
2240
2241 chdlc_udp_pkt = (chdlc_udp_pkt_t *) chdlc_priv_area->udp_pkt_data;
2242
2243 switch(chdlc_udp_pkt->cblock.command) {
2244
2245 case FT1_MONITOR_STATUS_CTRL:
2246 case CPIPE_ENABLE_TRACING:
2247 case CPIPE_DISABLE_TRACING:
2248 case CPIPE_GET_TRACE_INFO:
2249 case SET_FT1_MODE:
2250 if(chdlc_priv_area->udp_pkt_src ==
2251 UDP_PKT_FRM_NETWORK) {
2252 udp_mgmt_req_valid = 0;
2253 }
2254 break;
2255
2256 default:
2257 break;
2258 }
2259
2260 if(!udp_mgmt_req_valid) {
2261
2262 /* set length to 0 */
2263 chdlc_udp_pkt->cblock.buffer_length = 0;
2264
2265 /* set return code */
2266 chdlc_udp_pkt->cblock.return_code = 0xCD;
2267
2268 } else {
2269 unsigned long trace_status_cfg_addr = 0;
2270 TRACE_STATUS_EL_CFG_STRUCT trace_cfg_struct;
2271 TRACE_STATUS_ELEMENT_STRUCT trace_element_struct;
2272
2273 switch(chdlc_udp_pkt->cblock.command) {
2274
2275 case CPIPE_ENABLE_TRACING:
2276 if (!chdlc_priv_area->TracingEnabled) {
2277
2278 /* OPERATE_DATALINE_MONITOR */
2279
2280 mb->buffer_length = sizeof(LINE_TRACE_CONFIG_STRUCT);
2281 mb->command = SET_TRACE_CONFIGURATION;
2282
2283 ((LINE_TRACE_CONFIG_STRUCT *)mb->data)->
2284 trace_config = TRACE_ACTIVE;
2285 /* Trace delay mode is not used because it slows
2286 down transfer and results in a standoff situation
2287 when there is a lot of data */
2288
2289 /* Configure the Trace based on user inputs */
2290 ((LINE_TRACE_CONFIG_STRUCT *)mb->data)->trace_config |=
2291 chdlc_udp_pkt->data[0];
2292
2293 ((LINE_TRACE_CONFIG_STRUCT *)mb->data)->
2294 trace_deactivation_timer = 4000;
2295
2296
2297 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
2298 if (err != COMMAND_OK) {
2299 chdlc_error(card,err,mb);
2300 card->TracingEnabled = 0;
2301 chdlc_udp_pkt->cblock.return_code = err;
2302 mb->buffer_length = 0;
2303 break;
2304 }
2305
2306 /* Get the base address of the trace element list */
2307 mb->buffer_length = 0;
2308 mb->command = READ_TRACE_CONFIGURATION;
2309 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
2310
2311 if (err != COMMAND_OK) {
2312 chdlc_error(card,err,mb);
2313 chdlc_priv_area->TracingEnabled = 0;
2314 chdlc_udp_pkt->cblock.return_code = err;
2315 mb->buffer_length = 0;
2316 break;
2317 }
2318
2319 trace_status_cfg_addr =((LINE_TRACE_CONFIG_STRUCT *)
2320 mb->data) -> ptr_trace_stat_el_cfg_struct;
2321
2322 sdla_peek(&card->hw, trace_status_cfg_addr,
2323 &trace_cfg_struct, sizeof(trace_cfg_struct));
2324
2325 chdlc_priv_area->start_trace_addr = trace_cfg_struct.
2326 base_addr_trace_status_elements;
2327
2328 chdlc_priv_area->number_trace_elements =
2329 trace_cfg_struct.number_trace_status_elements;
2330
2331 chdlc_priv_area->end_trace_addr = (unsigned long)
2332 ((TRACE_STATUS_ELEMENT_STRUCT *)
2333 chdlc_priv_area->start_trace_addr +
2334 (chdlc_priv_area->number_trace_elements - 1));
2335
2336 chdlc_priv_area->base_addr_trace_buffer =
2337 trace_cfg_struct.base_addr_trace_buffer;
2338
2339 chdlc_priv_area->end_addr_trace_buffer =
2340 trace_cfg_struct.end_addr_trace_buffer;
2341
2342 chdlc_priv_area->curr_trace_addr =
2343 trace_cfg_struct.next_trace_element_to_use;
2344
2345 chdlc_priv_area->available_buffer_space = 2000 -
2346 sizeof(ip_pkt_t) -
2347 sizeof(udp_pkt_t) -
2348 sizeof(wp_mgmt_t) -
2349 sizeof(cblock_t) -
2350 sizeof(trace_info_t);
2351 }
2352 chdlc_udp_pkt->cblock.return_code = COMMAND_OK;
2353 mb->buffer_length = 0;
2354 chdlc_priv_area->TracingEnabled = 1;
2355 break;
2356
2357
2358 case CPIPE_DISABLE_TRACING:
2359 if (chdlc_priv_area->TracingEnabled) {
2360
2361 /* OPERATE_DATALINE_MONITOR */
2362 mb->buffer_length = sizeof(LINE_TRACE_CONFIG_STRUCT);
2363 mb->command = SET_TRACE_CONFIGURATION;
2364 ((LINE_TRACE_CONFIG_STRUCT *)mb->data)->
2365 trace_config = TRACE_INACTIVE;
2366 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
2367 }
2368
2369 chdlc_priv_area->TracingEnabled = 0;
2370 chdlc_udp_pkt->cblock.return_code = COMMAND_OK;
2371 mb->buffer_length = 0;
2372 break;
2373
2374
2375 case CPIPE_GET_TRACE_INFO:
2376
2377 if (!chdlc_priv_area->TracingEnabled) {
2378 chdlc_udp_pkt->cblock.return_code = 1;
2379 mb->buffer_length = 0;
2380 break;
2381 }
2382
2383 chdlc_udp_pkt->trace_info.ismoredata = 0x00;
2384 buffer_length = 0; /* offset of packet already occupied */
2385
2386 for (frames=0; frames < chdlc_priv_area->number_trace_elements; frames++){
2387
2388 trace_pkt_t *trace_pkt = (trace_pkt_t *)
2389 &chdlc_udp_pkt->data[buffer_length];
2390
2391 sdla_peek(&card->hw, chdlc_priv_area->curr_trace_addr,
2392 (unsigned char *)&trace_element_struct,
2393 sizeof(TRACE_STATUS_ELEMENT_STRUCT));
2394
2395 if (trace_element_struct.opp_flag == 0x00) {
2396 break;
2397 }
2398
2399 /* get pointer to real data */
2400 data_ptr = trace_element_struct.ptr_data_bfr;
2401
2402 /* See if there is actual data on the trace buffer */
2403 if (data_ptr){
2404 data_length = trace_element_struct.trace_length;
2405 }else{
2406 data_length = 0;
2407 chdlc_udp_pkt->trace_info.ismoredata = 0x01;
2408 }
2409
2410 if( (chdlc_priv_area->available_buffer_space - buffer_length)
2411 < ( sizeof(trace_pkt_t) + data_length) ) {
2412
2413 /* indicate there are more frames on board & exit */
2414 chdlc_udp_pkt->trace_info.ismoredata = 0x01;
2415 break;
2416 }
2417
2418 trace_pkt->status = trace_element_struct.trace_type;
2419
2420 trace_pkt->time_stamp =
2421 trace_element_struct.trace_time_stamp;
2422
2423 trace_pkt->real_length =
2424 trace_element_struct.trace_length;
2425
2426 /* see if we can fit the frame into the user buffer */
2427 real_len = trace_pkt->real_length;
2428
2429 if (data_ptr == 0) {
2430 trace_pkt->data_avail = 0x00;
2431 } else {
2432 unsigned tmp = 0;
2433
2434 /* get the data from circular buffer
2435 must check for end of buffer */
2436 trace_pkt->data_avail = 0x01;
2437
2438 if ((data_ptr + real_len) >
2439 chdlc_priv_area->end_addr_trace_buffer + 1){
2440
2441 tmp = chdlc_priv_area->end_addr_trace_buffer - data_ptr + 1;
2442 sdla_peek(&card->hw, data_ptr,
2443 trace_pkt->data,tmp);
2444 data_ptr = chdlc_priv_area->base_addr_trace_buffer;
2445 }
2446
2447 sdla_peek(&card->hw, data_ptr,
2448 &trace_pkt->data[tmp], real_len - tmp);
2449 }
2450
2451 /* zero the opp flag to show we got the frame */
2452 ut_char = 0x00;
2453 sdla_poke(&card->hw, chdlc_priv_area->curr_trace_addr, &ut_char, 1);
2454
2455 /* now move onto the next frame */
2456 chdlc_priv_area->curr_trace_addr += sizeof(TRACE_STATUS_ELEMENT_STRUCT);
2457
2458 /* check if we went over the last address */
2459 if ( chdlc_priv_area->curr_trace_addr > chdlc_priv_area->end_trace_addr ) {
2460 chdlc_priv_area->curr_trace_addr = chdlc_priv_area->start_trace_addr;
2461 }
2462
2463 if(trace_pkt->data_avail == 0x01) {
2464 buffer_length += real_len - 1;
2465 }
2466
2467 /* for the header */
2468 buffer_length += sizeof(trace_pkt_t);
2469
2470 } /* For Loop */
2471
2472 if (frames == chdlc_priv_area->number_trace_elements){
2473 chdlc_udp_pkt->trace_info.ismoredata = 0x01;
2474 }
2475 chdlc_udp_pkt->trace_info.num_frames = frames;
2476
2477 mb->buffer_length = buffer_length;
2478 chdlc_udp_pkt->cblock.buffer_length = buffer_length;
2479
2480 chdlc_udp_pkt->cblock.return_code = COMMAND_OK;
2481
2482 break;
2483
2484
2485 case CPIPE_FT1_READ_STATUS:
2486 ((unsigned char *)chdlc_udp_pkt->data )[0] =
2487 flags->FT1_info_struct.parallel_port_A_input;
2488
2489 ((unsigned char *)chdlc_udp_pkt->data )[1] =
2490 flags->FT1_info_struct.parallel_port_B_input;
2491
2492 chdlc_udp_pkt->cblock.return_code = COMMAND_OK;
2493 mb->buffer_length = 2;
2494 break;
2495
2496 case CPIPE_ROUTER_UP_TIME:
2497 do_gettimeofday( &tv );
2498 chdlc_priv_area->router_up_time = tv.tv_sec -
2499 chdlc_priv_area->router_start_time;
2500 *(unsigned long *)&chdlc_udp_pkt->data =
2501 chdlc_priv_area->router_up_time;
2502 mb->buffer_length = sizeof(unsigned long);
2503 break;
2504
2505 case FT1_MONITOR_STATUS_CTRL:
2506 /* Enable FT1 MONITOR STATUS */
2507 if ((chdlc_udp_pkt->data[0] & ENABLE_READ_FT1_STATUS) ||
2508 (chdlc_udp_pkt->data[0] & ENABLE_READ_FT1_OP_STATS)) {
2509
2510 if( rCount++ != 0 ) {
2511 chdlc_udp_pkt->cblock.
2512 return_code = COMMAND_OK;
2513 mb->buffer_length = 1;
2514 break;
2515 }
2516 }
2517
2518 /* Disable FT1 MONITOR STATUS */
2519 if( chdlc_udp_pkt->data[0] == 0) {
2520
2521 if( --rCount != 0) {
2522 chdlc_udp_pkt->cblock.
2523 return_code = COMMAND_OK;
2524 mb->buffer_length = 1;
2525 break;
2526 }
2527 }
2528
2529 default:
2530 /* it's a board command */
2531 mb->command = chdlc_udp_pkt->cblock.command;
2532 mb->buffer_length = chdlc_udp_pkt->cblock.buffer_length;
2533 if (mb->buffer_length) {
2534 memcpy(&mb->data, (unsigned char *) chdlc_udp_pkt->
2535 data, mb->buffer_length);
2536 }
2537 /* run the command on the board */
2538 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
2539 if (err != COMMAND_OK) {
2540 break;
2541 }
2542
2543 /* copy the result back to our buffer */
2544 memcpy(&chdlc_udp_pkt->cblock, mb, sizeof(cblock_t));
2545
2546 if (mb->buffer_length) {
2547 memcpy(&chdlc_udp_pkt->data, &mb->data,
2548 mb->buffer_length);
2549 }
2550
2551 } /* end of switch */
2552 } /* end of else */
2553
2554 /* Fill UDP TTL */
2555 chdlc_udp_pkt->ip_pkt.ttl = card->wandev.ttl;
2556
2557 len = reply_udp(chdlc_priv_area->udp_pkt_data, mb->buffer_length);
2558
2559 if(chdlc_priv_area->udp_pkt_src == UDP_PKT_FRM_NETWORK) {
2560 if(!chdlc_send(card, chdlc_priv_area->udp_pkt_data, len)) {
2561 ++ card->wandev.stats.tx_packets;
2562 #ifdef LINUX_2_1
2563 card->wandev.stats.tx_bytes += len;
2564 #endif
2565 }
2566 } else {
2567
2568 /* Pass it up the stack
2569 Allocate socket buffer */
2570 if ((new_skb = dev_alloc_skb(len)) != NULL) {
2571 /* copy data into new_skb */
2572
2573 buf = skb_put(new_skb, len);
2574 memcpy(buf, chdlc_priv_area->udp_pkt_data, len);
2575
2576 /* Decapsulate pkt and pass it up the protocol stack */
2577 new_skb->protocol = htons(ETH_P_IP);
2578 new_skb->dev = dev;
2579 new_skb->mac.raw = new_skb->data;
2580
2581 netif_rx(new_skb);
2582 } else {
2583
2584 printk(KERN_INFO "%s: no socket buffers available!\n",
2585 card->devname);
2586 }
2587 }
2588
2589 chdlc_priv_area->udp_pkt_lgth = 0;
2590
2591 return 0;
2592 }
2593
2594 /*============================================================================
2595 * Initialize Receive and Transmit Buffers.
2596 */
2597
2598 static void init_chdlc_tx_rx_buff( sdla_t* card, struct net_device *dev )
2599 {
2600 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
2601 CHDLC_TX_STATUS_EL_CFG_STRUCT *tx_config;
2602 CHDLC_RX_STATUS_EL_CFG_STRUCT *rx_config;
2603 char err;
2604
2605 mb->buffer_length = 0;
2606 mb->command = READ_CHDLC_CONFIGURATION;
2607 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
2608
2609 if(err != COMMAND_OK) {
2610 chdlc_error(card,err,mb);
2611 return;
2612 }
2613
2614 if(card->hw.type == SDLA_S514) {
2615 tx_config = (CHDLC_TX_STATUS_EL_CFG_STRUCT *)(card->hw.dpmbase +
2616 (((CHDLC_CONFIGURATION_STRUCT *)mb->data)->
2617 ptr_CHDLC_Tx_stat_el_cfg_struct));
2618 rx_config = (CHDLC_RX_STATUS_EL_CFG_STRUCT *)(card->hw.dpmbase +
2619 (((CHDLC_CONFIGURATION_STRUCT *)mb->data)->
2620 ptr_CHDLC_Rx_stat_el_cfg_struct));
2621
2622 /* Setup Head and Tails for buffers */
2623 card->u.c.txbuf_base = (void *)(card->hw.dpmbase +
2624 tx_config->base_addr_Tx_status_elements);
2625 card->u.c.txbuf_last =
2626 (CHDLC_DATA_TX_STATUS_EL_STRUCT *)
2627 card->u.c.txbuf_base +
2628 (tx_config->number_Tx_status_elements - 1);
2629
2630 card->u.c.rxbuf_base = (void *)(card->hw.dpmbase +
2631 rx_config->base_addr_Rx_status_elements);
2632 card->u.c.rxbuf_last =
2633 (CHDLC_DATA_RX_STATUS_EL_STRUCT *)
2634 card->u.c.rxbuf_base +
2635 (rx_config->number_Rx_status_elements - 1);
2636
2637 /* Set up next pointer to be used */
2638 card->u.c.txbuf = (void *)(card->hw.dpmbase +
2639 tx_config->next_Tx_status_element_to_use);
2640 card->u.c.rxmb = (void *)(card->hw.dpmbase +
2641 rx_config->next_Rx_status_element_to_use);
2642 }
2643 else {
2644 tx_config = (CHDLC_TX_STATUS_EL_CFG_STRUCT *)(card->hw.dpmbase +
2645 (((CHDLC_CONFIGURATION_STRUCT *)mb->data)->
2646 ptr_CHDLC_Tx_stat_el_cfg_struct % SDLA_WINDOWSIZE));
2647
2648 rx_config = (CHDLC_RX_STATUS_EL_CFG_STRUCT *)(card->hw.dpmbase +
2649 (((CHDLC_CONFIGURATION_STRUCT *)mb->data)->
2650 ptr_CHDLC_Rx_stat_el_cfg_struct % SDLA_WINDOWSIZE));
2651
2652 /* Setup Head and Tails for buffers */
2653 card->u.c.txbuf_base = (void *)(card->hw.dpmbase +
2654 (tx_config->base_addr_Tx_status_elements % SDLA_WINDOWSIZE));
2655 card->u.c.txbuf_last =
2656 (CHDLC_DATA_TX_STATUS_EL_STRUCT *)card->u.c.txbuf_base
2657 + (tx_config->number_Tx_status_elements - 1);
2658 card->u.c.rxbuf_base = (void *)(card->hw.dpmbase +
2659 (rx_config->base_addr_Rx_status_elements % SDLA_WINDOWSIZE));
2660 card->u.c.rxbuf_last =
2661 (CHDLC_DATA_RX_STATUS_EL_STRUCT *)card->u.c.rxbuf_base
2662 + (rx_config->number_Rx_status_elements - 1);
2663
2664 /* Set up next pointer to be used */
2665 card->u.c.txbuf = (void *)(card->hw.dpmbase +
2666 (tx_config->next_Tx_status_element_to_use % SDLA_WINDOWSIZE));
2667 card->u.c.rxmb = (void *)(card->hw.dpmbase +
2668 (rx_config->next_Rx_status_element_to_use % SDLA_WINDOWSIZE));
2669 }
2670
2671 /* Setup Actual Buffer Start and end addresses */
2672 card->u.c.rx_base = rx_config->base_addr_Rx_buffer;
2673 card->u.c.rx_top = rx_config->end_addr_Rx_buffer;
2674
2675 }
2676
2677 /*=============================================================================
2678 * Perform Interrupt Test by running READ_CHDLC_CODE_VERSION command MAX_INTR
2679 * _TEST_COUNTER times.
2680 */
2681 static int intr_test( sdla_t* card, struct net_device *dev )
2682 {
2683 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
2684 int err,i;
2685
2686 Intr_test_counter = 0;
2687
2688 /* The critical flag is unset because during intialization (if_open)
2689 * we want the interrupts to be enabled so that when the wpc_isr is
2690 * called it does not exit due to critical flag set.
2691 */
2692
2693 clear_bit(1, (void*)&card->wandev.critical);
2694 err = chdlc_set_intr_mode(card, APP_INT_ON_COMMAND_COMPLETE);
2695
2696 if (err == CMD_OK) {
2697 for (i = 0; i < MAX_INTR_TEST_COUNTER; i ++) {
2698 mb->buffer_length = 0;
2699 mb->command = READ_CHDLC_CODE_VERSION;
2700 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
2701 if (err != CMD_OK)
2702 chdlc_error(card, err, mb);
2703 }
2704 }
2705 else {
2706 return err;
2707 }
2708
2709 err = chdlc_set_intr_mode(card, 0);
2710 set_bit(1, (void*)&card->wandev.critical);
2711
2712
2713 if (err != CMD_OK)
2714 return err;
2715
2716 return 0;
2717 }
2718
2719 /*==============================================================================
2720 * Determine what type of UDP call it is. CPIPEAB ?
2721 */
2722 static int udp_pkt_type(struct sk_buff *skb, sdla_t* card)
2723 {
2724 chdlc_udp_pkt_t *chdlc_udp_pkt = (chdlc_udp_pkt_t *)skb->data;
2725
2726 if (!strncmp(chdlc_udp_pkt->wp_mgmt.signature,UDPMGMT_SIGNATURE,8) &&
2727 (chdlc_udp_pkt->udp_pkt.udp_dst_port == ntohs(card->wandev.udp_port)) &&
2728 (chdlc_udp_pkt->ip_pkt.protocol == UDPMGMT_UDP_PROTOCOL) &&
2729 (chdlc_udp_pkt->wp_mgmt.request_reply == UDPMGMT_REQUEST)) {
2730 return UDP_CPIPE_TYPE;
2731 }
2732 else return UDP_INVALID_TYPE;
2733 }
2734
2735 /*============================================================================
2736 * Set PORT state.
2737 */
2738 static void port_set_state (sdla_t *card, int state)
2739 {
2740 if (card->u.c.state != state)
2741 {
2742 switch (state)
2743 {
2744 case WAN_CONNECTED:
2745 printk (KERN_INFO "%s: Link connected!\n",
2746 card->devname);
2747 break;
2748
2749 case WAN_CONNECTING:
2750 printk (KERN_INFO "%s: Link connecting...\n",
2751 card->devname);
2752 break;
2753
2754 case WAN_DISCONNECTED:
2755 printk (KERN_INFO "%s: Link disconnected!\n",
2756 card->devname);
2757 break;
2758 }
2759
2760 card->wandev.state = card->u.c.state = state;
2761 }
2762 }
2763
2764 void s508_lock (sdla_t *card, unsigned long *smp_flags)
2765 {
2766 #ifdef CONFIG_SMP
2767 spin_lock_irqsave(&card->lock, *smp_flags);
2768 if (card->next){
2769 spin_lock(&card->next->lock);
2770 }
2771 #else
2772 disable_irq(card->hw.irq);
2773 #endif
2774 }
2775
2776 void s508_unlock (sdla_t *card, unsigned long *smp_flags)
2777 {
2778 #ifdef CONFIG_SMP
2779 if (card->next){
2780 spin_unlock(&card->next->lock);
2781 }
2782 spin_unlock_irqrestore(&card->lock, *smp_flags);
2783 #else
2784 enable_irq(card->hw.irq);
2785 #endif
2786 }
2787
2788 /****** End ****************************************************************/
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux