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