Merge branch 'master'
[linux-2.6] / drivers / net / wan / sdlamain.c
1 /****************************************************************************
2 * sdlamain.c    WANPIPE(tm) Multiprotocol WAN Link Driver.  Main module.
3 *
4 * Author:       Nenad Corbic    <ncorbic@sangoma.com>
5 *               Gideon Hack     
6 *
7 * Copyright:    (c) 1995-2000 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 * Dec 22, 2000  Nenad Corbic    Updated for 2.4.X kernels.
15 *                               Removed the polling routine.
16 * Nov 13, 2000  Nenad Corbic    Added hw probing on module load and dynamic
17 *                               device allocation. 
18 * Nov 7,  2000  Nenad Corbic    Fixed the Multi-Port PPP for kernels
19 *                               2.2.16 and above.
20 * Aug 2,  2000  Nenad Corbic    Block the Multi-Port PPP from running on
21 *                               kernels 2.2.16 or greater.  The SyncPPP 
22 *                               has changed.
23 * Jul 25, 2000  Nenad Corbic    Updated the Piggiback support for MultPPPP.
24 * Jul 13, 2000  Nenad Corbic    Added Multi-PPP support.
25 * Feb 02, 2000  Nenad Corbic    Fixed up piggyback probing and selection.
26 * Sep 23, 1999  Nenad Corbic    Added support for SMP
27 * Sep 13, 1999  Nenad Corbic    Each port is treated as a separate device.
28 * Jun 02, 1999  Gideon Hack     Added support for the S514 adapter.
29 *                               Updates for Linux 2.2.X kernels.
30 * Sep 17, 1998  Jaspreet Singh  Updated for 2.1.121+ kernel
31 * Nov 28, 1997  Jaspreet Singh  Changed DRV_RELEASE to 1
32 * Nov 10, 1997  Jaspreet Singh  Changed sti() to restore_flags();
33 * Nov 06, 1997  Jaspreet Singh  Changed DRV_VERSION to 4 and DRV_RELEASE to 0
34 * Oct 20, 1997  Jaspreet Singh  Modified sdla_isr routine so that card->in_isr
35 *                               assignments are taken out and placed in the
36 *                               sdla_ppp.c, sdla_fr.c and sdla_x25.c isr
37 *                               routines. Took out 'wandev->tx_int_enabled' and
38 *                               replaced it with 'wandev->enable_tx_int'. 
39 * May 29, 1997  Jaspreet Singh  Flow Control Problem
40 *                               added "wandev->tx_int_enabled=1" line in the
41 *                               init module. This line initializes the flag for 
42 *                               preventing Interrupt disabled with device set to
43 *                               busy
44 * Jan 15, 1997  Gene Kozin      Version 3.1.0
45 *                                o added UDP management stuff
46 * Jan 02, 1997  Gene Kozin      Initial version.
47 *****************************************************************************/
48
49 #include <linux/config.h>       /* OS configuration options */
50 #include <linux/stddef.h>       /* offsetof(), etc. */
51 #include <linux/errno.h>        /* return codes */
52 #include <linux/string.h>       /* inline memset(), etc. */
53 #include <linux/init.h>
54 #include <linux/slab.h> /* kmalloc(), kfree() */
55 #include <linux/kernel.h>       /* printk(), and other useful stuff */
56 #include <linux/module.h>       /* support for loadable modules */
57 #include <linux/ioport.h>       /* request_region(), release_region() */
58 #include <linux/wanrouter.h>    /* WAN router definitions */
59 #include <linux/wanpipe.h>      /* WANPIPE common user API definitions */
60 #include <linux/rcupdate.h>
61
62 #include <linux/in.h>
63 #include <asm/io.h>             /* phys_to_virt() */
64 #include <linux/pci.h>
65 #include <linux/sdlapci.h>
66 #include <linux/if_wanpipe_common.h>
67
68 #include <asm/uaccess.h>        /* kernel <-> user copy */
69 #include <linux/inetdevice.h>
70
71 #include <linux/ip.h>
72 #include <net/route.h>
73  
74 #define KMEM_SAFETYZONE 8
75
76
77 #ifndef CONFIG_WANPIPE_FR
78   #define wpf_init(a,b) (-EPROTONOSUPPORT) 
79 #endif
80
81 #ifndef CONFIG_WANPIPE_CHDLC
82  #define wpc_init(a,b) (-EPROTONOSUPPORT) 
83 #endif
84
85 #ifndef CONFIG_WANPIPE_X25
86  #define wpx_init(a,b) (-EPROTONOSUPPORT) 
87 #endif
88  
89 #ifndef CONFIG_WANPIPE_PPP
90  #define wpp_init(a,b) (-EPROTONOSUPPORT) 
91 #endif
92
93 #ifndef CONFIG_WANPIPE_MULTPPP 
94  #define wsppp_init(a,b) (-EPROTONOSUPPORT) 
95 #endif
96  
97  
98 /***********FOR DEBUGGING PURPOSES*********************************************
99 static void * dbg_kmalloc(unsigned int size, int prio, int line) {
100         int i = 0;
101         void * v = kmalloc(size+sizeof(unsigned int)+2*KMEM_SAFETYZONE*8,prio);
102         char * c1 = v;  
103         c1 += sizeof(unsigned int);
104         *((unsigned int *)v) = size;
105
106         for (i = 0; i < KMEM_SAFETYZONE; i++) {
107                 c1[0] = 'D'; c1[1] = 'E'; c1[2] = 'A'; c1[3] = 'D';
108                 c1[4] = 'B'; c1[5] = 'E'; c1[6] = 'E'; c1[7] = 'F';
109                 c1 += 8;
110         }
111         c1 += size;
112         for (i = 0; i < KMEM_SAFETYZONE; i++) {
113                 c1[0] = 'M'; c1[1] = 'U'; c1[2] = 'N'; c1[3] = 'G';
114                 c1[4] = 'W'; c1[5] = 'A'; c1[6] = 'L'; c1[7] = 'L';
115                 c1 += 8;
116         }
117         v = ((char *)v) + sizeof(unsigned int) + KMEM_SAFETYZONE*8;
118         printk(KERN_INFO "line %d  kmalloc(%d,%d) = %p\n",line,size,prio,v);
119         return v;
120 }
121 static void dbg_kfree(void * v, int line) {
122         unsigned int * sp = (unsigned int *)(((char *)v) - (sizeof(unsigned int) + KMEM_SAFETYZONE*8));
123         unsigned int size = *sp;
124         char * c1 = ((char *)v) - KMEM_SAFETYZONE*8;
125         int i = 0;
126         for (i = 0; i < KMEM_SAFETYZONE; i++) {
127                 if (   c1[0] != 'D' || c1[1] != 'E' || c1[2] != 'A' || c1[3] != 'D'
128                     || c1[4] != 'B' || c1[5] != 'E' || c1[6] != 'E' || c1[7] != 'F') {
129                         printk(KERN_INFO "kmalloced block at %p has been corrupted (underrun)!\n",v);
130                         printk(KERN_INFO " %4x: %2x %2x %2x %2x %2x %2x %2x %2x\n", i*8,
131                                         c1[0],c1[1],c1[2],c1[3],c1[4],c1[5],c1[6],c1[7] );
132                 }
133                 c1 += 8;
134         }
135         c1 += size;
136         for (i = 0; i < KMEM_SAFETYZONE; i++) {
137                 if (   c1[0] != 'M' || c1[1] != 'U' || c1[2] != 'N' || c1[3] != 'G'
138                     || c1[4] != 'W' || c1[5] != 'A' || c1[6] != 'L' || c1[7] != 'L'
139                    ) {
140                         printk(KERN_INFO "kmalloced block at %p has been corrupted (overrun):\n",v);
141                         printk(KERN_INFO " %4x: %2x %2x %2x %2x %2x %2x %2x %2x\n", i*8,
142                                         c1[0],c1[1],c1[2],c1[3],c1[4],c1[5],c1[6],c1[7] );
143                 }
144                 c1 += 8;
145         }
146         printk(KERN_INFO "line %d  kfree(%p)\n",line,v);
147         v = ((char *)v) - (sizeof(unsigned int) + KMEM_SAFETYZONE*8);
148         kfree(v);
149 }
150
151 #define kmalloc(x,y) dbg_kmalloc(x,y,__LINE__)
152 #define kfree(x) dbg_kfree(x,__LINE__)
153 ******************************************************************************/
154
155
156
157 /****** Defines & Macros ****************************************************/
158
159 #ifdef  _DEBUG_
160 #define STATIC
161 #else
162 #define STATIC          static
163 #endif
164
165 #define DRV_VERSION     5               /* version number */
166 #define DRV_RELEASE     0               /* release (minor version) number */
167 #define MAX_CARDS       16              /* max number of adapters */
168
169 #ifndef CONFIG_WANPIPE_CARDS            /* configurable option */
170 #define CONFIG_WANPIPE_CARDS 1
171 #endif
172
173 #define CMD_OK          0               /* normal firmware return code */
174 #define CMD_TIMEOUT     0xFF            /* firmware command timed out */
175 #define MAX_CMD_RETRY   10              /* max number of firmware retries */
176 /****** Function Prototypes *************************************************/
177
178 extern void disable_irq(unsigned int);
179 extern void enable_irq(unsigned int);
180  
181 /* WAN link driver entry points */
182 static int setup(struct wan_device* wandev, wandev_conf_t* conf);
183 static int shutdown(struct wan_device* wandev);
184 static int ioctl(struct wan_device* wandev, unsigned cmd, unsigned long arg);
185
186 /* IOCTL handlers */
187 static int ioctl_dump   (sdla_t* card, sdla_dump_t* u_dump);
188 static int ioctl_exec   (sdla_t* card, sdla_exec_t* u_exec, int);
189
190 /* Miscellaneous functions */
191 STATIC irqreturn_t sdla_isr     (int irq, void* dev_id, struct pt_regs *regs);
192 static void release_hw  (sdla_t *card);
193
194 static int check_s508_conflicts (sdla_t* card,wandev_conf_t* conf, int*);
195 static int check_s514_conflicts (sdla_t* card,wandev_conf_t* conf, int*);
196
197
198 /****** Global Data **********************************************************
199  * Note: All data must be explicitly initialized!!!
200  */
201
202 /* private data */
203 static char drvname[]   = "wanpipe";
204 static char fullname[]  = "WANPIPE(tm) Multiprotocol Driver";
205 static char copyright[] = "(c) 1995-2000 Sangoma Technologies Inc.";
206 static int ncards; 
207 static sdla_t* card_array;              /* adapter data space */
208
209 /* Wanpipe's own workqueue, used for all API's.
210  * All protocol specific tasks will be inserted
211  * into the "wanpipe_wq" workqueue. 
212
213  * The kernel workqueue mechanism will execute
214  * all pending tasks in the "wanpipe_wq" workqueue.
215  */
216
217 struct workqueue_struct *wanpipe_wq;
218 DECLARE_WORK(wanpipe_work, NULL, NULL);
219
220 static int wanpipe_bh_critical;
221
222 /******* Kernel Loadable Module Entry Points ********************************/
223
224 /*============================================================================
225  * Module 'insert' entry point.
226  * o print announcement
227  * o allocate adapter data space
228  * o initialize static data
229  * o register all cards with WAN router
230  * o calibrate SDLA shared memory access delay.
231  *
232  * Return:      0       Ok
233  *              < 0     error.
234  * Context:     process
235  */
236  
237 static int __init wanpipe_init(void)
238 {
239         int cnt, err = 0;
240
241         printk(KERN_INFO "%s v%u.%u %s\n",
242                 fullname, DRV_VERSION, DRV_RELEASE, copyright);
243
244         wanpipe_wq = create_workqueue("wanpipe_wq");
245         if (!wanpipe_wq)
246                 return -ENOMEM;
247
248         /* Probe for wanpipe cards and return the number found */
249         printk(KERN_INFO "wanpipe: Probing for WANPIPE hardware.\n");
250         ncards = wanpipe_hw_probe();
251         if (ncards){
252                 printk(KERN_INFO "wanpipe: Allocating maximum %i devices: wanpipe%i - wanpipe%i.\n",ncards,1,ncards);
253         }else{
254                 printk(KERN_INFO "wanpipe: No S514/S508 cards found, unloading modules!\n");
255                 destroy_workqueue(wanpipe_wq);
256                 return -ENODEV;
257         }
258         
259         /* Verify number of cards and allocate adapter data space */
260         card_array = kmalloc(sizeof(sdla_t) * ncards, GFP_KERNEL);
261         if (card_array == NULL) {
262                 destroy_workqueue(wanpipe_wq);
263                 return -ENOMEM;
264         }
265
266         memset(card_array, 0, sizeof(sdla_t) * ncards);
267
268         /* Register adapters with WAN router */
269         for (cnt = 0; cnt < ncards; ++ cnt) {
270                 sdla_t* card = &card_array[cnt];
271                 struct wan_device* wandev = &card->wandev;
272
273                 card->next = NULL;
274                 sprintf(card->devname, "%s%d", drvname, cnt + 1);
275                 wandev->magic    = ROUTER_MAGIC;
276                 wandev->name     = card->devname;
277                 wandev->private  = card;
278                 wandev->enable_tx_int = 0;
279                 wandev->setup    = &setup;
280                 wandev->shutdown = &shutdown;
281                 wandev->ioctl    = &ioctl;
282                 err = register_wan_device(wandev);
283                 if (err) {
284                         printk(KERN_INFO
285                                 "%s: %s registration failed with error %d!\n",
286                                 drvname, card->devname, err);
287                         break;
288                 }
289         }
290         if (cnt){
291                 ncards = cnt;   /* adjust actual number of cards */
292         }else {
293                 kfree(card_array);
294                 destroy_workqueue(wanpipe_wq);
295                 printk(KERN_INFO "IN Init Module: NO Cards registered\n");
296                 err = -ENODEV;
297         }
298
299         return err;
300 }
301
302 /*============================================================================
303  * Module 'remove' entry point.
304  * o unregister all adapters from the WAN router
305  * o release all remaining system resources
306  */
307 static void __exit wanpipe_cleanup(void)
308 {
309         int i;
310
311         if (!ncards)
312                 return;
313                 
314         for (i = 0; i < ncards; ++i) {
315                 sdla_t* card = &card_array[i];
316                 unregister_wan_device(card->devname);
317         }
318         destroy_workqueue(wanpipe_wq);
319         kfree(card_array);
320
321         printk(KERN_INFO "\nwanpipe: WANPIPE Modules Unloaded.\n");
322 }
323
324 module_init(wanpipe_init);
325 module_exit(wanpipe_cleanup);
326
327 /******* WAN Device Driver Entry Points *************************************/
328
329 /*============================================================================
330  * Setup/configure WAN link driver.
331  * o check adapter state
332  * o make sure firmware is present in configuration
333  * o make sure I/O port and IRQ are specified
334  * o make sure I/O region is available
335  * o allocate interrupt vector
336  * o setup SDLA hardware
337  * o call appropriate routine to perform protocol-specific initialization
338  * o mark I/O region as used
339  * o if this is the first active card, then schedule background task
340  *
341  * This function is called when router handles ROUTER_SETUP IOCTL. The
342  * configuration structure is in kernel memory (including extended data, if
343  * any).
344  */
345  
346 static int setup(struct wan_device* wandev, wandev_conf_t* conf)
347 {
348         sdla_t* card;
349         int err = 0;
350         int irq=0;
351
352         /* Sanity checks */
353         if ((wandev == NULL) || (wandev->private == NULL) || (conf == NULL)){
354                 printk(KERN_INFO 
355                       "%s: Failed Sdlamain Setup wandev %u, card %u, conf %u !\n",
356                       wandev->name,
357                       (unsigned int)wandev,(unsigned int)wandev->private,
358                       (unsigned int)conf); 
359                 return -EFAULT;
360         }
361
362         printk(KERN_INFO "%s: Starting WAN Setup\n", wandev->name);
363
364         card = wandev->private;
365         if (wandev->state != WAN_UNCONFIGURED){
366                 printk(KERN_INFO "%s: failed sdlamain setup, busy!\n",
367                         wandev->name);
368                 return -EBUSY;          /* already configured */
369         }
370
371         printk(KERN_INFO "\nProcessing WAN device %s...\n", wandev->name);
372
373         /* Initialize the counters for each wandev 
374          * Used for counting number of times new_if and 
375          * del_if get called.
376          */
377         wandev->del_if_cnt = 0;
378         wandev->new_if_cnt = 0;
379         wandev->config_id  = conf->config_id;
380
381         if (!conf->data_size || (conf->data == NULL)) {
382                 printk(KERN_INFO
383                         "%s: firmware not found in configuration data!\n",
384                         wandev->name);
385                 return -EINVAL;
386         }
387
388         /* Check for resource conflicts and setup the
389          * card for piggibacking if necessary */
390         if(!conf->S514_CPU_no[0]) {
391                 if ((err=check_s508_conflicts(card,conf,&irq)) != 0){
392                         return err;
393                 }
394         }else {
395                 if ((err=check_s514_conflicts(card,conf,&irq)) != 0){
396                         return err;
397                 }
398         }
399
400         /* If the current card has already been configured
401          * or it's a piggyback card, do not try to allocate
402          * resources.
403          */
404         if (!card->wandev.piggyback && !card->configured){
405
406                 /* Configure hardware, load firmware, etc. */
407                 memset(&card->hw, 0, sizeof(sdlahw_t));
408
409                 /* for an S514 adapter, pass the CPU number and the slot number read */
410                 /* from 'router.conf' to the 'sdla_setup()' function via the 'port' */
411                 /* parameter */
412                 if (conf->S514_CPU_no[0]){
413
414                         card->hw.S514_cpu_no[0] = conf->S514_CPU_no[0];
415                         card->hw.S514_slot_no = conf->PCI_slot_no;
416                         card->hw.auto_pci_cfg = conf->auto_pci_cfg;
417
418                         if (card->hw.auto_pci_cfg == WANOPT_YES){
419                                 printk(KERN_INFO "%s: Setting CPU to %c and Slot to Auto\n",
420                                 card->devname, card->hw.S514_cpu_no[0]);
421                         }else{
422                                 printk(KERN_INFO "%s: Setting CPU to %c and Slot to %i\n",
423                                 card->devname, card->hw.S514_cpu_no[0], card->hw.S514_slot_no);
424                         }
425
426                 }else{
427                         /* 508 Card io port and irq initialization */
428                         card->hw.port = conf->ioport;
429                         card->hw.irq = (conf->irq == 9) ? 2 : conf->irq;
430                 }
431
432
433                 /* Compute the virtual address of the card in kernel space */
434                 if(conf->maddr){
435                         card->hw.dpmbase = phys_to_virt(conf->maddr);
436                 }else{  
437                         card->hw.dpmbase = (void *)conf->maddr;
438                 }
439                         
440                 card->hw.dpmsize = SDLA_WINDOWSIZE;
441                 
442                 /* set the adapter type if using an S514 adapter */
443                 card->hw.type = (conf->S514_CPU_no[0]) ? SDLA_S514 : conf->hw_opt[0]; 
444                 card->hw.pclk = conf->hw_opt[1];
445
446                 err = sdla_setup(&card->hw, conf->data, conf->data_size);
447                 if (err){
448                         printk(KERN_INFO "%s: Hardware setup Failed %i\n",
449                                         card->devname,err);
450                         return err;
451                 }
452
453                 if(card->hw.type != SDLA_S514)
454                         irq = (conf->irq == 2) ? 9 : conf->irq; /* IRQ2 -> IRQ9 */
455                 else
456                         irq = card->hw.irq;
457
458                 /* request an interrupt vector - note that interrupts may be shared */
459                 /* when using the S514 PCI adapter */
460                 
461                 if(request_irq(irq, sdla_isr, 
462                       (card->hw.type == SDLA_S514) ? SA_SHIRQ : 0, 
463                        wandev->name, card)){
464
465                         printk(KERN_INFO "%s: Can't reserve IRQ %d!\n", wandev->name, irq);
466                         return -EINVAL;
467                 }
468
469         }else{
470                 printk(KERN_INFO "%s: Card Configured %lu or Piggybacking %i!\n",
471                         wandev->name,card->configured,card->wandev.piggyback);
472         } 
473
474
475         if (!card->configured){
476
477                 /* Initialize the Spin lock */
478                 printk(KERN_INFO "%s: Initializing for SMP\n",wandev->name);
479
480                 /* Piggyback spin lock has already been initialized,
481                  * in check_s514/s508_conflicts() */
482                 if (!card->wandev.piggyback){
483                         spin_lock_init(&card->wandev.lock);
484                 }
485                 
486                 /* Intialize WAN device data space */
487                 wandev->irq       = irq;
488                 wandev->dma       = 0;
489                 if(card->hw.type != SDLA_S514){ 
490                         wandev->ioport = card->hw.port;
491                 }else{
492                         wandev->S514_cpu_no[0] = card->hw.S514_cpu_no[0];
493                         wandev->S514_slot_no = card->hw.S514_slot_no;
494                 }
495                 wandev->maddr     = (unsigned long)card->hw.dpmbase;
496                 wandev->msize     = card->hw.dpmsize;
497                 wandev->hw_opt[0] = card->hw.type;
498                 wandev->hw_opt[1] = card->hw.pclk;
499                 wandev->hw_opt[2] = card->hw.memory;
500                 wandev->hw_opt[3] = card->hw.fwid;
501         }
502
503         /* Protocol-specific initialization */
504         switch (card->hw.fwid) {
505
506         case SFID_X25_502:
507         case SFID_X25_508:
508                 printk(KERN_INFO "%s: Starting X.25 Protocol Init.\n",
509                                 card->devname);
510                 err = wpx_init(card, conf);
511                 break;
512         case SFID_FR502:
513         case SFID_FR508:
514                 printk(KERN_INFO "%s: Starting Frame Relay Protocol Init.\n",
515                                 card->devname);
516                 err = wpf_init(card, conf);
517                 break;
518         case SFID_PPP502:
519         case SFID_PPP508:
520                 printk(KERN_INFO "%s: Starting PPP Protocol Init.\n",
521                                 card->devname);
522                 err = wpp_init(card, conf);
523                 break;
524                 
525         case SFID_CHDLC508:
526         case SFID_CHDLC514:
527                 if (conf->ft1){         
528                         printk(KERN_INFO "%s: Starting FT1 CSU/DSU Config Driver.\n",
529                                 card->devname);
530                         err = wpft1_init(card, conf);
531                         break;
532                         
533                 }else if (conf->config_id == WANCONFIG_MPPP){
534                         printk(KERN_INFO "%s: Starting Multi-Port PPP Protocol Init.\n",
535                                         card->devname);
536                         err = wsppp_init(card,conf);
537                         break;
538
539                 }else{
540                         printk(KERN_INFO "%s: Starting CHDLC Protocol Init.\n",
541                                         card->devname);
542                         err = wpc_init(card, conf);
543                         break;
544                 }
545         default:
546                 printk(KERN_INFO "%s: Error, Firmware is not supported %X %X!\n",
547                         wandev->name,card->hw.fwid,SFID_CHDLC508);
548                 err = -EPROTONOSUPPORT;
549         }
550
551         if (err != 0){
552                 if (err == -EPROTONOSUPPORT){
553                         printk(KERN_INFO 
554                                 "%s: Error, Protocol selected has not been compiled!\n",
555                                         card->devname);
556                         printk(KERN_INFO 
557                                 "%s:        Re-configure the kernel and re-build the modules!\n",
558                                         card->devname);
559                 }
560                 
561                 release_hw(card);
562                 wandev->state = WAN_UNCONFIGURED;
563                 return err;
564         }
565
566
567         /* Reserve I/O region and schedule background task */
568         if(card->hw.type != SDLA_S514 && !card->wandev.piggyback)
569                 if (!request_region(card->hw.port, card->hw.io_range, 
570                                 wandev->name)) {
571                         printk(KERN_WARNING "port 0x%04x busy\n", card->hw.port);
572                         release_hw(card);
573                         wandev->state = WAN_UNCONFIGURED;
574                         return -EBUSY;
575           }
576
577         /* Only use the polling routine for the X25 protocol */
578         
579         card->wandev.critical=0;
580         return 0;
581 }
582
583 /*================================================================== 
584  * configure_s508_card
585  * 
586  * For a S508 adapter, check for a possible configuration error in that
587  * we are loading an adapter in the same IO port as a previously loaded S508
588  * card.
589  */ 
590
591 static int check_s508_conflicts (sdla_t* card,wandev_conf_t* conf, int *irq)
592 {
593         unsigned long smp_flags;
594         int i;
595         
596         if (conf->ioport <= 0) {
597                 printk(KERN_INFO
598                 "%s: can't configure without I/O port address!\n",
599                 card->wandev.name);
600                 return -EINVAL;
601         }
602
603         if (conf->irq <= 0) {
604                 printk(KERN_INFO "%s: can't configure without IRQ!\n",
605                 card->wandev.name);
606                 return -EINVAL;
607         }
608
609         if (test_bit(0,&card->configured))
610                 return 0;
611
612
613         /* Check for already loaded card with the same IO port and IRQ 
614          * If found, copy its hardware configuration and use its
615          * resources (i.e. piggybacking)
616          */
617         
618         for (i = 0; i < ncards; i++) {
619                 sdla_t *nxt_card = &card_array[i];
620
621                 /* Skip the current card ptr */
622                 if (nxt_card == card)   
623                         continue;
624
625
626                 /* Find a card that is already configured with the
627                  * same IO Port */
628                 if ((nxt_card->hw.type == SDLA_S508) &&
629                     (nxt_card->hw.port == conf->ioport) && 
630                     (nxt_card->next == NULL)){
631                         
632                         /* We found a card the card that has same configuration
633                          * as us. This means, that we must setup this card in 
634                          * piggibacking mode. However, only CHDLC and MPPP protocol
635                          * support this setup */
636                 
637                         if ((conf->config_id == WANCONFIG_CHDLC || 
638                              conf->config_id == WANCONFIG_MPPP) &&
639                             (nxt_card->wandev.config_id == WANCONFIG_CHDLC || 
640                              nxt_card->wandev.config_id == WANCONFIG_MPPP)){ 
641                                 
642                                 *irq = nxt_card->hw.irq;
643                                 memcpy(&card->hw, &nxt_card->hw, sizeof(sdlahw_t));
644                         
645                                 /* The master could already be running, we must
646                                  * set this as a critical area */
647                                 lock_adapter_irq(&nxt_card->wandev.lock, &smp_flags);
648
649                                 nxt_card->next = card;
650                                 card->next = nxt_card;
651
652                                 card->wandev.piggyback = WANOPT_YES;
653
654                                 /* We must initialise the piggiback spin lock here
655                                  * since isr will try to lock card->next if it
656                                  * exists */
657                                 spin_lock_init(&card->wandev.lock);
658                                 
659                                 unlock_adapter_irq(&nxt_card->wandev.lock, &smp_flags);
660                                 break;
661                         }else{
662                                 /* Trying to run piggibacking with a wrong protocol */
663                                 printk(KERN_INFO "%s: ERROR: Resource busy, ioport: 0x%x\n"
664                                                  "%s:        This protocol doesn't support\n"
665                                                  "%s:        multi-port operation!\n",
666                                                  card->devname,nxt_card->hw.port,
667                                                  card->devname,card->devname);
668                                 return -EEXIST;
669                         }
670                 }
671         }
672         
673
674         /* Make sure I/O port region is available only if we are the
675          * master device.  If we are running in piggybacking mode, 
676          * we will use the resources of the master card. */
677         if (!card->wandev.piggyback) {
678                 struct resource *rr =
679                         request_region(conf->ioport, SDLA_MAXIORANGE, "sdlamain");
680                 release_region(conf->ioport, SDLA_MAXIORANGE);
681
682                 if (!rr) {
683                         printk(KERN_INFO
684                                 "%s: I/O region 0x%X - 0x%X is in use!\n",
685                                 card->wandev.name, conf->ioport,
686                                 conf->ioport + SDLA_MAXIORANGE - 1);
687                         return -EINVAL;
688                 }
689         }
690
691         return 0;
692 }
693
694 /*================================================================== 
695  * configure_s514_card
696  * 
697  * For a S514 adapter, check for a possible configuration error in that
698  * we are loading an adapter in the same slot as a previously loaded S514
699  * card.
700  */ 
701
702
703 static int check_s514_conflicts(sdla_t* card,wandev_conf_t* conf, int *irq)
704 {
705         unsigned long smp_flags;
706         int i;
707         
708         if (test_bit(0,&card->configured))
709                 return 0;
710
711         
712         /* Check for already loaded card with the same IO port and IRQ 
713          * If found, copy its hardware configuration and use its
714          * resources (i.e. piggybacking)
715          */
716
717         for (i = 0; i < ncards; i ++) {
718         
719                 sdla_t* nxt_card = &card_array[i];
720                 if(nxt_card == card)
721                         continue;
722                 
723                 if((nxt_card->hw.type == SDLA_S514) &&
724                    (nxt_card->hw.S514_slot_no == conf->PCI_slot_no) &&
725                    (nxt_card->hw.S514_cpu_no[0] == conf->S514_CPU_no[0])&&
726                    (nxt_card->next == NULL)){
727
728
729                         if ((conf->config_id == WANCONFIG_CHDLC || 
730                              conf->config_id == WANCONFIG_MPPP) &&
731                             (nxt_card->wandev.config_id == WANCONFIG_CHDLC || 
732                              nxt_card->wandev.config_id == WANCONFIG_MPPP)){ 
733                                 
734                                 *irq = nxt_card->hw.irq;
735                                 memcpy(&card->hw, &nxt_card->hw, sizeof(sdlahw_t));
736         
737                                 /* The master could already be running, we must
738                                  * set this as a critical area */
739                                 lock_adapter_irq(&nxt_card->wandev.lock,&smp_flags);
740                                 nxt_card->next = card;
741                                 card->next = nxt_card;
742
743                                 card->wandev.piggyback = WANOPT_YES;
744
745                                 /* We must initialise the piggiback spin lock here
746                                  * since isr will try to lock card->next if it
747                                  * exists */
748                                 spin_lock_init(&card->wandev.lock);
749
750                                 unlock_adapter_irq(&nxt_card->wandev.lock,&smp_flags);
751
752                         }else{
753                                 /* Trying to run piggibacking with a wrong protocol */
754                                 printk(KERN_INFO "%s: ERROR: Resource busy: CPU %c PCISLOT %i\n"
755                                                  "%s:        This protocol doesn't support\n"
756                                                  "%s:        multi-port operation!\n",
757                                                  card->devname,
758                                                  conf->S514_CPU_no[0],conf->PCI_slot_no,
759                                                  card->devname,card->devname);
760                                 return -EEXIST;
761                         }
762                 }
763         }
764
765         return 0;
766 }
767
768
769
770 /*============================================================================
771  * Shut down WAN link driver. 
772  * o shut down adapter hardware
773  * o release system resources.
774  *
775  * This function is called by the router when device is being unregistered or
776  * when it handles ROUTER_DOWN IOCTL.
777  */
778 static int shutdown(struct wan_device* wandev)
779 {
780         sdla_t *card;
781         int err=0;
782         
783         /* sanity checks */
784         if ((wandev == NULL) || (wandev->private == NULL)){
785                 return -EFAULT;
786         }
787                 
788         if (wandev->state == WAN_UNCONFIGURED){
789                 return 0;
790         }
791
792         card = wandev->private;
793
794         if (card->tty_opt){
795                 if (card->tty_open){
796                         printk(KERN_INFO 
797                                 "%s: Shutdown Failed: TTY is still open\n",
798                                   card->devname);
799                         return -EBUSY;
800                 }
801         }
802         
803         wandev->state = WAN_UNCONFIGURED;
804
805         set_bit(PERI_CRIT,(void*)&wandev->critical);
806         
807         /* In case of piggibacking, make sure that 
808          * we never try to shutdown both devices at the same
809          * time, because they depend on one another */
810         
811         if (card->disable_comm){
812                 card->disable_comm(card);
813         }
814
815         /* Release Resources */
816         release_hw(card);
817
818         /* only free the allocated I/O range if not an S514 adapter */
819         if (wandev->hw_opt[0] != SDLA_S514 && !card->configured){
820                 release_region(card->hw.port, card->hw.io_range);
821         }
822
823         if (!card->configured){
824                 memset(&card->hw, 0, sizeof(sdlahw_t));
825                 if (card->next){
826                         memset(&card->next->hw, 0, sizeof(sdlahw_t));
827                 }
828         }
829         
830
831         clear_bit(PERI_CRIT,(void*)&wandev->critical);
832         return err;
833 }
834
835 static void release_hw (sdla_t *card)
836 {
837         sdla_t *nxt_card;
838
839         
840         /* Check if next device exists */
841         if (card->next){
842                 nxt_card = card->next;
843                 /* If next device is down then release resources */
844                 if (nxt_card->wandev.state == WAN_UNCONFIGURED){
845                         if (card->wandev.piggyback){
846                                 /* If this device is piggyback then use
847                                  * information of the master device 
848                                  */
849                                 printk(KERN_INFO "%s: Piggyback shutting down\n",card->devname);
850                                 sdla_down(&card->next->hw);
851                                 free_irq(card->wandev.irq, card->next);
852                                 card->configured = 0;
853                                 card->next->configured = 0;
854                                 card->wandev.piggyback = 0;
855                         }else{
856                                 /* Master device shutting down */
857                                 printk(KERN_INFO "%s: Master shutting down\n",card->devname);
858                                 sdla_down(&card->hw);
859                                 free_irq(card->wandev.irq, card);
860                                 card->configured = 0;
861                                 card->next->configured = 0;
862                         }
863                 }else{
864                         printk(KERN_INFO "%s: Device still running %i\n",
865                                 nxt_card->devname,nxt_card->wandev.state);
866
867                         card->configured = 1;
868                 }
869         }else{
870                 printk(KERN_INFO "%s: Master shutting down\n",card->devname);
871                 sdla_down(&card->hw);
872                 free_irq(card->wandev.irq, card);
873                 card->configured = 0;
874         }
875         return;
876 }
877
878
879 /*============================================================================
880  * Driver I/O control. 
881  * o verify arguments
882  * o perform requested action
883  *
884  * This function is called when router handles one of the reserved user
885  * IOCTLs.  Note that 'arg' stil points to user address space.
886  */
887 static int ioctl(struct wan_device* wandev, unsigned cmd, unsigned long arg)
888 {
889         sdla_t* card;
890         int err;
891
892         /* sanity checks */
893         if ((wandev == NULL) || (wandev->private == NULL))
894                 return -EFAULT;
895         if (wandev->state == WAN_UNCONFIGURED)
896                 return -ENODEV;
897
898         card = wandev->private;
899
900         if(card->hw.type != SDLA_S514){
901                 disable_irq(card->hw.irq);
902         }
903
904         if (test_bit(SEND_CRIT, (void*)&wandev->critical)) {
905                 return -EAGAIN;
906         }
907         
908         switch (cmd) {
909         case WANPIPE_DUMP:
910                 err = ioctl_dump(wandev->private, (void*)arg);
911                 break;
912
913         case WANPIPE_EXEC:
914                 err = ioctl_exec(wandev->private, (void*)arg, cmd);
915                 break;
916         default:
917                 err = -EINVAL;
918         }
919  
920         return err;
921 }
922
923 /****** Driver IOCTL Handlers ***********************************************/
924
925 /*============================================================================
926  * Dump adapter memory to user buffer.
927  * o verify request structure
928  * o copy request structure to kernel data space
929  * o verify length/offset
930  * o verify user buffer
931  * o copy adapter memory image to user buffer
932  *
933  * Note: when dumping memory, this routine switches curent dual-port memory
934  *       vector, so care must be taken to avoid racing conditions.
935  */
936 static int ioctl_dump (sdla_t* card, sdla_dump_t* u_dump)
937 {
938         sdla_dump_t dump;
939         unsigned winsize;
940         unsigned long oldvec;   /* DPM window vector */
941         unsigned long smp_flags;
942         int err = 0;
943
944         if(copy_from_user((void*)&dump, (void*)u_dump, sizeof(sdla_dump_t)))
945                 return -EFAULT;
946                 
947         if ((dump.magic != WANPIPE_MAGIC) ||
948             (dump.offset + dump.length > card->hw.memory))
949                 return -EINVAL;
950         
951         winsize = card->hw.dpmsize;
952
953         if(card->hw.type != SDLA_S514) {
954
955                 lock_adapter_irq(&card->wandev.lock, &smp_flags);
956                 
957                 oldvec = card->hw.vector;
958                 while (dump.length) {
959                         /* current offset */                            
960                         unsigned pos = dump.offset % winsize;
961                         /* current vector */
962                         unsigned long vec = dump.offset - pos;
963                         unsigned len = (dump.length > (winsize - pos)) ?
964                                 (winsize - pos) : dump.length;
965                         /* relocate window */
966                         if (sdla_mapmem(&card->hw, vec) != 0) {
967                                 err = -EIO;
968                                 break;
969                         }
970                         
971                         if(copy_to_user((void *)dump.ptr,
972                                 (u8 *)card->hw.dpmbase + pos, len)){ 
973                                 
974                                 unlock_adapter_irq(&card->wandev.lock, &smp_flags);
975                                 return -EFAULT;
976                         }
977
978                         dump.length     -= len;
979                         dump.offset     += len;
980                         dump.ptr         = (char*)dump.ptr + len;
981                 }
982                 
983                 sdla_mapmem(&card->hw, oldvec);/* restore DPM window position */
984                 unlock_adapter_irq(&card->wandev.lock, &smp_flags);
985         
986         }else {
987
988                if(copy_to_user((void *)dump.ptr,
989                                (u8 *)card->hw.dpmbase + dump.offset, dump.length)){
990                         return -EFAULT;
991                 }
992         }
993
994         return err;
995 }
996
997 /*============================================================================
998  * Execute adapter firmware command.
999  * o verify request structure
1000  * o copy request structure to kernel data space
1001  * o call protocol-specific 'exec' function
1002  */
1003 static int ioctl_exec (sdla_t* card, sdla_exec_t* u_exec, int cmd)
1004 {
1005         sdla_exec_t exec;
1006         int err=0;
1007
1008         if (card->exec == NULL && cmd == WANPIPE_EXEC){
1009                 return -ENODEV;
1010         }
1011
1012         if(copy_from_user((void*)&exec, (void*)u_exec, sizeof(sdla_exec_t)))
1013                 return -EFAULT;
1014
1015         if ((exec.magic != WANPIPE_MAGIC) || (exec.cmd == NULL))
1016                 return -EINVAL;
1017
1018         switch (cmd) {
1019                 case WANPIPE_EXEC:      
1020                         err = card->exec(card, exec.cmd, exec.data);
1021                         break;
1022         }       
1023         return err;
1024 }
1025
1026 /******* Miscellaneous ******************************************************/
1027
1028 /*============================================================================
1029  * SDLA Interrupt Service Routine.
1030  * o acknowledge SDLA hardware interrupt.
1031  * o call protocol-specific interrupt service routine, if any.
1032  */
1033 STATIC irqreturn_t sdla_isr (int irq, void* dev_id, struct pt_regs *regs)
1034 {
1035 #define card    ((sdla_t*)dev_id)
1036
1037         if(card->hw.type == SDLA_S514) {        /* handle interrrupt on S514 */
1038                 u32 int_status;
1039                 unsigned char CPU_no = card->hw.S514_cpu_no[0];
1040                 unsigned char card_found_for_IRQ;
1041                 u8 IRQ_count = 0;
1042
1043                 for(;;) {
1044
1045                         read_S514_int_stat(&card->hw, &int_status);
1046
1047                         /* check if the interrupt is for this device */
1048                         if(!((unsigned char)int_status &
1049                                 (IRQ_CPU_A | IRQ_CPU_B)))
1050                                 return IRQ_HANDLED;
1051
1052                         /* if the IRQ is for both CPUs on the same adapter, */
1053                         /* then alter the interrupt status so as to handle */
1054                         /* one CPU at a time */
1055                         if(((unsigned char)int_status & (IRQ_CPU_A | IRQ_CPU_B))
1056                                 == (IRQ_CPU_A | IRQ_CPU_B)) {
1057                                 int_status &= (CPU_no == S514_CPU_A) ?
1058                                         ~IRQ_CPU_B : ~IRQ_CPU_A;
1059                         }
1060  
1061                         card_found_for_IRQ = 0;
1062
1063                         /* check to see that the CPU number for this device */
1064                         /* corresponds to the interrupt status read */
1065                         switch (CPU_no) {
1066                                 case S514_CPU_A:
1067                                         if((unsigned char)int_status &
1068                                                 IRQ_CPU_A)
1069                                         card_found_for_IRQ = 1;
1070                                 break;
1071
1072                                 case S514_CPU_B:
1073                                         if((unsigned char)int_status &
1074                                                 IRQ_CPU_B)
1075                                         card_found_for_IRQ = 1;
1076                                 break;
1077                         }
1078
1079                         /* exit if the interrupt is for another CPU on the */
1080                         /* same IRQ */
1081                         if(!card_found_for_IRQ)
1082                                 return IRQ_HANDLED;
1083
1084                         if (!card || 
1085                            (card->wandev.state == WAN_UNCONFIGURED && !card->configured)){
1086                                         printk(KERN_INFO
1087                                                 "Received IRQ %d for CPU #%c\n",
1088                                                 irq, CPU_no);
1089                                         printk(KERN_INFO
1090                                                 "IRQ for unconfigured adapter\n");
1091                                         S514_intack(&card->hw, int_status);
1092                                         return IRQ_HANDLED;
1093                         }
1094
1095                         if (card->in_isr) {
1096                                 printk(KERN_INFO
1097                                         "%s: interrupt re-entrancy on IRQ %d\n",
1098                                         card->devname, card->wandev.irq);
1099                                 S514_intack(&card->hw, int_status);
1100                                 return IRQ_HANDLED;
1101                         }
1102
1103                         spin_lock(&card->wandev.lock);
1104                         if (card->next){
1105                                 spin_lock(&card->next->wandev.lock);
1106                         }
1107                                 
1108                         S514_intack(&card->hw, int_status);
1109                         if (card->isr)
1110                                 card->isr(card);
1111
1112                         if (card->next){
1113                                 spin_unlock(&card->next->wandev.lock);
1114                         }
1115                         spin_unlock(&card->wandev.lock);
1116
1117                         /* handle a maximum of two interrupts (one for each */
1118                         /* CPU on the adapter) before returning */  
1119                         if((++ IRQ_count) == 2)
1120                                 return IRQ_HANDLED;
1121                 }
1122         }
1123
1124         else {                  /* handle interrupt on S508 adapter */
1125
1126                 if (!card || ((card->wandev.state == WAN_UNCONFIGURED) && !card->configured))
1127                         return IRQ_HANDLED;
1128
1129                 if (card->in_isr) {
1130                         printk(KERN_INFO
1131                                 "%s: interrupt re-entrancy on IRQ %d!\n",
1132                                 card->devname, card->wandev.irq);
1133                         return IRQ_HANDLED;
1134                 }
1135
1136                 spin_lock(&card->wandev.lock);
1137                 if (card->next){
1138                         spin_lock(&card->next->wandev.lock);
1139                 }
1140         
1141                 sdla_intack(&card->hw);
1142                 if (card->isr)
1143                         card->isr(card);
1144                 
1145                 if (card->next){
1146                         spin_unlock(&card->next->wandev.lock);
1147                 }
1148                 spin_unlock(&card->wandev.lock);
1149
1150         }
1151         return IRQ_HANDLED;
1152 #undef  card
1153 }
1154
1155 /*============================================================================
1156  * This routine is called by the protocol-specific modules when network
1157  * interface is being open.  The only reason we need this, is because we
1158  * have to call MOD_INC_USE_COUNT, but cannot include 'module.h' where it's
1159  * defined more than once into the same kernel module.
1160  */
1161 void wanpipe_open (sdla_t* card)
1162 {
1163         ++card->open_cnt;
1164 }
1165
1166 /*============================================================================
1167  * This routine is called by the protocol-specific modules when network
1168  * interface is being closed.  The only reason we need this, is because we
1169  * have to call MOD_DEC_USE_COUNT, but cannot include 'module.h' where it's
1170  * defined more than once into the same kernel module.
1171  */
1172 void wanpipe_close (sdla_t* card)
1173 {
1174         --card->open_cnt;
1175 }
1176
1177 /*============================================================================
1178  * Set WAN device state.
1179  */
1180 void wanpipe_set_state (sdla_t* card, int state)
1181 {
1182         if (card->wandev.state != state) {
1183                 switch (state) {
1184                 case WAN_CONNECTED:
1185                         printk (KERN_INFO "%s: link connected!\n",
1186                                 card->devname);
1187                         break;
1188
1189                 case WAN_CONNECTING:
1190                         printk (KERN_INFO "%s: link connecting...\n",
1191                                 card->devname);
1192                         break;
1193
1194                 case WAN_DISCONNECTED:
1195                         printk (KERN_INFO "%s: link disconnected!\n",
1196                                 card->devname);
1197                         break;
1198                 }
1199                 card->wandev.state = state;
1200         }
1201         card->state_tick = jiffies;
1202 }
1203
1204 sdla_t * wanpipe_find_card (char *name)
1205 {
1206         int cnt;
1207         for (cnt = 0; cnt < ncards; ++ cnt) {
1208                 sdla_t* card = &card_array[cnt];
1209                 if (!strcmp(card->devname,name))
1210                         return card;
1211         }
1212         return NULL;
1213 }
1214
1215 sdla_t * wanpipe_find_card_num (int num)
1216 {
1217         if (num < 1 || num > ncards)
1218                 return NULL;    
1219         num--;
1220         return &card_array[num];
1221 }
1222
1223 /*
1224  * @work_pointer:       work_struct to be done;
1225  *                      should already have PREPARE_WORK() or
1226  *                        INIT_WORK() done on it by caller;
1227  */
1228 void wanpipe_queue_work (struct work_struct *work_pointer)
1229 {
1230         if (test_and_set_bit(1, (void*)&wanpipe_bh_critical))
1231                 printk(KERN_INFO "CRITICAL IN QUEUING WORK\n");
1232
1233         queue_work(wanpipe_wq, work_pointer);
1234         clear_bit(1,(void*)&wanpipe_bh_critical);
1235 }
1236
1237 void wakeup_sk_bh(struct net_device *dev)
1238 {
1239         wanpipe_common_t *chan = dev->priv;
1240
1241         if (test_bit(0,&chan->common_critical))
1242                 return;
1243         
1244         if (chan->sk && chan->tx_timer){
1245                 chan->tx_timer->expires=jiffies+1;
1246                 add_timer(chan->tx_timer);
1247         }
1248 }
1249
1250 int change_dev_flags(struct net_device *dev, unsigned flags)
1251 {
1252         struct ifreq if_info;
1253         mm_segment_t fs = get_fs();
1254         int err;
1255
1256         memset(&if_info, 0, sizeof(if_info));
1257         strcpy(if_info.ifr_name, dev->name);
1258         if_info.ifr_flags = flags;      
1259
1260         set_fs(get_ds());     /* get user space block */ 
1261         err = devinet_ioctl(SIOCSIFFLAGS, &if_info);
1262         set_fs(fs);
1263
1264         return err;
1265 }
1266
1267 unsigned long get_ip_address(struct net_device *dev, int option)
1268 {
1269         
1270         struct in_ifaddr *ifaddr;
1271         struct in_device *in_dev;
1272         unsigned long addr = 0;
1273
1274         rcu_read_lock();
1275         if ((in_dev = __in_dev_get_rcu(dev)) == NULL){
1276                 goto out;
1277         }
1278
1279         if ((ifaddr = in_dev->ifa_list)== NULL ){
1280                 goto out;
1281         }
1282         
1283         switch (option){
1284
1285         case WAN_LOCAL_IP:
1286                 addr = ifaddr->ifa_local;
1287                 break;
1288         
1289         case WAN_POINTOPOINT_IP:
1290                 addr = ifaddr->ifa_address;
1291                 break;  
1292
1293         case WAN_NETMASK_IP:
1294                 addr = ifaddr->ifa_mask;
1295                 break;
1296
1297         case WAN_BROADCAST_IP:
1298                 addr = ifaddr->ifa_broadcast;
1299                 break;
1300         default:
1301                 break;
1302         }
1303
1304 out:
1305         rcu_read_unlock();
1306         return addr;
1307 }       
1308
1309 void add_gateway(sdla_t *card, struct net_device *dev)
1310 {
1311         mm_segment_t oldfs;
1312         struct rtentry route;
1313         int res;
1314
1315         memset((char*)&route,0,sizeof(struct rtentry));
1316
1317         ((struct sockaddr_in *)
1318                 &(route.rt_dst))->sin_addr.s_addr = 0;
1319         ((struct sockaddr_in *)
1320                 &(route.rt_dst))->sin_family = AF_INET;
1321
1322         ((struct sockaddr_in *)
1323                 &(route.rt_genmask))->sin_addr.s_addr = 0;
1324         ((struct sockaddr_in *) 
1325                 &(route.rt_genmask)) ->sin_family = AF_INET;
1326
1327
1328         route.rt_flags = 0;  
1329         route.rt_dev = dev->name;
1330
1331         oldfs = get_fs();
1332         set_fs(get_ds());
1333         res = ip_rt_ioctl(SIOCADDRT,&route);
1334         set_fs(oldfs);
1335
1336         if (res == 0){
1337                 printk(KERN_INFO "%s: Gateway added for %s\n",
1338                         card->devname,dev->name);
1339         }
1340
1341         return;
1342 }
1343
1344 MODULE_LICENSE("GPL");
1345
1346 /****** End *********************************************************/