aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wan/sdladrv.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/wan/sdladrv.c')
-rw-r--r--drivers/net/wan/sdladrv.c2314
1 files changed, 0 insertions, 2314 deletions
diff --git a/drivers/net/wan/sdladrv.c b/drivers/net/wan/sdladrv.c
deleted file mode 100644
index 032c0f81928e..000000000000
--- a/drivers/net/wan/sdladrv.c
+++ /dev/null
@@ -1,2314 +0,0 @@
1/*****************************************************************************
2* sdladrv.c SDLA Support Module. Main module.
3*
4* This module is a library of common hardware-specific functions
5* used by all Sangoma drivers.
6*
7* Author: Gideon Hack
8*
9* Copyright: (c) 1995-2000 Sangoma Technologies Inc.
10*
11* This program is free software; you can redistribute it and/or
12* modify it under the terms of the GNU General Public License
13* as published by the Free Software Foundation; either version
14* 2 of the License, or (at your option) any later version.
15* ============================================================================
16* Mar 20, 2001 Nenad Corbic Added the auto_pci_cfg filed, to support
17* the PCISLOT #0.
18* Apr 04, 2000 Nenad Corbic Fixed the auto memory detection code.
19* The memory test at address 0xC8000.
20* Mar 09, 2000 Nenad Corbic Added Gideon's Bug Fix: clear pci
21* interrupt flags on initial load.
22* Jun 02, 1999 Gideon Hack Added support for the S514 adapter.
23* Updates for Linux 2.2.X kernels.
24* Sep 17, 1998 Jaspreet Singh Updates for linux 2.2.X kernels
25* Dec 20, 1996 Gene Kozin Version 3.0.0. Complete overhaul.
26* Jul 12, 1996 Gene Kozin Changes for Linux 2.0 compatibility.
27* Jun 12, 1996 Gene Kozin Added support for S503 card.
28* Apr 30, 1996 Gene Kozin SDLA hardware interrupt is acknowledged before
29* calling protocolspecific ISR.
30* Register I/O ports with Linux kernel.
31* Miscellaneous bug fixes.
32* Dec 20, 1995 Gene Kozin Fixed a bug in interrupt routine.
33* Oct 14, 1995 Gene Kozin Initial version.
34*****************************************************************************/
35
36/*****************************************************************************
37 * Notes:
38 * ------
39 * 1. This code is ment to be system-independent (as much as possible). To
40 * achive this, various macros are used to hide system-specific interfaces.
41 * To compile this code, one of the following constants must be defined:
42 *
43 * Platform Define
44 * -------- ------
45 * Linux _LINUX_
46 * SCO Unix _SCO_UNIX_
47 *
48 * 2. Supported adapter types:
49 *
50 * S502A
51 * ES502A (S502E)
52 * S503
53 * S507
54 * S508 (S509)
55 *
56 * 3. S502A Notes:
57 *
58 * There is no separate DPM window enable/disable control in S502A. It
59 * opens immediately after a window number it written to the HMCR
60 * register. To close the window, HMCR has to be written a value
61 * ????1111b (e.g. 0x0F or 0xFF).
62 *
63 * S502A DPM window cannot be located at offset E000 (e.g. 0xAE000).
64 *
65 * There should be a delay of ??? before reading back S502A status
66 * register.
67 *
68 * 4. S502E Notes:
69 *
70 * S502E has a h/w bug: although default IRQ line state is HIGH, enabling
71 * interrupts by setting bit 1 of the control register (BASE) to '1'
72 * causes it to go LOW! Therefore, disabling interrupts by setting that
73 * bit to '0' causes low-to-high transition on IRQ line (ghosty
74 * interrupt). The same occurs when disabling CPU by resetting bit 0 of
75 * CPU control register (BASE+3) - see the next note.
76 *
77 * S502E CPU and DPM control is limited:
78 *
79 * o CPU cannot be stopped independently. Resetting bit 0 of the CPUi
80 * control register (BASE+3) shuts the board down entirely, including
81 * DPM;
82 *
83 * o DPM access cannot be controlled dynamically. Ones CPU is started,
84 * bit 1 of the control register (BASE) is used to enable/disable IRQ,
85 * so that access to shared memory cannot be disabled while CPU is
86 * running.
87 ****************************************************************************/
88
89#define _LINUX_
90
91#if defined(_LINUX_) /****** Linux *******************************/
92
93#include <linux/config.h>
94#include <linux/kernel.h> /* printk(), and other useful stuff */
95#include <linux/stddef.h> /* offsetof(), etc. */
96#include <linux/errno.h> /* return codes */
97#include <linux/string.h> /* inline memset(), etc. */
98#include <linux/module.h> /* support for loadable modules */
99#include <linux/jiffies.h> /* for jiffies, HZ, etc. */
100#include <linux/sdladrv.h> /* API definitions */
101#include <linux/sdlasfm.h> /* SDLA firmware module definitions */
102#include <linux/sdlapci.h> /* SDLA PCI hardware definitions */
103#include <linux/pci.h> /* PCI defines and function prototypes */
104#include <asm/io.h> /* for inb(), outb(), etc. */
105
106#define _INB(port) (inb(port))
107#define _OUTB(port, byte) (outb((byte),(port)))
108#define SYSTEM_TICK jiffies
109
110#include <linux/init.h>
111
112
113#elif defined(_SCO_UNIX_) /****** SCO Unix ****************************/
114
115#if !defined(INKERNEL)
116#error This code MUST be compiled in kernel mode!
117#endif
118#include <sys/sdladrv.h> /* API definitions */
119#include <sys/sdlasfm.h> /* SDLA firmware module definitions */
120#include <sys/inline.h> /* for inb(), outb(), etc. */
121#define _INB(port) (inb(port))
122#define _OUTB(port, byte) (outb((port),(byte)))
123#define SYSTEM_TICK lbolt
124
125#else
126#error Unknown system type!
127#endif
128
129#define MOD_VERSION 3
130#define MOD_RELEASE 0
131
132#define SDLA_IODELAY 100 /* I/O Rd/Wr delay, 10 works for 486DX2-66 */
133#define EXEC_DELAY 20 /* shared memory access delay, mks */
134#define EXEC_TIMEOUT (HZ*2) /* command timeout, in ticks */
135
136/* I/O port address range */
137#define S502A_IORANGE 3
138#define S502E_IORANGE 4
139#define S503_IORANGE 3
140#define S507_IORANGE 4
141#define S508_IORANGE 4
142
143/* Maximum amount of memory */
144#define S502_MAXMEM 0x10000L
145#define S503_MAXMEM 0x10000L
146#define S507_MAXMEM 0x40000L
147#define S508_MAXMEM 0x40000L
148
149/* Minimum amount of memory */
150#define S502_MINMEM 0x8000L
151#define S503_MINMEM 0x8000L
152#define S507_MINMEM 0x20000L
153#define S508_MINMEM 0x20000L
154#define NO_PORT -1
155
156
157
158
159
160/****** Function Prototypes *************************************************/
161
162/* Hardware-specific functions */
163static int sdla_detect (sdlahw_t* hw);
164static int sdla_autodpm (sdlahw_t* hw);
165static int sdla_setdpm (sdlahw_t* hw);
166static int sdla_load (sdlahw_t* hw, sfm_t* sfm, unsigned len);
167static int sdla_init (sdlahw_t* hw);
168static unsigned long sdla_memtest (sdlahw_t* hw);
169static int sdla_bootcfg (sdlahw_t* hw, sfm_info_t* sfminfo);
170static unsigned char make_config_byte (sdlahw_t* hw);
171static int sdla_start (sdlahw_t* hw, unsigned addr);
172
173static int init_s502a (sdlahw_t* hw);
174static int init_s502e (sdlahw_t* hw);
175static int init_s503 (sdlahw_t* hw);
176static int init_s507 (sdlahw_t* hw);
177static int init_s508 (sdlahw_t* hw);
178
179static int detect_s502a (int port);
180static int detect_s502e (int port);
181static int detect_s503 (int port);
182static int detect_s507 (int port);
183static int detect_s508 (int port);
184static int detect_s514 (sdlahw_t* hw);
185static int find_s514_adapter(sdlahw_t* hw, char find_first_S514_card);
186
187/* Miscellaneous functions */
188static void peek_by_4 (unsigned long src, void* buf, unsigned len);
189static void poke_by_4 (unsigned long dest, void* buf, unsigned len);
190static int calibrate_delay (int mks);
191static int get_option_index (unsigned* optlist, unsigned optval);
192static unsigned check_memregion (void* ptr, unsigned len);
193static unsigned test_memregion (void* ptr, unsigned len);
194static unsigned short checksum (unsigned char* buf, unsigned len);
195static int init_pci_slot(sdlahw_t *);
196
197static int pci_probe(sdlahw_t *hw);
198
199/****** Global Data **********************************************************
200 * Note: All data must be explicitly initialized!!!
201 */
202
203static struct pci_device_id sdladrv_pci_tbl[] = {
204 { V3_VENDOR_ID, V3_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, },
205 { } /* Terminating entry */
206};
207MODULE_DEVICE_TABLE(pci, sdladrv_pci_tbl);
208
209MODULE_LICENSE("GPL");
210
211/* private data */
212static char modname[] = "sdladrv";
213static char fullname[] = "SDLA Support Module";
214static char copyright[] = "(c) 1995-1999 Sangoma Technologies Inc.";
215static unsigned exec_idle;
216
217/* Hardware configuration options.
218 * These are arrays of configuration options used by verification routines.
219 * The first element of each array is its size (i.e. number of options).
220 */
221static unsigned s502_port_options[] =
222 { 4, 0x250, 0x300, 0x350, 0x360 }
223;
224static unsigned s503_port_options[] =
225 { 8, 0x250, 0x254, 0x300, 0x304, 0x350, 0x354, 0x360, 0x364 }
226;
227static unsigned s508_port_options[] =
228 { 8, 0x250, 0x270, 0x280, 0x300, 0x350, 0x360, 0x380, 0x390 }
229;
230
231static unsigned s502a_irq_options[] = { 0 };
232static unsigned s502e_irq_options[] = { 4, 2, 3, 5, 7 };
233static unsigned s503_irq_options[] = { 5, 2, 3, 4, 5, 7 };
234static unsigned s508_irq_options[] = { 8, 3, 4, 5, 7, 10, 11, 12, 15 };
235
236static unsigned s502a_dpmbase_options[] =
237{
238 28,
239 0xA0000, 0xA2000, 0xA4000, 0xA6000, 0xA8000, 0xAA000, 0xAC000,
240 0xC0000, 0xC2000, 0xC4000, 0xC6000, 0xC8000, 0xCA000, 0xCC000,
241 0xD0000, 0xD2000, 0xD4000, 0xD6000, 0xD8000, 0xDA000, 0xDC000,
242 0xE0000, 0xE2000, 0xE4000, 0xE6000, 0xE8000, 0xEA000, 0xEC000,
243};
244static unsigned s507_dpmbase_options[] =
245{
246 32,
247 0xA0000, 0xA2000, 0xA4000, 0xA6000, 0xA8000, 0xAA000, 0xAC000, 0xAE000,
248 0xB0000, 0xB2000, 0xB4000, 0xB6000, 0xB8000, 0xBA000, 0xBC000, 0xBE000,
249 0xC0000, 0xC2000, 0xC4000, 0xC6000, 0xC8000, 0xCA000, 0xCC000, 0xCE000,
250 0xE0000, 0xE2000, 0xE4000, 0xE6000, 0xE8000, 0xEA000, 0xEC000, 0xEE000,
251};
252static unsigned s508_dpmbase_options[] = /* incl. S502E and S503 */
253{
254 32,
255 0xA0000, 0xA2000, 0xA4000, 0xA6000, 0xA8000, 0xAA000, 0xAC000, 0xAE000,
256 0xC0000, 0xC2000, 0xC4000, 0xC6000, 0xC8000, 0xCA000, 0xCC000, 0xCE000,
257 0xD0000, 0xD2000, 0xD4000, 0xD6000, 0xD8000, 0xDA000, 0xDC000, 0xDE000,
258 0xE0000, 0xE2000, 0xE4000, 0xE6000, 0xE8000, 0xEA000, 0xEC000, 0xEE000,
259};
260
261/*
262static unsigned s502_dpmsize_options[] = { 2, 0x2000, 0x10000 };
263static unsigned s507_dpmsize_options[] = { 2, 0x2000, 0x4000 };
264static unsigned s508_dpmsize_options[] = { 1, 0x2000 };
265*/
266
267static unsigned s502a_pclk_options[] = { 2, 3600, 7200 };
268static unsigned s502e_pclk_options[] = { 5, 3600, 5000, 7200, 8000, 10000 };
269static unsigned s503_pclk_options[] = { 3, 7200, 8000, 10000 };
270static unsigned s507_pclk_options[] = { 1, 12288 };
271static unsigned s508_pclk_options[] = { 1, 16000 };
272
273/* Host memory control register masks */
274static unsigned char s502a_hmcr[] =
275{
276 0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, /* A0000 - AC000 */
277 0x20, 0x22, 0x24, 0x26, 0x28, 0x2A, 0x2C, /* C0000 - CC000 */
278 0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, /* D0000 - DC000 */
279 0x30, 0x32, 0x34, 0x36, 0x38, 0x3A, 0x3C, /* E0000 - EC000 */
280};
281static unsigned char s502e_hmcr[] =
282{
283 0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E, /* A0000 - AE000 */
284 0x20, 0x22, 0x24, 0x26, 0x28, 0x2A, 0x2C, 0x2E, /* C0000 - CE000 */
285 0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E, /* D0000 - DE000 */
286 0x30, 0x32, 0x34, 0x36, 0x38, 0x3A, 0x3C, 0x3E, /* E0000 - EE000 */
287};
288static unsigned char s507_hmcr[] =
289{
290 0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E, /* A0000 - AE000 */
291 0x40, 0x42, 0x44, 0x46, 0x48, 0x4A, 0x4C, 0x4E, /* B0000 - BE000 */
292 0x80, 0x82, 0x84, 0x86, 0x88, 0x8A, 0x8C, 0x8E, /* C0000 - CE000 */
293 0xC0, 0xC2, 0xC4, 0xC6, 0xC8, 0xCA, 0xCC, 0xCE, /* E0000 - EE000 */
294};
295static unsigned char s508_hmcr[] =
296{
297 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, /* A0000 - AE000 */
298 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, /* C0000 - CE000 */
299 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, /* D0000 - DE000 */
300 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, /* E0000 - EE000 */
301};
302
303static unsigned char s507_irqmask[] =
304{
305 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xE0
306};
307
308static int pci_slot_ar[MAX_S514_CARDS];
309
310/******* Kernel Loadable Module Entry Points ********************************/
311
312/*============================================================================
313 * Module 'insert' entry point.
314 * o print announcement
315 * o initialize static data
316 * o calibrate SDLA shared memory access delay.
317 *
318 * Return: 0 Ok
319 * < 0 error.
320 * Context: process
321 */
322
323static int __init sdladrv_init(void)
324{
325 int i=0;
326
327 printk(KERN_INFO "%s v%u.%u %s\n",
328 fullname, MOD_VERSION, MOD_RELEASE, copyright);
329 exec_idle = calibrate_delay(EXEC_DELAY);
330#ifdef WANDEBUG
331 printk(KERN_DEBUG "%s: exec_idle = %d\n", modname, exec_idle);
332#endif
333
334 /* Initialize the PCI Card array, which
335 * will store flags, used to mark
336 * card initialization state */
337 for (i=0; i<MAX_S514_CARDS; i++)
338 pci_slot_ar[i] = 0xFF;
339
340 return 0;
341}
342
343/*============================================================================
344 * Module 'remove' entry point.
345 * o release all remaining system resources
346 */
347static void __exit sdladrv_cleanup(void)
348{
349}
350
351module_init(sdladrv_init);
352module_exit(sdladrv_cleanup);
353
354/******* Kernel APIs ********************************************************/
355
356/*============================================================================
357 * Set up adapter.
358 * o detect adapter type
359 * o verify hardware configuration options
360 * o check for hardware conflicts
361 * o set up adapter shared memory
362 * o test adapter memory
363 * o load firmware
364 * Return: 0 ok.
365 * < 0 error
366 */
367
368EXPORT_SYMBOL(sdla_setup);
369
370int sdla_setup (sdlahw_t* hw, void* sfm, unsigned len)
371{
372 unsigned* irq_opt = NULL; /* IRQ options */
373 unsigned* dpmbase_opt = NULL; /* DPM window base options */
374 unsigned* pclk_opt = NULL; /* CPU clock rate options */
375 int err=0;
376
377 if (sdla_detect(hw)) {
378 if(hw->type != SDLA_S514)
379 printk(KERN_INFO "%s: no SDLA card found at port 0x%X\n",
380 modname, hw->port);
381 return -EINVAL;
382 }
383
384 if(hw->type != SDLA_S514) {
385 printk(KERN_INFO "%s: found S%04u card at port 0x%X.\n",
386 modname, hw->type, hw->port);
387
388 hw->dpmsize = SDLA_WINDOWSIZE;
389 switch (hw->type) {
390 case SDLA_S502A:
391 hw->io_range = S502A_IORANGE;
392 irq_opt = s502a_irq_options;
393 dpmbase_opt = s502a_dpmbase_options;
394 pclk_opt = s502a_pclk_options;
395 break;
396
397 case SDLA_S502E:
398 hw->io_range = S502E_IORANGE;
399 irq_opt = s502e_irq_options;
400 dpmbase_opt = s508_dpmbase_options;
401 pclk_opt = s502e_pclk_options;
402 break;
403
404 case SDLA_S503:
405 hw->io_range = S503_IORANGE;
406 irq_opt = s503_irq_options;
407 dpmbase_opt = s508_dpmbase_options;
408 pclk_opt = s503_pclk_options;
409 break;
410
411 case SDLA_S507:
412 hw->io_range = S507_IORANGE;
413 irq_opt = s508_irq_options;
414 dpmbase_opt = s507_dpmbase_options;
415 pclk_opt = s507_pclk_options;
416 break;
417
418 case SDLA_S508:
419 hw->io_range = S508_IORANGE;
420 irq_opt = s508_irq_options;
421 dpmbase_opt = s508_dpmbase_options;
422 pclk_opt = s508_pclk_options;
423 break;
424 }
425
426 /* Verify IRQ configuration options */
427 if (!get_option_index(irq_opt, hw->irq)) {
428 printk(KERN_INFO "%s: IRQ %d is invalid!\n",
429 modname, hw->irq);
430 return -EINVAL;
431 }
432
433 /* Verify CPU clock rate configuration options */
434 if (hw->pclk == 0)
435 hw->pclk = pclk_opt[1]; /* use default */
436
437 else if (!get_option_index(pclk_opt, hw->pclk)) {
438 printk(KERN_INFO "%s: CPU clock %u is invalid!\n",
439 modname, hw->pclk);
440 return -EINVAL;
441 }
442 printk(KERN_INFO "%s: assuming CPU clock rate of %u kHz.\n",
443 modname, hw->pclk);
444
445 /* Setup adapter dual-port memory window and test memory */
446 if (hw->dpmbase == 0) {
447 err = sdla_autodpm(hw);
448 if (err) {
449 printk(KERN_INFO
450 "%s: can't find available memory region!\n",
451 modname);
452 return err;
453 }
454 }
455 else if (!get_option_index(dpmbase_opt,
456 virt_to_phys(hw->dpmbase))) {
457 printk(KERN_INFO
458 "%s: memory address 0x%lX is invalid!\n",
459 modname, virt_to_phys(hw->dpmbase));
460 return -EINVAL;
461 }
462 else if (sdla_setdpm(hw)) {
463 printk(KERN_INFO
464 "%s: 8K memory region at 0x%lX is not available!\n",
465 modname, virt_to_phys(hw->dpmbase));
466 return -EINVAL;
467 }
468 printk(KERN_INFO
469 "%s: dual-port memory window is set at 0x%lX.\n",
470 modname, virt_to_phys(hw->dpmbase));
471
472
473 /* If we find memory in 0xE**** Memory region,
474 * warn the user to disable the SHADOW RAM.
475 * Since memory corruption can occur if SHADOW is
476 * enabled. This can causes random crashes ! */
477 if (virt_to_phys(hw->dpmbase) >= 0xE0000){
478 printk(KERN_WARNING "\n%s: !!!!!!!! WARNING !!!!!!!!\n",modname);
479 printk(KERN_WARNING "%s: WANPIPE is using 0x%lX memory region !!!\n",
480 modname, virt_to_phys(hw->dpmbase));
481 printk(KERN_WARNING " Please disable the SHADOW RAM, otherwise\n");
482 printk(KERN_WARNING " your system might crash randomly from time to time !\n");
483 printk(KERN_WARNING "%s: !!!!!!!! WARNING !!!!!!!!\n\n",modname);
484 }
485 }
486
487 else {
488 hw->memory = test_memregion((void*)hw->dpmbase,
489 MAX_SIZEOF_S514_MEMORY);
490 if(hw->memory < (256 * 1024)) {
491 printk(KERN_INFO
492 "%s: error in testing S514 memory (0x%lX)\n",
493 modname, hw->memory);
494 sdla_down(hw);
495 return -EINVAL;
496 }
497 }
498
499 printk(KERN_INFO "%s: found %luK bytes of on-board memory\n",
500 modname, hw->memory / 1024);
501
502 /* Load firmware. If loader fails then shut down adapter */
503 err = sdla_load(hw, sfm, len);
504 if (err) sdla_down(hw); /* shutdown adapter */
505
506 return err;
507}
508
509/*============================================================================
510 * Shut down SDLA: disable shared memory access and interrupts, stop CPU, etc.
511 */
512
513EXPORT_SYMBOL(sdla_down);
514
515int sdla_down (sdlahw_t* hw)
516{
517 unsigned port = hw->port;
518 int i;
519 unsigned char CPU_no;
520 u32 int_config, int_status;
521
522 if(!port && (hw->type != SDLA_S514))
523 return -EFAULT;
524
525 switch (hw->type) {
526 case SDLA_S502A:
527 _OUTB(port, 0x08); /* halt CPU */
528 _OUTB(port, 0x08);
529 _OUTB(port, 0x08);
530 hw->regs[0] = 0x08;
531 _OUTB(port + 1, 0xFF); /* close memory window */
532 hw->regs[1] = 0xFF;
533 break;
534
535 case SDLA_S502E:
536 _OUTB(port + 3, 0); /* stop CPU */
537 _OUTB(port, 0); /* reset board */
538 for (i = 0; i < S502E_IORANGE; ++i)
539 hw->regs[i] = 0
540 ;
541 break;
542
543 case SDLA_S503:
544 case SDLA_S507:
545 case SDLA_S508:
546 _OUTB(port, 0); /* reset board logic */
547 hw->regs[0] = 0;
548 break;
549
550 case SDLA_S514:
551 /* halt the adapter */
552 *(char *)hw->vector = S514_CPU_HALT;
553 CPU_no = hw->S514_cpu_no[0];
554
555 /* disable the PCI IRQ and disable memory access */
556 pci_read_config_dword(hw->pci_dev, PCI_INT_CONFIG, &int_config);
557 int_config &= (CPU_no == S514_CPU_A) ? ~PCI_DISABLE_IRQ_CPU_A : ~PCI_DISABLE_IRQ_CPU_B;
558 pci_write_config_dword(hw->pci_dev, PCI_INT_CONFIG, int_config);
559 read_S514_int_stat(hw, &int_status);
560 S514_intack(hw, int_status);
561 if(CPU_no == S514_CPU_A)
562 pci_write_config_dword(hw->pci_dev, PCI_MAP0_DWORD,
563 PCI_CPU_A_MEM_DISABLE);
564 else
565 pci_write_config_dword(hw->pci_dev, PCI_MAP1_DWORD,
566 PCI_CPU_B_MEM_DISABLE);
567
568 /* free up the allocated virtual memory */
569 iounmap((void *)hw->dpmbase);
570 iounmap((void *)hw->vector);
571 break;
572
573
574 default:
575 return -EINVAL;
576 }
577 return 0;
578}
579
580/*============================================================================
581 * Map shared memory window into SDLA address space.
582 */
583
584EXPORT_SYMBOL(sdla_mapmem);
585
586int sdla_mapmem (sdlahw_t* hw, unsigned long addr)
587{
588 unsigned port = hw->port;
589 register int tmp;
590
591 switch (hw->type) {
592 case SDLA_S502A:
593 case SDLA_S502E:
594 if (addr < S502_MAXMEM) { /* verify parameter */
595 tmp = addr >> 13; /* convert to register mask */
596 _OUTB(port + 2, tmp);
597 hw->regs[2] = tmp;
598 }
599 else return -EINVAL;
600 break;
601
602 case SDLA_S503:
603 if (addr < S503_MAXMEM) { /* verify parameter */
604 tmp = (hw->regs[0] & 0x8F) | ((addr >> 9) & 0x70);
605 _OUTB(port, tmp);
606 hw->regs[0] = tmp;
607 }
608 else return -EINVAL;
609 break;
610
611 case SDLA_S507:
612 if (addr < S507_MAXMEM) {
613 if (!(_INB(port) & 0x02))
614 return -EIO;
615 tmp = addr >> 13; /* convert to register mask */
616 _OUTB(port + 2, tmp);
617 hw->regs[2] = tmp;
618 }
619 else return -EINVAL;
620 break;
621
622 case SDLA_S508:
623 if (addr < S508_MAXMEM) {
624 tmp = addr >> 13; /* convert to register mask */
625 _OUTB(port + 2, tmp);
626 hw->regs[2] = tmp;
627 }
628 else return -EINVAL;
629 break;
630
631 case SDLA_S514:
632 return 0;
633
634 default:
635 return -EINVAL;
636 }
637 hw->vector = addr & 0xFFFFE000L;
638 return 0;
639}
640
641/*============================================================================
642 * Enable interrupt generation.
643 */
644
645static int sdla_inten (sdlahw_t* hw)
646{
647 unsigned port = hw->port;
648 int tmp, i;
649
650 switch (hw->type) {
651 case SDLA_S502E:
652 /* Note thar interrupt control operations on S502E are allowed
653 * only if CPU is enabled (bit 0 of status register is set).
654 */
655 if (_INB(port) & 0x01) {
656 _OUTB(port, 0x02); /* bit1 = 1, bit2 = 0 */
657 _OUTB(port, 0x06); /* bit1 = 1, bit2 = 1 */
658 hw->regs[0] = 0x06;
659 }
660 else return -EIO;
661 break;
662
663 case SDLA_S503:
664 tmp = hw->regs[0] | 0x04;
665 _OUTB(port, tmp);
666 hw->regs[0] = tmp; /* update mirror */
667 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
668 if (!(_INB(port) & 0x02)) /* verify */
669 return -EIO;
670 break;
671
672 case SDLA_S508:
673 tmp = hw->regs[0] | 0x10;
674 _OUTB(port, tmp);
675 hw->regs[0] = tmp; /* update mirror */
676 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
677 if (!(_INB(port + 1) & 0x10)) /* verify */
678 return -EIO;
679 break;
680
681 case SDLA_S502A:
682 case SDLA_S507:
683 break;
684
685 case SDLA_S514:
686 break;
687
688 default:
689 return -EINVAL;
690
691 }
692 return 0;
693}
694
695/*============================================================================
696 * Disable interrupt generation.
697 */
698
699#if 0
700int sdla_intde (sdlahw_t* hw)
701{
702 unsigned port = hw->port;
703 int tmp, i;
704
705 switch (hw->type) {
706 case SDLA_S502E:
707 /* Notes:
708 * 1) interrupt control operations are allowed only if CPU is
709 * enabled (bit 0 of status register is set).
710 * 2) disabling interrupts using bit 1 of control register
711 * causes IRQ line go high, therefore we are going to use
712 * 0x04 instead: lower it to inhibit interrupts to PC.
713 */
714 if (_INB(port) & 0x01) {
715 _OUTB(port, hw->regs[0] & ~0x04);
716 hw->regs[0] &= ~0x04;
717 }
718 else return -EIO;
719 break;
720
721 case SDLA_S503:
722 tmp = hw->regs[0] & ~0x04;
723 _OUTB(port, tmp);
724 hw->regs[0] = tmp; /* update mirror */
725 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
726 if (_INB(port) & 0x02) /* verify */
727 return -EIO;
728 break;
729
730 case SDLA_S508:
731 tmp = hw->regs[0] & ~0x10;
732 _OUTB(port, tmp);
733 hw->regs[0] = tmp; /* update mirror */
734 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
735 if (_INB(port) & 0x10) /* verify */
736 return -EIO;
737 break;
738
739 case SDLA_S502A:
740 case SDLA_S507:
741 break;
742
743 default:
744 return -EINVAL;
745 }
746 return 0;
747}
748#endif /* 0 */
749
750/*============================================================================
751 * Acknowledge SDLA hardware interrupt.
752 */
753
754static int sdla_intack (sdlahw_t* hw)
755{
756 unsigned port = hw->port;
757 int tmp;
758
759 switch (hw->type) {
760 case SDLA_S502E:
761 /* To acknoledge hardware interrupt we have to toggle bit 3 of
762 * control register: \_/
763 * Note that interrupt control operations on S502E are allowed
764 * only if CPU is enabled (bit 1 of status register is set).
765 */
766 if (_INB(port) & 0x01) {
767 tmp = hw->regs[0] & ~0x04;
768 _OUTB(port, tmp);
769 tmp |= 0x04;
770 _OUTB(port, tmp);
771 hw->regs[0] = tmp;
772 }
773 else return -EIO;
774 break;
775
776 case SDLA_S503:
777 if (_INB(port) & 0x04) {
778 tmp = hw->regs[0] & ~0x08;
779 _OUTB(port, tmp);
780 tmp |= 0x08;
781 _OUTB(port, tmp);
782 hw->regs[0] = tmp;
783 }
784 break;
785
786 case SDLA_S502A:
787 case SDLA_S507:
788 case SDLA_S508:
789 break;
790
791 default:
792 return -EINVAL;
793 }
794 return 0;
795}
796
797
798/*============================================================================
799 * Acknowledge S514 hardware interrupt.
800 */
801
802EXPORT_SYMBOL(S514_intack);
803
804void S514_intack (sdlahw_t* hw, u32 int_status)
805{
806 pci_write_config_dword(hw->pci_dev, PCI_INT_STATUS, int_status);
807}
808
809
810/*============================================================================
811 * Read the S514 hardware interrupt status.
812 */
813
814EXPORT_SYMBOL(read_S514_int_stat);
815
816void read_S514_int_stat (sdlahw_t* hw, u32* int_status)
817{
818 pci_read_config_dword(hw->pci_dev, PCI_INT_STATUS, int_status);
819}
820
821
822/*============================================================================
823 * Generate an interrupt to adapter's CPU.
824 */
825
826#if 0
827int sdla_intr (sdlahw_t* hw)
828{
829 unsigned port = hw->port;
830
831 switch (hw->type) {
832 case SDLA_S502A:
833 if (!(_INB(port) & 0x40)) {
834 _OUTB(port, 0x10); /* issue NMI to CPU */
835 hw->regs[0] = 0x10;
836 }
837 else return -EIO;
838 break;
839
840 case SDLA_S507:
841 if ((_INB(port) & 0x06) == 0x06) {
842 _OUTB(port + 3, 0);
843 }
844 else return -EIO;
845 break;
846
847 case SDLA_S508:
848 if (_INB(port + 1) & 0x02) {
849 _OUTB(port, 0x08);
850 }
851 else return -EIO;
852 break;
853
854 case SDLA_S502E:
855 case SDLA_S503:
856 default:
857 return -EINVAL;
858 }
859 return 0;
860}
861#endif /* 0 */
862
863/*============================================================================
864 * Execute Adapter Command.
865 * o Set exec flag.
866 * o Busy-wait until flag is reset.
867 * o Return number of loops made, or 0 if command timed out.
868 */
869
870EXPORT_SYMBOL(sdla_exec);
871
872int sdla_exec (void* opflag)
873{
874 volatile unsigned char* flag = opflag;
875 unsigned long tstop;
876 int nloops;
877
878 if(readb(flag) != 0x00) {
879 printk(KERN_INFO
880 "WANPIPE: opp flag set on entry to sdla_exec\n");
881 return 0;
882 }
883
884 writeb(0x01, flag);
885
886 tstop = SYSTEM_TICK + EXEC_TIMEOUT;
887
888 for (nloops = 1; (readb(flag) == 0x01); ++ nloops) {
889 unsigned delay = exec_idle;
890 while (-- delay); /* delay */
891 if (SYSTEM_TICK > tstop) return 0; /* time is up! */
892 }
893 return nloops;
894}
895
896/*============================================================================
897 * Read absolute adapter memory.
898 * Transfer data from adapter's memory to data buffer.
899 *
900 * Note:
901 * Care should be taken when crossing dual-port memory window boundary.
902 * This function is not atomic, so caller must disable interrupt if
903 * interrupt routines are accessing adapter shared memory.
904 */
905
906EXPORT_SYMBOL(sdla_peek);
907
908int sdla_peek (sdlahw_t* hw, unsigned long addr, void* buf, unsigned len)
909{
910
911 if (addr + len > hw->memory) /* verify arguments */
912 return -EINVAL;
913
914 if(hw->type == SDLA_S514) { /* copy data for the S514 adapter */
915 peek_by_4 ((unsigned long)hw->dpmbase + addr, buf, len);
916 return 0;
917 }
918
919 else { /* copy data for the S508 adapter */
920 unsigned long oldvec = hw->vector;
921 unsigned winsize = hw->dpmsize;
922 unsigned curpos, curlen; /* current offset and block size */
923 unsigned long curvec; /* current DPM window vector */
924 int err = 0;
925
926 while (len && !err) {
927 curpos = addr % winsize; /* current window offset */
928 curvec = addr - curpos; /* current window vector */
929 curlen = (len > (winsize - curpos)) ?
930 (winsize - curpos) : len;
931 /* Relocate window and copy block of data */
932 err = sdla_mapmem(hw, curvec);
933 peek_by_4 ((unsigned long)hw->dpmbase + curpos, buf,
934 curlen);
935 addr += curlen;
936 buf = (char*)buf + curlen;
937 len -= curlen;
938 }
939
940 /* Restore DPM window position */
941 sdla_mapmem(hw, oldvec);
942 return err;
943 }
944}
945
946
947/*============================================================================
948 * Read data from adapter's memory to a data buffer in 4-byte chunks.
949 * Note that we ensure that the SDLA memory address is on a 4-byte boundary
950 * before we begin moving the data in 4-byte chunks.
951*/
952
953static void peek_by_4 (unsigned long src, void* buf, unsigned len)
954{
955
956 /* byte copy data until we get to a 4-byte boundary */
957 while (len && (src & 0x03)) {
958 *(char *)buf ++ = readb(src ++);
959 len --;
960 }
961
962 /* copy data in 4-byte chunks */
963 while (len >= 4) {
964 *(unsigned long *)buf = readl(src);
965 buf += 4;
966 src += 4;
967 len -= 4;
968 }
969
970 /* byte copy any remaining data */
971 while (len) {
972 *(char *)buf ++ = readb(src ++);
973 len --;
974 }
975}
976
977
978/*============================================================================
979 * Write Absolute Adapter Memory.
980 * Transfer data from data buffer to adapter's memory.
981 *
982 * Note:
983 * Care should be taken when crossing dual-port memory window boundary.
984 * This function is not atomic, so caller must disable interrupt if
985 * interrupt routines are accessing adapter shared memory.
986 */
987
988EXPORT_SYMBOL(sdla_poke);
989
990int sdla_poke (sdlahw_t* hw, unsigned long addr, void* buf, unsigned len)
991{
992
993 if (addr + len > hw->memory) /* verify arguments */
994 return -EINVAL;
995
996 if(hw->type == SDLA_S514) { /* copy data for the S514 adapter */
997 poke_by_4 ((unsigned long)hw->dpmbase + addr, buf, len);
998 return 0;
999 }
1000
1001 else { /* copy data for the S508 adapter */
1002 unsigned long oldvec = hw->vector;
1003 unsigned winsize = hw->dpmsize;
1004 unsigned curpos, curlen; /* current offset and block size */
1005 unsigned long curvec; /* current DPM window vector */
1006 int err = 0;
1007
1008 while (len && !err) {
1009 curpos = addr % winsize; /* current window offset */
1010 curvec = addr - curpos; /* current window vector */
1011 curlen = (len > (winsize - curpos)) ?
1012 (winsize - curpos) : len;
1013 /* Relocate window and copy block of data */
1014 sdla_mapmem(hw, curvec);
1015 poke_by_4 ((unsigned long)hw->dpmbase + curpos, buf,
1016 curlen);
1017 addr += curlen;
1018 buf = (char*)buf + curlen;
1019 len -= curlen;
1020 }
1021
1022 /* Restore DPM window position */
1023 sdla_mapmem(hw, oldvec);
1024 return err;
1025 }
1026}
1027
1028
1029/*============================================================================
1030 * Write from a data buffer to adapter's memory in 4-byte chunks.
1031 * Note that we ensure that the SDLA memory address is on a 4-byte boundary
1032 * before we begin moving the data in 4-byte chunks.
1033*/
1034
1035static void poke_by_4 (unsigned long dest, void* buf, unsigned len)
1036{
1037
1038 /* byte copy data until we get to a 4-byte boundary */
1039 while (len && (dest & 0x03)) {
1040 writeb (*(char *)buf ++, dest ++);
1041 len --;
1042 }
1043
1044 /* copy data in 4-byte chunks */
1045 while (len >= 4) {
1046 writel (*(unsigned long *)buf, dest);
1047 dest += 4;
1048 buf += 4;
1049 len -= 4;
1050 }
1051
1052 /* byte copy any remaining data */
1053 while (len) {
1054 writeb (*(char *)buf ++ , dest ++);
1055 len --;
1056 }
1057}
1058
1059
1060#ifdef DONT_COMPIPLE_THIS
1061#endif /* DONT_COMPIPLE_THIS */
1062
1063/****** Hardware-Specific Functions *****************************************/
1064
1065/*============================================================================
1066 * Detect adapter type.
1067 * o if adapter type is specified then call detection routine for that adapter
1068 * type. Otherwise call detection routines for every adapter types until
1069 * adapter is detected.
1070 *
1071 * Notes:
1072 * 1) Detection tests are destructive! Adapter will be left in shutdown state
1073 * after the test.
1074 */
1075static int sdla_detect (sdlahw_t* hw)
1076{
1077 unsigned port = hw->port;
1078 int err = 0;
1079
1080 if (!port && (hw->type != SDLA_S514))
1081 return -EFAULT;
1082
1083 switch (hw->type) {
1084 case SDLA_S502A:
1085 if (!detect_s502a(port)) err = -ENODEV;
1086 break;
1087
1088 case SDLA_S502E:
1089 if (!detect_s502e(port)) err = -ENODEV;
1090 break;
1091
1092 case SDLA_S503:
1093 if (!detect_s503(port)) err = -ENODEV;
1094 break;
1095
1096 case SDLA_S507:
1097 if (!detect_s507(port)) err = -ENODEV;
1098 break;
1099
1100 case SDLA_S508:
1101 if (!detect_s508(port)) err = -ENODEV;
1102 break;
1103
1104 case SDLA_S514:
1105 if (!detect_s514(hw)) err = -ENODEV;
1106 break;
1107
1108 default:
1109 if (detect_s502a(port))
1110 hw->type = SDLA_S502A;
1111 else if (detect_s502e(port))
1112 hw->type = SDLA_S502E;
1113 else if (detect_s503(port))
1114 hw->type = SDLA_S503;
1115 else if (detect_s507(port))
1116 hw->type = SDLA_S507;
1117 else if (detect_s508(port))
1118 hw->type = SDLA_S508;
1119 else err = -ENODEV;
1120 }
1121 return err;
1122}
1123
1124/*============================================================================
1125 * Autoselect memory region.
1126 * o try all available DMP address options from the top down until success.
1127 */
1128static int sdla_autodpm (sdlahw_t* hw)
1129{
1130 int i, err = -EINVAL;
1131 unsigned* opt;
1132
1133 switch (hw->type) {
1134 case SDLA_S502A:
1135 opt = s502a_dpmbase_options;
1136 break;
1137
1138 case SDLA_S502E:
1139 case SDLA_S503:
1140 case SDLA_S508:
1141 opt = s508_dpmbase_options;
1142 break;
1143
1144 case SDLA_S507:
1145 opt = s507_dpmbase_options;
1146 break;
1147
1148 default:
1149 return -EINVAL;
1150 }
1151
1152 /* Start testing from 8th position, address
1153 * 0xC8000 from the 508 address table.
1154 * We don't want to test A**** addresses, since
1155 * they are usually used for Video */
1156 for (i = 8; i <= opt[0] && err; i++) {
1157 hw->dpmbase = phys_to_virt(opt[i]);
1158 err = sdla_setdpm(hw);
1159 }
1160 return err;
1161}
1162
1163/*============================================================================
1164 * Set up adapter dual-port memory window.
1165 * o shut down adapter
1166 * o make sure that no physical memory exists in this region, i.e entire
1167 * region reads 0xFF and is not writable when adapter is shut down.
1168 * o initialize adapter hardware
1169 * o make sure that region is usable with SDLA card, i.e. we can write to it
1170 * when adapter is configured.
1171 */
1172static int sdla_setdpm (sdlahw_t* hw)
1173{
1174 int err;
1175
1176 /* Shut down card and verify memory region */
1177 sdla_down(hw);
1178 if (check_memregion(hw->dpmbase, hw->dpmsize))
1179 return -EINVAL;
1180
1181 /* Initialize adapter and test on-board memory segment by segment.
1182 * If memory size appears to be less than shared memory window size,
1183 * assume that memory region is unusable.
1184 */
1185 err = sdla_init(hw);
1186 if (err) return err;
1187
1188 if (sdla_memtest(hw) < hw->dpmsize) { /* less than window size */
1189 sdla_down(hw);
1190 return -EIO;
1191 }
1192 sdla_mapmem(hw, 0L); /* set window vector at bottom */
1193 return 0;
1194}
1195
1196/*============================================================================
1197 * Load adapter from the memory image of the SDLA firmware module.
1198 * o verify firmware integrity and compatibility
1199 * o start adapter up
1200 */
1201static int sdla_load (sdlahw_t* hw, sfm_t* sfm, unsigned len)
1202{
1203
1204 int i;
1205
1206 /* Verify firmware signature */
1207 if (strcmp(sfm->signature, SFM_SIGNATURE)) {
1208 printk(KERN_INFO "%s: not SDLA firmware!\n",
1209 modname);
1210 return -EINVAL;
1211 }
1212
1213 /* Verify firmware module format version */
1214 if (sfm->version != SFM_VERSION) {
1215 printk(KERN_INFO
1216 "%s: firmware format %u rejected! Expecting %u.\n",
1217 modname, sfm->version, SFM_VERSION);
1218 return -EINVAL;
1219 }
1220
1221 /* Verify firmware module length and checksum */
1222 if ((len - offsetof(sfm_t, image) != sfm->info.codesize) ||
1223 (checksum((void*)&sfm->info,
1224 sizeof(sfm_info_t) + sfm->info.codesize) != sfm->checksum)) {
1225 printk(KERN_INFO "%s: firmware corrupted!\n", modname);
1226 return -EINVAL;
1227 }
1228
1229 /* Announce */
1230 printk(KERN_INFO "%s: loading %s (ID=%u)...\n", modname,
1231 (sfm->descr[0] != '\0') ? sfm->descr : "unknown firmware",
1232 sfm->info.codeid);
1233
1234 if(hw->type == SDLA_S514)
1235 printk(KERN_INFO "%s: loading S514 adapter, CPU %c\n",
1236 modname, hw->S514_cpu_no[0]);
1237
1238 /* Scan through the list of compatible adapters and make sure our
1239 * adapter type is listed.
1240 */
1241 for (i = 0;
1242 (i < SFM_MAX_SDLA) && (sfm->info.adapter[i] != hw->type);
1243 ++i);
1244
1245 if (i == SFM_MAX_SDLA) {
1246 printk(KERN_INFO "%s: firmware is not compatible with S%u!\n",
1247 modname, hw->type);
1248 return -EINVAL;
1249 }
1250
1251
1252 /* Make sure there is enough on-board memory */
1253 if (hw->memory < sfm->info.memsize) {
1254 printk(KERN_INFO
1255 "%s: firmware needs %lu bytes of on-board memory!\n",
1256 modname, sfm->info.memsize);
1257 return -EINVAL;
1258 }
1259
1260 /* Move code onto adapter */
1261 if (sdla_poke(hw, sfm->info.codeoffs, sfm->image, sfm->info.codesize)) {
1262 printk(KERN_INFO "%s: failed to load code segment!\n",
1263 modname);
1264 return -EIO;
1265 }
1266
1267 /* Prepare boot-time configuration data and kick-off CPU */
1268 sdla_bootcfg(hw, &sfm->info);
1269 if (sdla_start(hw, sfm->info.startoffs)) {
1270 printk(KERN_INFO "%s: Damn... Adapter won't start!\n",
1271 modname);
1272 return -EIO;
1273 }
1274
1275 /* position DPM window over the mailbox and enable interrupts */
1276 if (sdla_mapmem(hw, sfm->info.winoffs) || sdla_inten(hw)) {
1277 printk(KERN_INFO "%s: adapter hardware failure!\n",
1278 modname);
1279 return -EIO;
1280 }
1281 hw->fwid = sfm->info.codeid; /* set firmware ID */
1282 return 0;
1283}
1284
1285/*============================================================================
1286 * Initialize SDLA hardware: setup memory window, IRQ, etc.
1287 */
1288static int sdla_init (sdlahw_t* hw)
1289{
1290 int i;
1291
1292 for (i = 0; i < SDLA_MAXIORANGE; ++i)
1293 hw->regs[i] = 0;
1294
1295 switch (hw->type) {
1296 case SDLA_S502A: return init_s502a(hw);
1297 case SDLA_S502E: return init_s502e(hw);
1298 case SDLA_S503: return init_s503(hw);
1299 case SDLA_S507: return init_s507(hw);
1300 case SDLA_S508: return init_s508(hw);
1301 }
1302 return -EINVAL;
1303}
1304
1305/*============================================================================
1306 * Test adapter on-board memory.
1307 * o slide DPM window from the bottom up and test adapter memory segment by
1308 * segment.
1309 * Return adapter memory size.
1310 */
1311static unsigned long sdla_memtest (sdlahw_t* hw)
1312{
1313 unsigned long memsize;
1314 unsigned winsize;
1315
1316 for (memsize = 0, winsize = hw->dpmsize;
1317 !sdla_mapmem(hw, memsize) &&
1318 (test_memregion(hw->dpmbase, winsize) == winsize)
1319 ;
1320 memsize += winsize)
1321 ;
1322 hw->memory = memsize;
1323 return memsize;
1324}
1325
1326/*============================================================================
1327 * Prepare boot-time firmware configuration data.
1328 * o position DPM window
1329 * o initialize configuration data area
1330 */
1331static int sdla_bootcfg (sdlahw_t* hw, sfm_info_t* sfminfo)
1332{
1333 unsigned char* data;
1334
1335 if (!sfminfo->datasize) return 0; /* nothing to do */
1336
1337 if (sdla_mapmem(hw, sfminfo->dataoffs) != 0)
1338 return -EIO;
1339
1340 if(hw->type == SDLA_S514)
1341 data = (void*)(hw->dpmbase + sfminfo->dataoffs);
1342 else
1343 data = (void*)((u8 *)hw->dpmbase +
1344 (sfminfo->dataoffs - hw->vector));
1345
1346 memset_io (data, 0, sfminfo->datasize);
1347
1348 writeb (make_config_byte(hw), &data[0x00]);
1349
1350 switch (sfminfo->codeid) {
1351 case SFID_X25_502:
1352 case SFID_X25_508:
1353 writeb (3, &data[0x01]); /* T1 timer */
1354 writeb (10, &data[0x03]); /* N2 */
1355 writeb (7, &data[0x06]); /* HDLC window size */
1356 writeb (1, &data[0x0B]); /* DTE */
1357 writeb (2, &data[0x0C]); /* X.25 packet window size */
1358 writew (128, &data[0x0D]); /* default X.25 data size */
1359 writew (128, &data[0x0F]); /* maximum X.25 data size */
1360 break;
1361 }
1362 return 0;
1363}
1364
1365/*============================================================================
1366 * Prepare configuration byte identifying adapter type and CPU clock rate.
1367 */
1368static unsigned char make_config_byte (sdlahw_t* hw)
1369{
1370 unsigned char byte = 0;
1371
1372 switch (hw->pclk) {
1373 case 5000: byte = 0x01; break;
1374 case 7200: byte = 0x02; break;
1375 case 8000: byte = 0x03; break;
1376 case 10000: byte = 0x04; break;
1377 case 16000: byte = 0x05; break;
1378 }
1379
1380 switch (hw->type) {
1381 case SDLA_S502E: byte |= 0x80; break;
1382 case SDLA_S503: byte |= 0x40; break;
1383 }
1384 return byte;
1385}
1386
1387/*============================================================================
1388 * Start adapter's CPU.
1389 * o calculate a pointer to adapter's cold boot entry point
1390 * o position DPM window
1391 * o place boot instruction (jp addr) at cold boot entry point
1392 * o start CPU
1393 */
1394static int sdla_start (sdlahw_t* hw, unsigned addr)
1395{
1396 unsigned port = hw->port;
1397 unsigned char *bootp;
1398 int err, tmp, i;
1399
1400 if (!port && (hw->type != SDLA_S514)) return -EFAULT;
1401
1402 switch (hw->type) {
1403 case SDLA_S502A:
1404 bootp = hw->dpmbase;
1405 bootp += 0x66;
1406 break;
1407
1408 case SDLA_S502E:
1409 case SDLA_S503:
1410 case SDLA_S507:
1411 case SDLA_S508:
1412 case SDLA_S514:
1413 bootp = hw->dpmbase;
1414 break;
1415
1416 default:
1417 return -EINVAL;
1418 }
1419
1420 err = sdla_mapmem(hw, 0);
1421 if (err) return err;
1422
1423 writeb (0xC3, bootp); /* Z80: 'jp' opcode */
1424 bootp ++;
1425 writew (addr, bootp);
1426
1427 switch (hw->type) {
1428 case SDLA_S502A:
1429 _OUTB(port, 0x10); /* issue NMI to CPU */
1430 hw->regs[0] = 0x10;
1431 break;
1432
1433 case SDLA_S502E:
1434 _OUTB(port + 3, 0x01); /* start CPU */
1435 hw->regs[3] = 0x01;
1436 for (i = 0; i < SDLA_IODELAY; ++i);
1437 if (_INB(port) & 0x01) { /* verify */
1438 /*
1439 * Enabling CPU changes functionality of the
1440 * control register, so we have to reset its
1441 * mirror.
1442 */
1443 _OUTB(port, 0); /* disable interrupts */
1444 hw->regs[0] = 0;
1445 }
1446 else return -EIO;
1447 break;
1448
1449 case SDLA_S503:
1450 tmp = hw->regs[0] | 0x09; /* set bits 0 and 3 */
1451 _OUTB(port, tmp);
1452 hw->regs[0] = tmp; /* update mirror */
1453 for (i = 0; i < SDLA_IODELAY; ++i);
1454 if (!(_INB(port) & 0x01)) /* verify */
1455 return -EIO;
1456 break;
1457
1458 case SDLA_S507:
1459 tmp = hw->regs[0] | 0x02;
1460 _OUTB(port, tmp);
1461 hw->regs[0] = tmp; /* update mirror */
1462 for (i = 0; i < SDLA_IODELAY; ++i);
1463 if (!(_INB(port) & 0x04)) /* verify */
1464 return -EIO;
1465 break;
1466
1467 case SDLA_S508:
1468 tmp = hw->regs[0] | 0x02;
1469 _OUTB(port, tmp);
1470 hw->regs[0] = tmp; /* update mirror */
1471 for (i = 0; i < SDLA_IODELAY; ++i);
1472 if (!(_INB(port + 1) & 0x02)) /* verify */
1473 return -EIO;
1474 break;
1475
1476 case SDLA_S514:
1477 writeb (S514_CPU_START, hw->vector);
1478 break;
1479
1480 default:
1481 return -EINVAL;
1482 }
1483 return 0;
1484}
1485
1486/*============================================================================
1487 * Initialize S502A adapter.
1488 */
1489static int init_s502a (sdlahw_t* hw)
1490{
1491 unsigned port = hw->port;
1492 int tmp, i;
1493
1494 if (!detect_s502a(port))
1495 return -ENODEV;
1496
1497 hw->regs[0] = 0x08;
1498 hw->regs[1] = 0xFF;
1499
1500 /* Verify configuration options */
1501 i = get_option_index(s502a_dpmbase_options, virt_to_phys(hw->dpmbase));
1502 if (i == 0)
1503 return -EINVAL;
1504
1505 tmp = s502a_hmcr[i - 1];
1506 switch (hw->dpmsize) {
1507 case 0x2000:
1508 tmp |= 0x01;
1509 break;
1510
1511 case 0x10000L:
1512 break;
1513
1514 default:
1515 return -EINVAL;
1516 }
1517
1518 /* Setup dual-port memory window (this also enables memory access) */
1519 _OUTB(port + 1, tmp);
1520 hw->regs[1] = tmp;
1521 hw->regs[0] = 0x08;
1522 return 0;
1523}
1524
1525/*============================================================================
1526 * Initialize S502E adapter.
1527 */
1528static int init_s502e (sdlahw_t* hw)
1529{
1530 unsigned port = hw->port;
1531 int tmp, i;
1532
1533 if (!detect_s502e(port))
1534 return -ENODEV;
1535
1536 /* Verify configuration options */
1537 i = get_option_index(s508_dpmbase_options, virt_to_phys(hw->dpmbase));
1538 if (i == 0)
1539 return -EINVAL;
1540
1541 tmp = s502e_hmcr[i - 1];
1542 switch (hw->dpmsize) {
1543 case 0x2000:
1544 tmp |= 0x01;
1545 break;
1546
1547 case 0x10000L:
1548 break;
1549
1550 default:
1551 return -EINVAL;
1552 }
1553
1554 /* Setup dual-port memory window */
1555 _OUTB(port + 1, tmp);
1556 hw->regs[1] = tmp;
1557
1558 /* Enable memory access */
1559 _OUTB(port, 0x02);
1560 hw->regs[0] = 0x02;
1561 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1562 return (_INB(port) & 0x02) ? 0 : -EIO;
1563}
1564
1565/*============================================================================
1566 * Initialize S503 adapter.
1567 * ---------------------------------------------------------------------------
1568 */
1569static int init_s503 (sdlahw_t* hw)
1570{
1571 unsigned port = hw->port;
1572 int tmp, i;
1573
1574 if (!detect_s503(port))
1575 return -ENODEV;
1576
1577 /* Verify configuration options */
1578 i = get_option_index(s508_dpmbase_options, virt_to_phys(hw->dpmbase));
1579 if (i == 0)
1580 return -EINVAL;
1581
1582 tmp = s502e_hmcr[i - 1];
1583 switch (hw->dpmsize) {
1584 case 0x2000:
1585 tmp |= 0x01;
1586 break;
1587
1588 case 0x10000L:
1589 break;
1590
1591 default:
1592 return -EINVAL;
1593 }
1594
1595 /* Setup dual-port memory window */
1596 _OUTB(port + 1, tmp);
1597 hw->regs[1] = tmp;
1598
1599 /* Enable memory access */
1600 _OUTB(port, 0x02);
1601 hw->regs[0] = 0x02; /* update mirror */
1602 return 0;
1603}
1604
1605/*============================================================================
1606 * Initialize S507 adapter.
1607 */
1608static int init_s507 (sdlahw_t* hw)
1609{
1610 unsigned port = hw->port;
1611 int tmp, i;
1612
1613 if (!detect_s507(port))
1614 return -ENODEV;
1615
1616 /* Verify configuration options */
1617 i = get_option_index(s507_dpmbase_options, virt_to_phys(hw->dpmbase));
1618 if (i == 0)
1619 return -EINVAL;
1620
1621 tmp = s507_hmcr[i - 1];
1622 switch (hw->dpmsize) {
1623 case 0x2000:
1624 tmp |= 0x01;
1625 break;
1626
1627 case 0x10000L:
1628 break;
1629
1630 default:
1631 return -EINVAL;
1632 }
1633
1634 /* Enable adapter's logic */
1635 _OUTB(port, 0x01);
1636 hw->regs[0] = 0x01;
1637 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1638 if (!(_INB(port) & 0x20))
1639 return -EIO;
1640
1641 /* Setup dual-port memory window */
1642 _OUTB(port + 1, tmp);
1643 hw->regs[1] = tmp;
1644
1645 /* Enable memory access */
1646 tmp = hw->regs[0] | 0x04;
1647 if (hw->irq) {
1648 i = get_option_index(s508_irq_options, hw->irq);
1649 if (i) tmp |= s507_irqmask[i - 1];
1650 }
1651 _OUTB(port, tmp);
1652 hw->regs[0] = tmp; /* update mirror */
1653 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1654 return (_INB(port) & 0x08) ? 0 : -EIO;
1655}
1656
1657/*============================================================================
1658 * Initialize S508 adapter.
1659 */
1660static int init_s508 (sdlahw_t* hw)
1661{
1662 unsigned port = hw->port;
1663 int tmp, i;
1664
1665 if (!detect_s508(port))
1666 return -ENODEV;
1667
1668 /* Verify configuration options */
1669 i = get_option_index(s508_dpmbase_options, virt_to_phys(hw->dpmbase));
1670 if (i == 0)
1671 return -EINVAL;
1672
1673 /* Setup memory configuration */
1674 tmp = s508_hmcr[i - 1];
1675 _OUTB(port + 1, tmp);
1676 hw->regs[1] = tmp;
1677
1678 /* Enable memory access */
1679 _OUTB(port, 0x04);
1680 hw->regs[0] = 0x04; /* update mirror */
1681 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1682 return (_INB(port + 1) & 0x04) ? 0 : -EIO;
1683}
1684
1685/*============================================================================
1686 * Detect S502A adapter.
1687 * Following tests are used to detect S502A adapter:
1688 * 1. All registers other than status (BASE) should read 0xFF
1689 * 2. After writing 00001000b to control register, status register should
1690 * read 01000000b.
1691 * 3. After writing 0 to control register, status register should still
1692 * read 01000000b.
1693 * 4. After writing 00000100b to control register, status register should
1694 * read 01000100b.
1695 * Return 1 if detected o.k. or 0 if failed.
1696 * Note: This test is destructive! Adapter will be left in shutdown
1697 * state after the test.
1698 */
1699static int detect_s502a (int port)
1700{
1701 int i, j;
1702
1703 if (!get_option_index(s502_port_options, port))
1704 return 0;
1705
1706 for (j = 1; j < SDLA_MAXIORANGE; ++j) {
1707 if (_INB(port + j) != 0xFF)
1708 return 0;
1709 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1710 }
1711
1712 _OUTB(port, 0x08); /* halt CPU */
1713 _OUTB(port, 0x08);
1714 _OUTB(port, 0x08);
1715 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1716 if (_INB(port) != 0x40)
1717 return 0;
1718 _OUTB(port, 0x00);
1719 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1720 if (_INB(port) != 0x40)
1721 return 0;
1722 _OUTB(port, 0x04);
1723 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1724 if (_INB(port) != 0x44)
1725 return 0;
1726
1727 /* Reset adapter */
1728 _OUTB(port, 0x08);
1729 _OUTB(port, 0x08);
1730 _OUTB(port, 0x08);
1731 _OUTB(port + 1, 0xFF);
1732 return 1;
1733}
1734
1735/*============================================================================
1736 * Detect S502E adapter.
1737 * Following tests are used to verify adapter presence:
1738 * 1. All registers other than status (BASE) should read 0xFF.
1739 * 2. After writing 0 to CPU control register (BASE+3), status register
1740 * (BASE) should read 11111000b.
1741 * 3. After writing 00000100b to port BASE (set bit 2), status register
1742 * (BASE) should read 11111100b.
1743 * Return 1 if detected o.k. or 0 if failed.
1744 * Note: This test is destructive! Adapter will be left in shutdown
1745 * state after the test.
1746 */
1747static int detect_s502e (int port)
1748{
1749 int i, j;
1750
1751 if (!get_option_index(s502_port_options, port))
1752 return 0;
1753 for (j = 1; j < SDLA_MAXIORANGE; ++j) {
1754 if (_INB(port + j) != 0xFF)
1755 return 0;
1756 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1757 }
1758
1759 _OUTB(port + 3, 0); /* CPU control reg. */
1760 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1761 if (_INB(port) != 0xF8) /* read status */
1762 return 0;
1763 _OUTB(port, 0x04); /* set bit 2 */
1764 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1765 if (_INB(port) != 0xFC) /* verify */
1766 return 0;
1767
1768 /* Reset adapter */
1769 _OUTB(port, 0);
1770 return 1;
1771}
1772
1773/*============================================================================
1774 * Detect s503 adapter.
1775 * Following tests are used to verify adapter presence:
1776 * 1. All registers other than status (BASE) should read 0xFF.
1777 * 2. After writing 0 to control register (BASE), status register (BASE)
1778 * should read 11110000b.
1779 * 3. After writing 00000100b (set bit 2) to control register (BASE),
1780 * status register should read 11110010b.
1781 * Return 1 if detected o.k. or 0 if failed.
1782 * Note: This test is destructive! Adapter will be left in shutdown
1783 * state after the test.
1784 */
1785static int detect_s503 (int port)
1786{
1787 int i, j;
1788
1789 if (!get_option_index(s503_port_options, port))
1790 return 0;
1791 for (j = 1; j < SDLA_MAXIORANGE; ++j) {
1792 if (_INB(port + j) != 0xFF)
1793 return 0;
1794 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1795 }
1796
1797 _OUTB(port, 0); /* reset control reg.*/
1798 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1799 if (_INB(port) != 0xF0) /* read status */
1800 return 0;
1801 _OUTB(port, 0x04); /* set bit 2 */
1802 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1803 if (_INB(port) != 0xF2) /* verify */
1804 return 0;
1805
1806 /* Reset adapter */
1807 _OUTB(port, 0);
1808 return 1;
1809}
1810
1811/*============================================================================
1812 * Detect s507 adapter.
1813 * Following tests are used to detect s507 adapter:
1814 * 1. All ports should read the same value.
1815 * 2. After writing 0x00 to control register, status register should read
1816 * ?011000?b.
1817 * 3. After writing 0x01 to control register, status register should read
1818 * ?011001?b.
1819 * Return 1 if detected o.k. or 0 if failed.
1820 * Note: This test is destructive! Adapter will be left in shutdown
1821 * state after the test.
1822 */
1823static int detect_s507 (int port)
1824{
1825 int tmp, i, j;
1826
1827 if (!get_option_index(s508_port_options, port))
1828 return 0;
1829 tmp = _INB(port);
1830 for (j = 1; j < S507_IORANGE; ++j) {
1831 if (_INB(port + j) != tmp)
1832 return 0;
1833 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1834 }
1835
1836 _OUTB(port, 0x00);
1837 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1838 if ((_INB(port) & 0x7E) != 0x30)
1839 return 0;
1840 _OUTB(port, 0x01);
1841 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1842 if ((_INB(port) & 0x7E) != 0x32)
1843 return 0;
1844
1845 /* Reset adapter */
1846 _OUTB(port, 0x00);
1847 return 1;
1848}
1849
1850/*============================================================================
1851 * Detect s508 adapter.
1852 * Following tests are used to detect s508 adapter:
1853 * 1. After writing 0x00 to control register, status register should read
1854 * ??000000b.
1855 * 2. After writing 0x10 to control register, status register should read
1856 * ??010000b
1857 * Return 1 if detected o.k. or 0 if failed.
1858 * Note: This test is destructive! Adapter will be left in shutdown
1859 * state after the test.
1860 */
1861static int detect_s508 (int port)
1862{
1863 int i;
1864
1865 if (!get_option_index(s508_port_options, port))
1866 return 0;
1867 _OUTB(port, 0x00);
1868 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1869 if ((_INB(port + 1) & 0x3F) != 0x00)
1870 return 0;
1871 _OUTB(port, 0x10);
1872 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1873 if ((_INB(port + 1) & 0x3F) != 0x10)
1874 return 0;
1875
1876 /* Reset adapter */
1877 _OUTB(port, 0x00);
1878 return 1;
1879}
1880
1881/*============================================================================
1882 * Detect s514 PCI adapter.
1883 * Return 1 if detected o.k. or 0 if failed.
1884 * Note: This test is destructive! Adapter will be left in shutdown
1885 * state after the test.
1886 */
1887static int detect_s514 (sdlahw_t* hw)
1888{
1889 unsigned char CPU_no, slot_no, auto_slot_cfg;
1890 int number_S514_cards = 0;
1891 u32 S514_mem_base_addr = 0;
1892 u32 ut_u32;
1893 struct pci_dev *pci_dev;
1894
1895
1896#ifndef CONFIG_PCI
1897 printk(KERN_INFO "%s: Linux not compiled for PCI usage!\n", modname);
1898 return 0;
1899#endif
1900
1901 /*
1902 The 'setup()' procedure in 'sdlamain.c' passes the CPU number and the
1903 slot number defined in 'router.conf' via the 'port' definition.
1904 */
1905 CPU_no = hw->S514_cpu_no[0];
1906 slot_no = hw->S514_slot_no;
1907 auto_slot_cfg = hw->auto_pci_cfg;
1908
1909 if (auto_slot_cfg){
1910 printk(KERN_INFO "%s: srch... S514 card, CPU %c, Slot=Auto\n",
1911 modname, CPU_no);
1912
1913 }else{
1914 printk(KERN_INFO "%s: srch... S514 card, CPU %c, Slot #%d\n",
1915 modname, CPU_no, slot_no);
1916 }
1917
1918 /* check to see that CPU A or B has been selected in 'router.conf' */
1919 switch(CPU_no) {
1920 case S514_CPU_A:
1921 case S514_CPU_B:
1922 break;
1923
1924 default:
1925 printk(KERN_INFO "%s: S514 CPU definition invalid.\n",
1926 modname);
1927 printk(KERN_INFO "Must be 'A' or 'B'\n");
1928 return 0;
1929 }
1930
1931 number_S514_cards = find_s514_adapter(hw, 0);
1932 if(!number_S514_cards)
1933 return 0;
1934
1935 /* we are using a single S514 adapter with a slot of 0 so re-read the */
1936 /* location of this adapter */
1937 if((number_S514_cards == 1) && auto_slot_cfg) {
1938 number_S514_cards = find_s514_adapter(hw, 1);
1939 if(!number_S514_cards) {
1940 printk(KERN_INFO "%s: Error finding PCI card\n",
1941 modname);
1942 return 0;
1943 }
1944 }
1945
1946 pci_dev = hw->pci_dev;
1947 /* read the physical memory base address */
1948 S514_mem_base_addr = (CPU_no == S514_CPU_A) ?
1949 (pci_dev->resource[1].start) :
1950 (pci_dev->resource[2].start);
1951
1952 printk(KERN_INFO "%s: S514 PCI memory at 0x%X\n",
1953 modname, S514_mem_base_addr);
1954 if(!S514_mem_base_addr) {
1955 if(CPU_no == S514_CPU_B)
1956 printk(KERN_INFO "%s: CPU #B not present on the card\n", modname);
1957 else
1958 printk(KERN_INFO "%s: No PCI memory allocated to card\n", modname);
1959 return 0;
1960 }
1961
1962 /* enable the PCI memory */
1963 pci_read_config_dword(pci_dev,
1964 (CPU_no == S514_CPU_A) ? PCI_MAP0_DWORD : PCI_MAP1_DWORD,
1965 &ut_u32);
1966 pci_write_config_dword(pci_dev,
1967 (CPU_no == S514_CPU_A) ? PCI_MAP0_DWORD : PCI_MAP1_DWORD,
1968 (ut_u32 | PCI_MEMORY_ENABLE));
1969
1970 /* check the IRQ allocated and enable IRQ usage */
1971 if(!(hw->irq = pci_dev->irq)) {
1972 printk(KERN_INFO "%s: IRQ not allocated to S514 adapter\n",
1973 modname);
1974 return 0;
1975 }
1976
1977 /* BUG FIX : Mar 6 2000
1978 * On a initial loading of the card, we must check
1979 * and clear PCI interrupt bits, due to a reset
1980 * problem on some other boards. i.e. An interrupt
1981 * might be pending, even after system bootup,
1982 * in which case, when starting wanrouter the machine
1983 * would crash.
1984 */
1985 if (init_pci_slot(hw))
1986 return 0;
1987
1988 pci_read_config_dword(pci_dev, PCI_INT_CONFIG, &ut_u32);
1989 ut_u32 |= (CPU_no == S514_CPU_A) ?
1990 PCI_ENABLE_IRQ_CPU_A : PCI_ENABLE_IRQ_CPU_B;
1991 pci_write_config_dword(pci_dev, PCI_INT_CONFIG, ut_u32);
1992
1993 printk(KERN_INFO "%s: IRQ %d allocated to the S514 card\n",
1994 modname, hw->irq);
1995
1996 /* map the physical PCI memory to virtual memory */
1997 hw->dpmbase = ioremap((unsigned long)S514_mem_base_addr,
1998 (unsigned long)MAX_SIZEOF_S514_MEMORY);
1999 /* map the physical control register memory to virtual memory */
2000 hw->vector = (unsigned long)ioremap(
2001 (unsigned long)(S514_mem_base_addr + S514_CTRL_REG_BYTE),
2002 (unsigned long)16);
2003
2004 if(!hw->dpmbase || !hw->vector) {
2005 printk(KERN_INFO "%s: PCI virtual memory allocation failed\n",
2006 modname);
2007 return 0;
2008 }
2009
2010 /* halt the adapter */
2011 writeb (S514_CPU_HALT, hw->vector);
2012
2013 return 1;
2014}
2015
2016/*============================================================================
2017 * Find the S514 PCI adapter in the PCI bus.
2018 * Return the number of S514 adapters found (0 if no adapter found).
2019 */
2020static int find_s514_adapter(sdlahw_t* hw, char find_first_S514_card)
2021{
2022 unsigned char slot_no;
2023 int number_S514_cards = 0;
2024 char S514_found_in_slot = 0;
2025 u16 PCI_subsys_vendor;
2026
2027 struct pci_dev *pci_dev = NULL;
2028
2029 slot_no = hw->S514_slot_no;
2030
2031 while ((pci_dev = pci_find_device(V3_VENDOR_ID, V3_DEVICE_ID, pci_dev))
2032 != NULL) {
2033
2034 pci_read_config_word(pci_dev, PCI_SUBSYS_VENDOR_WORD,
2035 &PCI_subsys_vendor);
2036
2037 if(PCI_subsys_vendor != SANGOMA_SUBSYS_VENDOR)
2038 continue;
2039
2040 hw->pci_dev = pci_dev;
2041
2042 if(find_first_S514_card)
2043 return(1);
2044
2045 number_S514_cards ++;
2046
2047 printk(KERN_INFO
2048 "%s: S514 card found, slot #%d (devfn 0x%X)\n",
2049 modname, ((pci_dev->devfn >> 3) & PCI_DEV_SLOT_MASK),
2050 pci_dev->devfn);
2051
2052 if (hw->auto_pci_cfg){
2053 hw->S514_slot_no = ((pci_dev->devfn >> 3) & PCI_DEV_SLOT_MASK);
2054 slot_no = hw->S514_slot_no;
2055
2056 }else if (((pci_dev->devfn >> 3) & PCI_DEV_SLOT_MASK) == slot_no){
2057 S514_found_in_slot = 1;
2058 break;
2059 }
2060 }
2061
2062 /* if no S514 adapter has been found, then exit */
2063 if (!number_S514_cards) {
2064 printk(KERN_INFO "%s: Error, no S514 adapters found\n", modname);
2065 return 0;
2066 }
2067 /* if more than one S514 card has been found, then the user must have */ /* defined a slot number so that the correct adapter is used */
2068 else if ((number_S514_cards > 1) && hw->auto_pci_cfg) {
2069 printk(KERN_INFO "%s: Error, PCI Slot autodetect Failed! \n"
2070 "%s: More than one S514 adapter found.\n"
2071 "%s: Disable the Autodetect feature and supply\n"
2072 "%s: the PCISLOT numbers for each card.\n",
2073 modname,modname,modname,modname);
2074 return 0;
2075 }
2076 /* if the user has specified a slot number and the S514 adapter has */
2077 /* not been found in that slot, then exit */
2078 else if (!hw->auto_pci_cfg && !S514_found_in_slot) {
2079 printk(KERN_INFO
2080 "%s: Error, S514 card not found in specified slot #%d\n",
2081 modname, slot_no);
2082 return 0;
2083 }
2084
2085 return (number_S514_cards);
2086}
2087
2088
2089
2090/******* Miscellaneous ******************************************************/
2091
2092/*============================================================================
2093 * Calibrate SDLA memory access delay.
2094 * Count number of idle loops made within 1 second and then calculate the
2095 * number of loops that should be made to achive desired delay.
2096 */
2097static int calibrate_delay (int mks)
2098{
2099 unsigned int delay;
2100 unsigned long stop;
2101
2102 for (delay = 0, stop = SYSTEM_TICK + HZ; SYSTEM_TICK < stop; ++delay);
2103 return (delay/(1000000L/mks) + 1);
2104}
2105
2106/*============================================================================
2107 * Get option's index into the options list.
2108 * Return option's index (1 .. N) or zero if option is invalid.
2109 */
2110static int get_option_index (unsigned* optlist, unsigned optval)
2111{
2112 int i;
2113
2114 for (i = 1; i <= optlist[0]; ++i)
2115 if ( optlist[i] == optval)
2116 return i;
2117 return 0;
2118}
2119
2120/*============================================================================
2121 * Check memory region to see if it's available.
2122 * Return: 0 ok.
2123 */
2124static unsigned check_memregion (void* ptr, unsigned len)
2125{
2126 volatile unsigned char* p = ptr;
2127
2128 for (; len && (readb (p) == 0xFF); --len, ++p) {
2129 writeb (0, p); /* attempt to write 0 */
2130 if (readb(p) != 0xFF) { /* still has to read 0xFF */
2131 writeb (0xFF, p);/* restore original value */
2132 break; /* not good */
2133 }
2134 }
2135
2136 return len;
2137}
2138
2139/*============================================================================
2140 * Test memory region.
2141 * Return: size of the region that passed the test.
2142 * Note: Region size must be multiple of 2 !
2143 */
2144static unsigned test_memregion (void* ptr, unsigned len)
2145{
2146 volatile unsigned short* w_ptr;
2147 unsigned len_w = len >> 1; /* region len in words */
2148 unsigned i;
2149
2150 for (i = 0, w_ptr = ptr; i < len_w; ++i, ++w_ptr)
2151 writew (0xAA55, w_ptr);
2152
2153 for (i = 0, w_ptr = ptr; i < len_w; ++i, ++w_ptr)
2154 if (readw (w_ptr) != 0xAA55) {
2155 len_w = i;
2156 break;
2157 }
2158
2159 for (i = 0, w_ptr = ptr; i < len_w; ++i, ++w_ptr)
2160 writew (0x55AA, w_ptr);
2161
2162 for (i = 0, w_ptr = ptr; i < len_w; ++i, ++w_ptr)
2163 if (readw(w_ptr) != 0x55AA) {
2164 len_w = i;
2165 break;
2166 }
2167
2168 for (i = 0, w_ptr = ptr; i < len_w; ++i, ++w_ptr)
2169 writew (0, w_ptr);
2170
2171 return len_w << 1;
2172}
2173
2174/*============================================================================
2175 * Calculate 16-bit CRC using CCITT polynomial.
2176 */
2177static unsigned short checksum (unsigned char* buf, unsigned len)
2178{
2179 unsigned short crc = 0;
2180 unsigned mask, flag;
2181
2182 for (; len; --len, ++buf) {
2183 for (mask = 0x80; mask; mask >>= 1) {
2184 flag = (crc & 0x8000);
2185 crc <<= 1;
2186 crc |= ((*buf & mask) ? 1 : 0);
2187 if (flag) crc ^= 0x1021;
2188 }
2189 }
2190 return crc;
2191}
2192
2193static int init_pci_slot(sdlahw_t *hw)
2194{
2195
2196 u32 int_status;
2197 int volatile found=0;
2198 int i=0;
2199
2200 /* Check if this is a very first load for a specific
2201 * pci card. If it is, clear the interrput bits, and
2202 * set the flag indicating that this card was initialized.
2203 */
2204
2205 for (i=0; (i<MAX_S514_CARDS) && !found; i++){
2206 if (pci_slot_ar[i] == hw->S514_slot_no){
2207 found=1;
2208 break;
2209 }
2210 if (pci_slot_ar[i] == 0xFF){
2211 break;
2212 }
2213 }
2214
2215 if (!found){
2216 read_S514_int_stat(hw,&int_status);
2217 S514_intack(hw,int_status);
2218 if (i == MAX_S514_CARDS){
2219 printk(KERN_INFO "%s: Critical Error !!!\n",modname);
2220 printk(KERN_INFO
2221 "%s: Number of Sangoma PCI cards exceeded maximum limit.\n",
2222 modname);
2223 printk(KERN_INFO "Please contact Sangoma Technologies\n");
2224 return 1;
2225 }
2226 pci_slot_ar[i] = hw->S514_slot_no;
2227 }
2228 return 0;
2229}
2230
2231static int pci_probe(sdlahw_t *hw)
2232{
2233
2234 unsigned char slot_no;
2235 int number_S514_cards = 0;
2236 u16 PCI_subsys_vendor;
2237 u16 PCI_card_type;
2238
2239 struct pci_dev *pci_dev = NULL;
2240 struct pci_bus *bus = NULL;
2241
2242 slot_no = 0;
2243
2244 while ((pci_dev = pci_find_device(V3_VENDOR_ID, V3_DEVICE_ID, pci_dev))
2245 != NULL) {
2246
2247 pci_read_config_word(pci_dev, PCI_SUBSYS_VENDOR_WORD,
2248 &PCI_subsys_vendor);
2249
2250 if(PCI_subsys_vendor != SANGOMA_SUBSYS_VENDOR)
2251 continue;
2252
2253 pci_read_config_word(pci_dev, PCI_CARD_TYPE,
2254 &PCI_card_type);
2255
2256 bus = pci_dev->bus;
2257
2258 /* A dual cpu card can support up to 4 physical connections,
2259 * where a single cpu card can support up to 2 physical
2260 * connections. The FT1 card can only support a single
2261 * connection, however we cannot distinguish between a Single
2262 * CPU card and an FT1 card. */
2263 if (PCI_card_type == S514_DUAL_CPU){
2264 number_S514_cards += 4;
2265 printk(KERN_INFO
2266 "wanpipe: S514-PCI card found, cpu(s) 2, bus #%d, slot #%d, irq #%d\n",
2267 bus->number,((pci_dev->devfn >> 3) & PCI_DEV_SLOT_MASK),
2268 pci_dev->irq);
2269 }else{
2270 number_S514_cards += 2;
2271 printk(KERN_INFO
2272 "wanpipe: S514-PCI card found, cpu(s) 1, bus #%d, slot #%d, irq #%d\n",
2273 bus->number,((pci_dev->devfn >> 3) & PCI_DEV_SLOT_MASK),
2274 pci_dev->irq);
2275 }
2276 }
2277
2278 return number_S514_cards;
2279
2280}
2281
2282
2283
2284EXPORT_SYMBOL(wanpipe_hw_probe);
2285
2286unsigned wanpipe_hw_probe(void)
2287{
2288 sdlahw_t hw;
2289 unsigned* opt = s508_port_options;
2290 unsigned cardno=0;
2291 int i;
2292
2293 memset(&hw, 0, sizeof(hw));
2294
2295 for (i = 1; i <= opt[0]; i++) {
2296 if (detect_s508(opt[i])){
2297 /* S508 card can support up to two physical links */
2298 cardno+=2;
2299 printk(KERN_INFO "wanpipe: S508-ISA card found, port 0x%x\n",opt[i]);
2300 }
2301 }
2302
2303 #ifdef CONFIG_PCI
2304 hw.S514_slot_no = 0;
2305 cardno += pci_probe(&hw);
2306 #else
2307 printk(KERN_INFO "wanpipe: Warning, Kernel not compiled for PCI support!\n");
2308 printk(KERN_INFO "wanpipe: PCI Hardware Probe Failed!\n");
2309 #endif
2310
2311 return cardno;
2312}
2313
2314/****** End *****************************************************************/
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-29 09:13:14 -0500