projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge with ../linux-2.6-smp
[deliverable/linux.git] / drivers / net / wan / sdladrv.c
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 */
163 static int sdla_detect (sdlahw_t* hw);
164 static int sdla_autodpm (sdlahw_t* hw);
165 static int sdla_setdpm (sdlahw_t* hw);
166 static int sdla_load (sdlahw_t* hw, sfm_t* sfm, unsigned len);
167 static int sdla_init (sdlahw_t* hw);
168 static unsigned long sdla_memtest (sdlahw_t* hw);
169 static int sdla_bootcfg (sdlahw_t* hw, sfm_info_t* sfminfo);
170 static unsigned char make_config_byte (sdlahw_t* hw);
171 static int sdla_start (sdlahw_t* hw, unsigned addr);
172
173 static int init_s502a (sdlahw_t* hw);
174 static int init_s502e (sdlahw_t* hw);
175 static int init_s503 (sdlahw_t* hw);
176 static int init_s507 (sdlahw_t* hw);
177 static int init_s508 (sdlahw_t* hw);
178
179 static int detect_s502a (int port);
180 static int detect_s502e (int port);
181 static int detect_s503 (int port);
182 static int detect_s507 (int port);
183 static int detect_s508 (int port);
184 static int detect_s514 (sdlahw_t* hw);
185 static int find_s514_adapter(sdlahw_t* hw, char find_first_S514_card);
186
187 /* Miscellaneous functions */
188 static void peek_by_4 (unsigned long src, void* buf, unsigned len);
189 static void poke_by_4 (unsigned long dest, void* buf, unsigned len);
190 static int calibrate_delay (int mks);
191 static int get_option_index (unsigned* optlist, unsigned optval);
192 static unsigned check_memregion (void* ptr, unsigned len);
193 static unsigned test_memregion (void* ptr, unsigned len);
194 static unsigned short checksum (unsigned char* buf, unsigned len);
195 static int init_pci_slot(sdlahw_t *);
196
197 static int pci_probe(sdlahw_t *hw);
198
199 /****** Global Data **********************************************************
200 * Note: All data must be explicitly initialized!!!
201 */
202
203 static struct pci_device_id sdladrv_pci_tbl[] = {
204 { V3_VENDOR_ID, V3_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, },
205 { } /* Terminating entry */
206 };
207 MODULE_DEVICE_TABLE(pci, sdladrv_pci_tbl);
208
209 MODULE_LICENSE("GPL");
210
211 /* private data */
212 static char modname[] = "sdladrv";
213 static char fullname[] = "SDLA Support Module";
214 static char copyright[] = "(c) 1995-1999 Sangoma Technologies Inc.";
215 static 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 */
221 static unsigned s502_port_options[] =
222 { 4, 0x250, 0x300, 0x350, 0x360 }
223 ;
224 static unsigned s503_port_options[] =
225 { 8, 0x250, 0x254, 0x300, 0x304, 0x350, 0x354, 0x360, 0x364 }
226 ;
227 static unsigned s508_port_options[] =
228 { 8, 0x250, 0x270, 0x280, 0x300, 0x350, 0x360, 0x380, 0x390 }
229 ;
230
231 static unsigned s502a_irq_options[] = { 0 };
232 static unsigned s502e_irq_options[] = { 4, 2, 3, 5, 7 };
233 static unsigned s503_irq_options[] = { 5, 2, 3, 4, 5, 7 };
234 static unsigned s508_irq_options[] = { 8, 3, 4, 5, 7, 10, 11, 12, 15 };
235
236 static 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 };
244 static 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 };
252 static 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 /*
262 static unsigned s502_dpmsize_options[] = { 2, 0x2000, 0x10000 };
263 static unsigned s507_dpmsize_options[] = { 2, 0x2000, 0x4000 };
264 static unsigned s508_dpmsize_options[] = { 1, 0x2000 };
265 */
266
267 static unsigned s502a_pclk_options[] = { 2, 3600, 7200 };
268 static unsigned s502e_pclk_options[] = { 5, 3600, 5000, 7200, 8000, 10000 };
269 static unsigned s503_pclk_options[] = { 3, 7200, 8000, 10000 };
270 static unsigned s507_pclk_options[] = { 1, 12288 };
271 static unsigned s508_pclk_options[] = { 1, 16000 };
272
273 /* Host memory control register masks */
274 static 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 };
281 static 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 };
288 static 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 };
295 static 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
303 static unsigned char s507_irqmask[] =
304 {
305 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xE0
306 };
307
308 static 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
323 static 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 */
347 static void __exit sdladrv_cleanup(void)
348 {
349 }
350
351 module_init(sdladrv_init);
352 module_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
368 EXPORT_SYMBOL(sdla_setup);
369
370 int 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
513 EXPORT_SYMBOL(sdla_down);
514
515 int 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
584 EXPORT_SYMBOL(sdla_mapmem);
585
586 int 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
645 EXPORT_SYMBOL(sdla_inten);
646
647 int sdla_inten (sdlahw_t* hw)
648 {
649 unsigned port = hw->port;
650 int tmp, i;
651
652 switch (hw->type) {
653 case SDLA_S502E:
654 /* Note thar interrupt control operations on S502E are allowed
655 * only if CPU is enabled (bit 0 of status register is set).
656 */
657 if (_INB(port) & 0x01) {
658 _OUTB(port, 0x02); /* bit1 = 1, bit2 = 0 */
659 _OUTB(port, 0x06); /* bit1 = 1, bit2 = 1 */
660 hw->regs[0] = 0x06;
661 }
662 else return -EIO;
663 break;
664
665 case SDLA_S503:
666 tmp = hw->regs[0] | 0x04;
667 _OUTB(port, tmp);
668 hw->regs[0] = tmp; /* update mirror */
669 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
670 if (!(_INB(port) & 0x02)) /* verify */
671 return -EIO;
672 break;
673
674 case SDLA_S508:
675 tmp = hw->regs[0] | 0x10;
676 _OUTB(port, tmp);
677 hw->regs[0] = tmp; /* update mirror */
678 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
679 if (!(_INB(port + 1) & 0x10)) /* verify */
680 return -EIO;
681 break;
682
683 case SDLA_S502A:
684 case SDLA_S507:
685 break;
686
687 case SDLA_S514:
688 break;
689
690 default:
691 return -EINVAL;
692
693 }
694 return 0;
695 }
696
697 /*============================================================================
698 * Disable interrupt generation.
699 */
700
701 EXPORT_SYMBOL(sdla_intde);
702
703 int sdla_intde (sdlahw_t* hw)
704 {
705 unsigned port = hw->port;
706 int tmp, i;
707
708 switch (hw->type) {
709 case SDLA_S502E:
710 /* Notes:
711 * 1) interrupt control operations are allowed only if CPU is
712 * enabled (bit 0 of status register is set).
713 * 2) disabling interrupts using bit 1 of control register
714 * causes IRQ line go high, therefore we are going to use
715 * 0x04 instead: lower it to inhibit interrupts to PC.
716 */
717 if (_INB(port) & 0x01) {
718 _OUTB(port, hw->regs[0] & ~0x04);
719 hw->regs[0] &= ~0x04;
720 }
721 else return -EIO;
722 break;
723
724 case SDLA_S503:
725 tmp = hw->regs[0] & ~0x04;
726 _OUTB(port, tmp);
727 hw->regs[0] = tmp; /* update mirror */
728 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
729 if (_INB(port) & 0x02) /* verify */
730 return -EIO;
731 break;
732
733 case SDLA_S508:
734 tmp = hw->regs[0] & ~0x10;
735 _OUTB(port, tmp);
736 hw->regs[0] = tmp; /* update mirror */
737 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
738 if (_INB(port) & 0x10) /* verify */
739 return -EIO;
740 break;
741
742 case SDLA_S502A:
743 case SDLA_S507:
744 break;
745
746 default:
747 return -EINVAL;
748 }
749 return 0;
750 }
751
752 /*============================================================================
753 * Acknowledge SDLA hardware interrupt.
754 */
755
756 EXPORT_SYMBOL(sdla_intack);
757
758 int sdla_intack (sdlahw_t* hw)
759 {
760 unsigned port = hw->port;
761 int tmp;
762
763 switch (hw->type) {
764 case SDLA_S502E:
765 /* To acknoledge hardware interrupt we have to toggle bit 3 of
766 * control register: \_/
767 * Note that interrupt control operations on S502E are allowed
768 * only if CPU is enabled (bit 1 of status register is set).
769 */
770 if (_INB(port) & 0x01) {
771 tmp = hw->regs[0] & ~0x04;
772 _OUTB(port, tmp);
773 tmp |= 0x04;
774 _OUTB(port, tmp);
775 hw->regs[0] = tmp;
776 }
777 else return -EIO;
778 break;
779
780 case SDLA_S503:
781 if (_INB(port) & 0x04) {
782 tmp = hw->regs[0] & ~0x08;
783 _OUTB(port, tmp);
784 tmp |= 0x08;
785 _OUTB(port, tmp);
786 hw->regs[0] = tmp;
787 }
788 break;
789
790 case SDLA_S502A:
791 case SDLA_S507:
792 case SDLA_S508:
793 break;
794
795 default:
796 return -EINVAL;
797 }
798 return 0;
799 }
800
801
802 /*============================================================================
803 * Acknowledge S514 hardware interrupt.
804 */
805
806 EXPORT_SYMBOL(S514_intack);
807
808 void S514_intack (sdlahw_t* hw, u32 int_status)
809 {
810 pci_write_config_dword(hw->pci_dev, PCI_INT_STATUS, int_status);
811 }
812
813
814 /*============================================================================
815 * Read the S514 hardware interrupt status.
816 */
817
818 EXPORT_SYMBOL(read_S514_int_stat);
819
820 void read_S514_int_stat (sdlahw_t* hw, u32* int_status)
821 {
822 pci_read_config_dword(hw->pci_dev, PCI_INT_STATUS, int_status);
823 }
824
825
826 /*============================================================================
827 * Generate an interrupt to adapter's CPU.
828 */
829
830 EXPORT_SYMBOL(sdla_intr);
831
832 int sdla_intr (sdlahw_t* hw)
833 {
834 unsigned port = hw->port;
835
836 switch (hw->type) {
837 case SDLA_S502A:
838 if (!(_INB(port) & 0x40)) {
839 _OUTB(port, 0x10); /* issue NMI to CPU */
840 hw->regs[0] = 0x10;
841 }
842 else return -EIO;
843 break;
844
845 case SDLA_S507:
846 if ((_INB(port) & 0x06) == 0x06) {
847 _OUTB(port + 3, 0);
848 }
849 else return -EIO;
850 break;
851
852 case SDLA_S508:
853 if (_INB(port + 1) & 0x02) {
854 _OUTB(port, 0x08);
855 }
856 else return -EIO;
857 break;
858
859 case SDLA_S502E:
860 case SDLA_S503:
861 default:
862 return -EINVAL;
863 }
864 return 0;
865 }
866
867 /*============================================================================
868 * Execute Adapter Command.
869 * o Set exec flag.
870 * o Busy-wait until flag is reset.
871 * o Return number of loops made, or 0 if command timed out.
872 */
873
874 EXPORT_SYMBOL(sdla_exec);
875
876 int sdla_exec (void* opflag)
877 {
878 volatile unsigned char* flag = opflag;
879 unsigned long tstop;
880 int nloops;
881
882 if(readb(flag) != 0x00) {
883 printk(KERN_INFO
884 "WANPIPE: opp flag set on entry to sdla_exec\n");
885 return 0;
886 }
887
888 writeb(0x01, flag);
889
890 tstop = SYSTEM_TICK + EXEC_TIMEOUT;
891
892 for (nloops = 1; (readb(flag) == 0x01); ++ nloops) {
893 unsigned delay = exec_idle;
894 while (-- delay); /* delay */
895 if (SYSTEM_TICK > tstop) return 0; /* time is up! */
896 }
897 return nloops;
898 }
899
900 /*============================================================================
901 * Read absolute adapter memory.
902 * Transfer data from adapter's memory to data buffer.
903 *
904 * Note:
905 * Care should be taken when crossing dual-port memory window boundary.
906 * This function is not atomic, so caller must disable interrupt if
907 * interrupt routines are accessing adapter shared memory.
908 */
909
910 EXPORT_SYMBOL(sdla_peek);
911
912 int sdla_peek (sdlahw_t* hw, unsigned long addr, void* buf, unsigned len)
913 {
914
915 if (addr + len > hw->memory) /* verify arguments */
916 return -EINVAL;
917
918 if(hw->type == SDLA_S514) { /* copy data for the S514 adapter */
919 peek_by_4 ((unsigned long)hw->dpmbase + addr, buf, len);
920 return 0;
921 }
922
923 else { /* copy data for the S508 adapter */
924 unsigned long oldvec = hw->vector;
925 unsigned winsize = hw->dpmsize;
926 unsigned curpos, curlen; /* current offset and block size */
927 unsigned long curvec; /* current DPM window vector */
928 int err = 0;
929
930 while (len && !err) {
931 curpos = addr % winsize; /* current window offset */
932 curvec = addr - curpos; /* current window vector */
933 curlen = (len > (winsize - curpos)) ?
934 (winsize - curpos) : len;
935 /* Relocate window and copy block of data */
936 err = sdla_mapmem(hw, curvec);
937 peek_by_4 ((unsigned long)hw->dpmbase + curpos, buf,
938 curlen);
939 addr += curlen;
940 buf = (char*)buf + curlen;
941 len -= curlen;
942 }
943
944 /* Restore DPM window position */
945 sdla_mapmem(hw, oldvec);
946 return err;
947 }
948 }
949
950
951 /*============================================================================
952 * Read data from adapter's memory to a data buffer in 4-byte chunks.
953 * Note that we ensure that the SDLA memory address is on a 4-byte boundary
954 * before we begin moving the data in 4-byte chunks.
955 */
956
957 static void peek_by_4 (unsigned long src, void* buf, unsigned len)
958 {
959
960 /* byte copy data until we get to a 4-byte boundary */
961 while (len && (src & 0x03)) {
962 *(char *)buf ++ = readb(src ++);
963 len --;
964 }
965
966 /* copy data in 4-byte chunks */
967 while (len >= 4) {
968 *(unsigned long *)buf = readl(src);
969 buf += 4;
970 src += 4;
971 len -= 4;
972 }
973
974 /* byte copy any remaining data */
975 while (len) {
976 *(char *)buf ++ = readb(src ++);
977 len --;
978 }
979 }
980
981
982 /*============================================================================
983 * Write Absolute Adapter Memory.
984 * Transfer data from data buffer to adapter's memory.
985 *
986 * Note:
987 * Care should be taken when crossing dual-port memory window boundary.
988 * This function is not atomic, so caller must disable interrupt if
989 * interrupt routines are accessing adapter shared memory.
990 */
991
992 EXPORT_SYMBOL(sdla_poke);
993
994 int sdla_poke (sdlahw_t* hw, unsigned long addr, void* buf, unsigned len)
995 {
996
997 if (addr + len > hw->memory) /* verify arguments */
998 return -EINVAL;
999
1000 if(hw->type == SDLA_S514) { /* copy data for the S514 adapter */
1001 poke_by_4 ((unsigned long)hw->dpmbase + addr, buf, len);
1002 return 0;
1003 }
1004
1005 else { /* copy data for the S508 adapter */
1006 unsigned long oldvec = hw->vector;
1007 unsigned winsize = hw->dpmsize;
1008 unsigned curpos, curlen; /* current offset and block size */
1009 unsigned long curvec; /* current DPM window vector */
1010 int err = 0;
1011
1012 while (len && !err) {
1013 curpos = addr % winsize; /* current window offset */
1014 curvec = addr - curpos; /* current window vector */
1015 curlen = (len > (winsize - curpos)) ?
1016 (winsize - curpos) : len;
1017 /* Relocate window and copy block of data */
1018 sdla_mapmem(hw, curvec);
1019 poke_by_4 ((unsigned long)hw->dpmbase + curpos, buf,
1020 curlen);
1021 addr += curlen;
1022 buf = (char*)buf + curlen;
1023 len -= curlen;
1024 }
1025
1026 /* Restore DPM window position */
1027 sdla_mapmem(hw, oldvec);
1028 return err;
1029 }
1030 }
1031
1032
1033 /*============================================================================
1034 * Write from a data buffer to adapter's memory in 4-byte chunks.
1035 * Note that we ensure that the SDLA memory address is on a 4-byte boundary
1036 * before we begin moving the data in 4-byte chunks.
1037 */
1038
1039 static void poke_by_4 (unsigned long dest, void* buf, unsigned len)
1040 {
1041
1042 /* byte copy data until we get to a 4-byte boundary */
1043 while (len && (dest & 0x03)) {
1044 writeb (*(char *)buf ++, dest ++);
1045 len --;
1046 }
1047
1048 /* copy data in 4-byte chunks */
1049 while (len >= 4) {
1050 writel (*(unsigned long *)buf, dest);
1051 dest += 4;
1052 buf += 4;
1053 len -= 4;
1054 }
1055
1056 /* byte copy any remaining data */
1057 while (len) {
1058 writeb (*(char *)buf ++ , dest ++);
1059 len --;
1060 }
1061 }
1062
1063
1064 #ifdef DONT_COMPIPLE_THIS
1065 #endif /* DONT_COMPIPLE_THIS */
1066
1067 /****** Hardware-Specific Functions *****************************************/
1068
1069 /*============================================================================
1070 * Detect adapter type.
1071 * o if adapter type is specified then call detection routine for that adapter
1072 * type. Otherwise call detection routines for every adapter types until
1073 * adapter is detected.
1074 *
1075 * Notes:
1076 * 1) Detection tests are destructive! Adapter will be left in shutdown state
1077 * after the test.
1078 */
1079 static int sdla_detect (sdlahw_t* hw)
1080 {
1081 unsigned port = hw->port;
1082 int err = 0;
1083
1084 if (!port && (hw->type != SDLA_S514))
1085 return -EFAULT;
1086
1087 switch (hw->type) {
1088 case SDLA_S502A:
1089 if (!detect_s502a(port)) err = -ENODEV;
1090 break;
1091
1092 case SDLA_S502E:
1093 if (!detect_s502e(port)) err = -ENODEV;
1094 break;
1095
1096 case SDLA_S503:
1097 if (!detect_s503(port)) err = -ENODEV;
1098 break;
1099
1100 case SDLA_S507:
1101 if (!detect_s507(port)) err = -ENODEV;
1102 break;
1103
1104 case SDLA_S508:
1105 if (!detect_s508(port)) err = -ENODEV;
1106 break;
1107
1108 case SDLA_S514:
1109 if (!detect_s514(hw)) err = -ENODEV;
1110 break;
1111
1112 default:
1113 if (detect_s502a(port))
1114 hw->type = SDLA_S502A;
1115 else if (detect_s502e(port))
1116 hw->type = SDLA_S502E;
1117 else if (detect_s503(port))
1118 hw->type = SDLA_S503;
1119 else if (detect_s507(port))
1120 hw->type = SDLA_S507;
1121 else if (detect_s508(port))
1122 hw->type = SDLA_S508;
1123 else err = -ENODEV;
1124 }
1125 return err;
1126 }
1127
1128 /*============================================================================
1129 * Autoselect memory region.
1130 * o try all available DMP address options from the top down until success.
1131 */
1132 static int sdla_autodpm (sdlahw_t* hw)
1133 {
1134 int i, err = -EINVAL;
1135 unsigned* opt;
1136
1137 switch (hw->type) {
1138 case SDLA_S502A:
1139 opt = s502a_dpmbase_options;
1140 break;
1141
1142 case SDLA_S502E:
1143 case SDLA_S503:
1144 case SDLA_S508:
1145 opt = s508_dpmbase_options;
1146 break;
1147
1148 case SDLA_S507:
1149 opt = s507_dpmbase_options;
1150 break;
1151
1152 default:
1153 return -EINVAL;
1154 }
1155
1156 /* Start testing from 8th position, address
1157 * 0xC8000 from the 508 address table.
1158 * We don't want to test A**** addresses, since
1159 * they are usually used for Video */
1160 for (i = 8; i <= opt[0] && err; i++) {
1161 hw->dpmbase = phys_to_virt(opt[i]);
1162 err = sdla_setdpm(hw);
1163 }
1164 return err;
1165 }
1166
1167 /*============================================================================
1168 * Set up adapter dual-port memory window.
1169 * o shut down adapter
1170 * o make sure that no physical memory exists in this region, i.e entire
1171 * region reads 0xFF and is not writable when adapter is shut down.
1172 * o initialize adapter hardware
1173 * o make sure that region is usable with SDLA card, i.e. we can write to it
1174 * when adapter is configured.
1175 */
1176 static int sdla_setdpm (sdlahw_t* hw)
1177 {
1178 int err;
1179
1180 /* Shut down card and verify memory region */
1181 sdla_down(hw);
1182 if (check_memregion(hw->dpmbase, hw->dpmsize))
1183 return -EINVAL;
1184
1185 /* Initialize adapter and test on-board memory segment by segment.
1186 * If memory size appears to be less than shared memory window size,
1187 * assume that memory region is unusable.
1188 */
1189 err = sdla_init(hw);
1190 if (err) return err;
1191
1192 if (sdla_memtest(hw) < hw->dpmsize) { /* less than window size */
1193 sdla_down(hw);
1194 return -EIO;
1195 }
1196 sdla_mapmem(hw, 0L); /* set window vector at bottom */
1197 return 0;
1198 }
1199
1200 /*============================================================================
1201 * Load adapter from the memory image of the SDLA firmware module.
1202 * o verify firmware integrity and compatibility
1203 * o start adapter up
1204 */
1205 static int sdla_load (sdlahw_t* hw, sfm_t* sfm, unsigned len)
1206 {
1207
1208 int i;
1209
1210 /* Verify firmware signature */
1211 if (strcmp(sfm->signature, SFM_SIGNATURE)) {
1212 printk(KERN_INFO "%s: not SDLA firmware!\n",
1213 modname);
1214 return -EINVAL;
1215 }
1216
1217 /* Verify firmware module format version */
1218 if (sfm->version != SFM_VERSION) {
1219 printk(KERN_INFO
1220 "%s: firmware format %u rejected! Expecting %u.\n",
1221 modname, sfm->version, SFM_VERSION);
1222 return -EINVAL;
1223 }
1224
1225 /* Verify firmware module length and checksum */
1226 if ((len - offsetof(sfm_t, image) != sfm->info.codesize) ||
1227 (checksum((void*)&sfm->info,
1228 sizeof(sfm_info_t) + sfm->info.codesize) != sfm->checksum)) {
1229 printk(KERN_INFO "%s: firmware corrupted!\n", modname);
1230 return -EINVAL;
1231 }
1232
1233 /* Announce */
1234 printk(KERN_INFO "%s: loading %s (ID=%u)...\n", modname,
1235 (sfm->descr[0] != '\0') ? sfm->descr : "unknown firmware",
1236 sfm->info.codeid);
1237
1238 if(hw->type == SDLA_S514)
1239 printk(KERN_INFO "%s: loading S514 adapter, CPU %c\n",
1240 modname, hw->S514_cpu_no[0]);
1241
1242 /* Scan through the list of compatible adapters and make sure our
1243 * adapter type is listed.
1244 */
1245 for (i = 0;
1246 (i < SFM_MAX_SDLA) && (sfm->info.adapter[i] != hw->type);
1247 ++i);
1248
1249 if (i == SFM_MAX_SDLA) {
1250 printk(KERN_INFO "%s: firmware is not compatible with S%u!\n",
1251 modname, hw->type);
1252 return -EINVAL;
1253 }
1254
1255
1256 /* Make sure there is enough on-board memory */
1257 if (hw->memory < sfm->info.memsize) {
1258 printk(KERN_INFO
1259 "%s: firmware needs %lu bytes of on-board memory!\n",
1260 modname, sfm->info.memsize);
1261 return -EINVAL;
1262 }
1263
1264 /* Move code onto adapter */
1265 if (sdla_poke(hw, sfm->info.codeoffs, sfm->image, sfm->info.codesize)) {
1266 printk(KERN_INFO "%s: failed to load code segment!\n",
1267 modname);
1268 return -EIO;
1269 }
1270
1271 /* Prepare boot-time configuration data and kick-off CPU */
1272 sdla_bootcfg(hw, &sfm->info);
1273 if (sdla_start(hw, sfm->info.startoffs)) {
1274 printk(KERN_INFO "%s: Damn... Adapter won't start!\n",
1275 modname);
1276 return -EIO;
1277 }
1278
1279 /* position DPM window over the mailbox and enable interrupts */
1280 if (sdla_mapmem(hw, sfm->info.winoffs) || sdla_inten(hw)) {
1281 printk(KERN_INFO "%s: adapter hardware failure!\n",
1282 modname);
1283 return -EIO;
1284 }
1285 hw->fwid = sfm->info.codeid; /* set firmware ID */
1286 return 0;
1287 }
1288
1289 /*============================================================================
1290 * Initialize SDLA hardware: setup memory window, IRQ, etc.
1291 */
1292 static int sdla_init (sdlahw_t* hw)
1293 {
1294 int i;
1295
1296 for (i = 0; i < SDLA_MAXIORANGE; ++i)
1297 hw->regs[i] = 0;
1298
1299 switch (hw->type) {
1300 case SDLA_S502A: return init_s502a(hw);
1301 case SDLA_S502E: return init_s502e(hw);
1302 case SDLA_S503: return init_s503(hw);
1303 case SDLA_S507: return init_s507(hw);
1304 case SDLA_S508: return init_s508(hw);
1305 }
1306 return -EINVAL;
1307 }
1308
1309 /*============================================================================
1310 * Test adapter on-board memory.
1311 * o slide DPM window from the bottom up and test adapter memory segment by
1312 * segment.
1313 * Return adapter memory size.
1314 */
1315 static unsigned long sdla_memtest (sdlahw_t* hw)
1316 {
1317 unsigned long memsize;
1318 unsigned winsize;
1319
1320 for (memsize = 0, winsize = hw->dpmsize;
1321 !sdla_mapmem(hw, memsize) &&
1322 (test_memregion(hw->dpmbase, winsize) == winsize)
1323 ;
1324 memsize += winsize)
1325 ;
1326 hw->memory = memsize;
1327 return memsize;
1328 }
1329
1330 /*============================================================================
1331 * Prepare boot-time firmware configuration data.
1332 * o position DPM window
1333 * o initialize configuration data area
1334 */
1335 static int sdla_bootcfg (sdlahw_t* hw, sfm_info_t* sfminfo)
1336 {
1337 unsigned char* data;
1338
1339 if (!sfminfo->datasize) return 0; /* nothing to do */
1340
1341 if (sdla_mapmem(hw, sfminfo->dataoffs) != 0)
1342 return -EIO;
1343
1344 if(hw->type == SDLA_S514)
1345 data = (void*)(hw->dpmbase + sfminfo->dataoffs);
1346 else
1347 data = (void*)((u8 *)hw->dpmbase +
1348 (sfminfo->dataoffs - hw->vector));
1349
1350 memset_io (data, 0, sfminfo->datasize);
1351
1352 writeb (make_config_byte(hw), &data[0x00]);
1353
1354 switch (sfminfo->codeid) {
1355 case SFID_X25_502:
1356 case SFID_X25_508:
1357 writeb (3, &data[0x01]); /* T1 timer */
1358 writeb (10, &data[0x03]); /* N2 */
1359 writeb (7, &data[0x06]); /* HDLC window size */
1360 writeb (1, &data[0x0B]); /* DTE */
1361 writeb (2, &data[0x0C]); /* X.25 packet window size */
1362 writew (128, &data[0x0D]); /* default X.25 data size */
1363 writew (128, &data[0x0F]); /* maximum X.25 data size */
1364 break;
1365 }
1366 return 0;
1367 }
1368
1369 /*============================================================================
1370 * Prepare configuration byte identifying adapter type and CPU clock rate.
1371 */
1372 static unsigned char make_config_byte (sdlahw_t* hw)
1373 {
1374 unsigned char byte = 0;
1375
1376 switch (hw->pclk) {
1377 case 5000: byte = 0x01; break;
1378 case 7200: byte = 0x02; break;
1379 case 8000: byte = 0x03; break;
1380 case 10000: byte = 0x04; break;
1381 case 16000: byte = 0x05; break;
1382 }
1383
1384 switch (hw->type) {
1385 case SDLA_S502E: byte |= 0x80; break;
1386 case SDLA_S503: byte |= 0x40; break;
1387 }
1388 return byte;
1389 }
1390
1391 /*============================================================================
1392 * Start adapter's CPU.
1393 * o calculate a pointer to adapter's cold boot entry point
1394 * o position DPM window
1395 * o place boot instruction (jp addr) at cold boot entry point
1396 * o start CPU
1397 */
1398 static int sdla_start (sdlahw_t* hw, unsigned addr)
1399 {
1400 unsigned port = hw->port;
1401 unsigned char *bootp;
1402 int err, tmp, i;
1403
1404 if (!port && (hw->type != SDLA_S514)) return -EFAULT;
1405
1406 switch (hw->type) {
1407 case SDLA_S502A:
1408 bootp = hw->dpmbase;
1409 bootp += 0x66;
1410 break;
1411
1412 case SDLA_S502E:
1413 case SDLA_S503:
1414 case SDLA_S507:
1415 case SDLA_S508:
1416 case SDLA_S514:
1417 bootp = hw->dpmbase;
1418 break;
1419
1420 default:
1421 return -EINVAL;
1422 }
1423
1424 err = sdla_mapmem(hw, 0);
1425 if (err) return err;
1426
1427 writeb (0xC3, bootp); /* Z80: 'jp' opcode */
1428 bootp ++;
1429 writew (addr, bootp);
1430
1431 switch (hw->type) {
1432 case SDLA_S502A:
1433 _OUTB(port, 0x10); /* issue NMI to CPU */
1434 hw->regs[0] = 0x10;
1435 break;
1436
1437 case SDLA_S502E:
1438 _OUTB(port + 3, 0x01); /* start CPU */
1439 hw->regs[3] = 0x01;
1440 for (i = 0; i < SDLA_IODELAY; ++i);
1441 if (_INB(port) & 0x01) { /* verify */
1442 /*
1443 * Enabling CPU changes functionality of the
1444 * control register, so we have to reset its
1445 * mirror.
1446 */
1447 _OUTB(port, 0); /* disable interrupts */
1448 hw->regs[0] = 0;
1449 }
1450 else return -EIO;
1451 break;
1452
1453 case SDLA_S503:
1454 tmp = hw->regs[0] | 0x09; /* set bits 0 and 3 */
1455 _OUTB(port, tmp);
1456 hw->regs[0] = tmp; /* update mirror */
1457 for (i = 0; i < SDLA_IODELAY; ++i);
1458 if (!(_INB(port) & 0x01)) /* verify */
1459 return -EIO;
1460 break;
1461
1462 case SDLA_S507:
1463 tmp = hw->regs[0] | 0x02;
1464 _OUTB(port, tmp);
1465 hw->regs[0] = tmp; /* update mirror */
1466 for (i = 0; i < SDLA_IODELAY; ++i);
1467 if (!(_INB(port) & 0x04)) /* verify */
1468 return -EIO;
1469 break;
1470
1471 case SDLA_S508:
1472 tmp = hw->regs[0] | 0x02;
1473 _OUTB(port, tmp);
1474 hw->regs[0] = tmp; /* update mirror */
1475 for (i = 0; i < SDLA_IODELAY; ++i);
1476 if (!(_INB(port + 1) & 0x02)) /* verify */
1477 return -EIO;
1478 break;
1479
1480 case SDLA_S514:
1481 writeb (S514_CPU_START, hw->vector);
1482 break;
1483
1484 default:
1485 return -EINVAL;
1486 }
1487 return 0;
1488 }
1489
1490 /*============================================================================
1491 * Initialize S502A adapter.
1492 */
1493 static int init_s502a (sdlahw_t* hw)
1494 {
1495 unsigned port = hw->port;
1496 int tmp, i;
1497
1498 if (!detect_s502a(port))
1499 return -ENODEV;
1500
1501 hw->regs[0] = 0x08;
1502 hw->regs[1] = 0xFF;
1503
1504 /* Verify configuration options */
1505 i = get_option_index(s502a_dpmbase_options, virt_to_phys(hw->dpmbase));
1506 if (i == 0)
1507 return -EINVAL;
1508
1509 tmp = s502a_hmcr[i - 1];
1510 switch (hw->dpmsize) {
1511 case 0x2000:
1512 tmp |= 0x01;
1513 break;
1514
1515 case 0x10000L:
1516 break;
1517
1518 default:
1519 return -EINVAL;
1520 }
1521
1522 /* Setup dual-port memory window (this also enables memory access) */
1523 _OUTB(port + 1, tmp);
1524 hw->regs[1] = tmp;
1525 hw->regs[0] = 0x08;
1526 return 0;
1527 }
1528
1529 /*============================================================================
1530 * Initialize S502E adapter.
1531 */
1532 static int init_s502e (sdlahw_t* hw)
1533 {
1534 unsigned port = hw->port;
1535 int tmp, i;
1536
1537 if (!detect_s502e(port))
1538 return -ENODEV;
1539
1540 /* Verify configuration options */
1541 i = get_option_index(s508_dpmbase_options, virt_to_phys(hw->dpmbase));
1542 if (i == 0)
1543 return -EINVAL;
1544
1545 tmp = s502e_hmcr[i - 1];
1546 switch (hw->dpmsize) {
1547 case 0x2000:
1548 tmp |= 0x01;
1549 break;
1550
1551 case 0x10000L:
1552 break;
1553
1554 default:
1555 return -EINVAL;
1556 }
1557
1558 /* Setup dual-port memory window */
1559 _OUTB(port + 1, tmp);
1560 hw->regs[1] = tmp;
1561
1562 /* Enable memory access */
1563 _OUTB(port, 0x02);
1564 hw->regs[0] = 0x02;
1565 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1566 return (_INB(port) & 0x02) ? 0 : -EIO;
1567 }
1568
1569 /*============================================================================
1570 * Initialize S503 adapter.
1571 * ---------------------------------------------------------------------------
1572 */
1573 static int init_s503 (sdlahw_t* hw)
1574 {
1575 unsigned port = hw->port;
1576 int tmp, i;
1577
1578 if (!detect_s503(port))
1579 return -ENODEV;
1580
1581 /* Verify configuration options */
1582 i = get_option_index(s508_dpmbase_options, virt_to_phys(hw->dpmbase));
1583 if (i == 0)
1584 return -EINVAL;
1585
1586 tmp = s502e_hmcr[i - 1];
1587 switch (hw->dpmsize) {
1588 case 0x2000:
1589 tmp |= 0x01;
1590 break;
1591
1592 case 0x10000L:
1593 break;
1594
1595 default:
1596 return -EINVAL;
1597 }
1598
1599 /* Setup dual-port memory window */
1600 _OUTB(port + 1, tmp);
1601 hw->regs[1] = tmp;
1602
1603 /* Enable memory access */
1604 _OUTB(port, 0x02);
1605 hw->regs[0] = 0x02; /* update mirror */
1606 return 0;
1607 }
1608
1609 /*============================================================================
1610 * Initialize S507 adapter.
1611 */
1612 static int init_s507 (sdlahw_t* hw)
1613 {
1614 unsigned port = hw->port;
1615 int tmp, i;
1616
1617 if (!detect_s507(port))
1618 return -ENODEV;
1619
1620 /* Verify configuration options */
1621 i = get_option_index(s507_dpmbase_options, virt_to_phys(hw->dpmbase));
1622 if (i == 0)
1623 return -EINVAL;
1624
1625 tmp = s507_hmcr[i - 1];
1626 switch (hw->dpmsize) {
1627 case 0x2000:
1628 tmp |= 0x01;
1629 break;
1630
1631 case 0x10000L:
1632 break;
1633
1634 default:
1635 return -EINVAL;
1636 }
1637
1638 /* Enable adapter's logic */
1639 _OUTB(port, 0x01);
1640 hw->regs[0] = 0x01;
1641 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1642 if (!(_INB(port) & 0x20))
1643 return -EIO;
1644
1645 /* Setup dual-port memory window */
1646 _OUTB(port + 1, tmp);
1647 hw->regs[1] = tmp;
1648
1649 /* Enable memory access */
1650 tmp = hw->regs[0] | 0x04;
1651 if (hw->irq) {
1652 i = get_option_index(s508_irq_options, hw->irq);
1653 if (i) tmp |= s507_irqmask[i - 1];
1654 }
1655 _OUTB(port, tmp);
1656 hw->regs[0] = tmp; /* update mirror */
1657 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1658 return (_INB(port) & 0x08) ? 0 : -EIO;
1659 }
1660
1661 /*============================================================================
1662 * Initialize S508 adapter.
1663 */
1664 static int init_s508 (sdlahw_t* hw)
1665 {
1666 unsigned port = hw->port;
1667 int tmp, i;
1668
1669 if (!detect_s508(port))
1670 return -ENODEV;
1671
1672 /* Verify configuration options */
1673 i = get_option_index(s508_dpmbase_options, virt_to_phys(hw->dpmbase));
1674 if (i == 0)
1675 return -EINVAL;
1676
1677 /* Setup memory configuration */
1678 tmp = s508_hmcr[i - 1];
1679 _OUTB(port + 1, tmp);
1680 hw->regs[1] = tmp;
1681
1682 /* Enable memory access */
1683 _OUTB(port, 0x04);
1684 hw->regs[0] = 0x04; /* update mirror */
1685 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1686 return (_INB(port + 1) & 0x04) ? 0 : -EIO;
1687 }
1688
1689 /*============================================================================
1690 * Detect S502A adapter.
1691 * Following tests are used to detect S502A adapter:
1692 * 1. All registers other than status (BASE) should read 0xFF
1693 * 2. After writing 00001000b to control register, status register should
1694 * read 01000000b.
1695 * 3. After writing 0 to control register, status register should still
1696 * read 01000000b.
1697 * 4. After writing 00000100b to control register, status register should
1698 * read 01000100b.
1699 * Return 1 if detected o.k. or 0 if failed.
1700 * Note: This test is destructive! Adapter will be left in shutdown
1701 * state after the test.
1702 */
1703 static int detect_s502a (int port)
1704 {
1705 int i, j;
1706
1707 if (!get_option_index(s502_port_options, port))
1708 return 0;
1709
1710 for (j = 1; j < SDLA_MAXIORANGE; ++j) {
1711 if (_INB(port + j) != 0xFF)
1712 return 0;
1713 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1714 }
1715
1716 _OUTB(port, 0x08); /* halt CPU */
1717 _OUTB(port, 0x08);
1718 _OUTB(port, 0x08);
1719 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1720 if (_INB(port) != 0x40)
1721 return 0;
1722 _OUTB(port, 0x00);
1723 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1724 if (_INB(port) != 0x40)
1725 return 0;
1726 _OUTB(port, 0x04);
1727 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1728 if (_INB(port) != 0x44)
1729 return 0;
1730
1731 /* Reset adapter */
1732 _OUTB(port, 0x08);
1733 _OUTB(port, 0x08);
1734 _OUTB(port, 0x08);
1735 _OUTB(port + 1, 0xFF);
1736 return 1;
1737 }
1738
1739 /*============================================================================
1740 * Detect S502E adapter.
1741 * Following tests are used to verify adapter presence:
1742 * 1. All registers other than status (BASE) should read 0xFF.
1743 * 2. After writing 0 to CPU control register (BASE+3), status register
1744 * (BASE) should read 11111000b.
1745 * 3. After writing 00000100b to port BASE (set bit 2), status register
1746 * (BASE) should read 11111100b.
1747 * Return 1 if detected o.k. or 0 if failed.
1748 * Note: This test is destructive! Adapter will be left in shutdown
1749 * state after the test.
1750 */
1751 static int detect_s502e (int port)
1752 {
1753 int i, j;
1754
1755 if (!get_option_index(s502_port_options, port))
1756 return 0;
1757 for (j = 1; j < SDLA_MAXIORANGE; ++j) {
1758 if (_INB(port + j) != 0xFF)
1759 return 0;
1760 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1761 }
1762
1763 _OUTB(port + 3, 0); /* CPU control reg. */
1764 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1765 if (_INB(port) != 0xF8) /* read status */
1766 return 0;
1767 _OUTB(port, 0x04); /* set bit 2 */
1768 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1769 if (_INB(port) != 0xFC) /* verify */
1770 return 0;
1771
1772 /* Reset adapter */
1773 _OUTB(port, 0);
1774 return 1;
1775 }
1776
1777 /*============================================================================
1778 * Detect s503 adapter.
1779 * Following tests are used to verify adapter presence:
1780 * 1. All registers other than status (BASE) should read 0xFF.
1781 * 2. After writing 0 to control register (BASE), status register (BASE)
1782 * should read 11110000b.
1783 * 3. After writing 00000100b (set bit 2) to control register (BASE),
1784 * status register should read 11110010b.
1785 * Return 1 if detected o.k. or 0 if failed.
1786 * Note: This test is destructive! Adapter will be left in shutdown
1787 * state after the test.
1788 */
1789 static int detect_s503 (int port)
1790 {
1791 int i, j;
1792
1793 if (!get_option_index(s503_port_options, port))
1794 return 0;
1795 for (j = 1; j < SDLA_MAXIORANGE; ++j) {
1796 if (_INB(port + j) != 0xFF)
1797 return 0;
1798 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1799 }
1800
1801 _OUTB(port, 0); /* reset control reg.*/
1802 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1803 if (_INB(port) != 0xF0) /* read status */
1804 return 0;
1805 _OUTB(port, 0x04); /* set bit 2 */
1806 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1807 if (_INB(port) != 0xF2) /* verify */
1808 return 0;
1809
1810 /* Reset adapter */
1811 _OUTB(port, 0);
1812 return 1;
1813 }
1814
1815 /*============================================================================
1816 * Detect s507 adapter.
1817 * Following tests are used to detect s507 adapter:
1818 * 1. All ports should read the same value.
1819 * 2. After writing 0x00 to control register, status register should read
1820 * ?011000?b.
1821 * 3. After writing 0x01 to control register, status register should read
1822 * ?011001?b.
1823 * Return 1 if detected o.k. or 0 if failed.
1824 * Note: This test is destructive! Adapter will be left in shutdown
1825 * state after the test.
1826 */
1827 static int detect_s507 (int port)
1828 {
1829 int tmp, i, j;
1830
1831 if (!get_option_index(s508_port_options, port))
1832 return 0;
1833 tmp = _INB(port);
1834 for (j = 1; j < S507_IORANGE; ++j) {
1835 if (_INB(port + j) != tmp)
1836 return 0;
1837 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1838 }
1839
1840 _OUTB(port, 0x00);
1841 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1842 if ((_INB(port) & 0x7E) != 0x30)
1843 return 0;
1844 _OUTB(port, 0x01);
1845 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1846 if ((_INB(port) & 0x7E) != 0x32)
1847 return 0;
1848
1849 /* Reset adapter */
1850 _OUTB(port, 0x00);
1851 return 1;
1852 }
1853
1854 /*============================================================================
1855 * Detect s508 adapter.
1856 * Following tests are used to detect s508 adapter:
1857 * 1. After writing 0x00 to control register, status register should read
1858 * ??000000b.
1859 * 2. After writing 0x10 to control register, status register should read
1860 * ??010000b
1861 * Return 1 if detected o.k. or 0 if failed.
1862 * Note: This test is destructive! Adapter will be left in shutdown
1863 * state after the test.
1864 */
1865 static int detect_s508 (int port)
1866 {
1867 int i;
1868
1869 if (!get_option_index(s508_port_options, port))
1870 return 0;
1871 _OUTB(port, 0x00);
1872 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1873 if ((_INB(port + 1) & 0x3F) != 0x00)
1874 return 0;
1875 _OUTB(port, 0x10);
1876 for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
1877 if ((_INB(port + 1) & 0x3F) != 0x10)
1878 return 0;
1879
1880 /* Reset adapter */
1881 _OUTB(port, 0x00);
1882 return 1;
1883 }
1884
1885 /*============================================================================
1886 * Detect s514 PCI adapter.
1887 * Return 1 if detected o.k. or 0 if failed.
1888 * Note: This test is destructive! Adapter will be left in shutdown
1889 * state after the test.
1890 */
1891 static int detect_s514 (sdlahw_t* hw)
1892 {
1893 unsigned char CPU_no, slot_no, auto_slot_cfg;
1894 int number_S514_cards = 0;
1895 u32 S514_mem_base_addr = 0;
1896 u32 ut_u32;
1897 struct pci_dev *pci_dev;
1898
1899
1900 #ifndef CONFIG_PCI
1901 printk(KERN_INFO "%s: Linux not compiled for PCI usage!\n", modname);
1902 return 0;
1903 #endif
1904
1905 /*
1906 The 'setup()' procedure in 'sdlamain.c' passes the CPU number and the
1907 slot number defined in 'router.conf' via the 'port' definition.
1908 */
1909 CPU_no = hw->S514_cpu_no[0];
1910 slot_no = hw->S514_slot_no;
1911 auto_slot_cfg = hw->auto_pci_cfg;
1912
1913 if (auto_slot_cfg){
1914 printk(KERN_INFO "%s: srch... S514 card, CPU %c, Slot=Auto\n",
1915 modname, CPU_no);
1916
1917 }else{
1918 printk(KERN_INFO "%s: srch... S514 card, CPU %c, Slot #%d\n",
1919 modname, CPU_no, slot_no);
1920 }
1921
1922 /* check to see that CPU A or B has been selected in 'router.conf' */
1923 switch(CPU_no) {
1924 case S514_CPU_A:
1925 case S514_CPU_B:
1926 break;
1927
1928 default:
1929 printk(KERN_INFO "%s: S514 CPU definition invalid.\n",
1930 modname);
1931 printk(KERN_INFO "Must be 'A' or 'B'\n");
1932 return 0;
1933 }
1934
1935 number_S514_cards = find_s514_adapter(hw, 0);
1936 if(!number_S514_cards)
1937 return 0;
1938
1939 /* we are using a single S514 adapter with a slot of 0 so re-read the */
1940 /* location of this adapter */
1941 if((number_S514_cards == 1) && auto_slot_cfg) {
1942 number_S514_cards = find_s514_adapter(hw, 1);
1943 if(!number_S514_cards) {
1944 printk(KERN_INFO "%s: Error finding PCI card\n",
1945 modname);
1946 return 0;
1947 }
1948 }
1949
1950 pci_dev = hw->pci_dev;
1951 /* read the physical memory base address */
1952 S514_mem_base_addr = (CPU_no == S514_CPU_A) ?
1953 (pci_dev->resource[1].start) :
1954 (pci_dev->resource[2].start);
1955
1956 printk(KERN_INFO "%s: S514 PCI memory at 0x%X\n",
1957 modname, S514_mem_base_addr);
1958 if(!S514_mem_base_addr) {
1959 if(CPU_no == S514_CPU_B)
1960 printk(KERN_INFO "%s: CPU #B not present on the card\n", modname);
1961 else
1962 printk(KERN_INFO "%s: No PCI memory allocated to card\n", modname);
1963 return 0;
1964 }
1965
1966 /* enable the PCI memory */
1967 pci_read_config_dword(pci_dev,
1968 (CPU_no == S514_CPU_A) ? PCI_MAP0_DWORD : PCI_MAP1_DWORD,
1969 &ut_u32);
1970 pci_write_config_dword(pci_dev,
1971 (CPU_no == S514_CPU_A) ? PCI_MAP0_DWORD : PCI_MAP1_DWORD,
1972 (ut_u32 | PCI_MEMORY_ENABLE));
1973
1974 /* check the IRQ allocated and enable IRQ usage */
1975 if(!(hw->irq = pci_dev->irq)) {
1976 printk(KERN_INFO "%s: IRQ not allocated to S514 adapter\n",
1977 modname);
1978 return 0;
1979 }
1980
1981 /* BUG FIX : Mar 6 2000
1982 * On a initial loading of the card, we must check
1983 * and clear PCI interrupt bits, due to a reset
1984 * problem on some other boards. i.e. An interrupt
1985 * might be pending, even after system bootup,
1986 * in which case, when starting wanrouter the machine
1987 * would crash.
1988 */
1989 if (init_pci_slot(hw))
1990 return 0;
1991
1992 pci_read_config_dword(pci_dev, PCI_INT_CONFIG, &ut_u32);
1993 ut_u32 |= (CPU_no == S514_CPU_A) ?
1994 PCI_ENABLE_IRQ_CPU_A : PCI_ENABLE_IRQ_CPU_B;
1995 pci_write_config_dword(pci_dev, PCI_INT_CONFIG, ut_u32);
1996
1997 printk(KERN_INFO "%s: IRQ %d allocated to the S514 card\n",
1998 modname, hw->irq);
1999
2000 /* map the physical PCI memory to virtual memory */
2001 (void *)hw->dpmbase = ioremap((unsigned long)S514_mem_base_addr,
2002 (unsigned long)MAX_SIZEOF_S514_MEMORY);
2003 /* map the physical control register memory to virtual memory */
2004 hw->vector = (unsigned long)ioremap(
2005 (unsigned long)(S514_mem_base_addr + S514_CTRL_REG_BYTE),
2006 (unsigned long)16);
2007
2008 if(!hw->dpmbase || !hw->vector) {
2009 printk(KERN_INFO "%s: PCI virtual memory allocation failed\n",
2010 modname);
2011 return 0;
2012 }
2013
2014 /* halt the adapter */
2015 writeb (S514_CPU_HALT, hw->vector);
2016
2017 return 1;
2018 }
2019
2020 /*============================================================================
2021 * Find the S514 PCI adapter in the PCI bus.
2022 * Return the number of S514 adapters found (0 if no adapter found).
2023 */
2024 static int find_s514_adapter(sdlahw_t* hw, char find_first_S514_card)
2025 {
2026 unsigned char slot_no;
2027 int number_S514_cards = 0;
2028 char S514_found_in_slot = 0;
2029 u16 PCI_subsys_vendor;
2030
2031 struct pci_dev *pci_dev = NULL;
2032
2033 slot_no = hw->S514_slot_no;
2034
2035 while ((pci_dev = pci_find_device(V3_VENDOR_ID, V3_DEVICE_ID, pci_dev))
2036 != NULL) {
2037
2038 pci_read_config_word(pci_dev, PCI_SUBSYS_VENDOR_WORD,
2039 &PCI_subsys_vendor);
2040
2041 if(PCI_subsys_vendor != SANGOMA_SUBSYS_VENDOR)
2042 continue;
2043
2044 hw->pci_dev = pci_dev;
2045
2046 if(find_first_S514_card)
2047 return(1);
2048
2049 number_S514_cards ++;
2050
2051 printk(KERN_INFO
2052 "%s: S514 card found, slot #%d (devfn 0x%X)\n",
2053 modname, ((pci_dev->devfn >> 3) & PCI_DEV_SLOT_MASK),
2054 pci_dev->devfn);
2055
2056 if (hw->auto_pci_cfg){
2057 hw->S514_slot_no = ((pci_dev->devfn >> 3) & PCI_DEV_SLOT_MASK);
2058 slot_no = hw->S514_slot_no;
2059
2060 }else if (((pci_dev->devfn >> 3) & PCI_DEV_SLOT_MASK) == slot_no){
2061 S514_found_in_slot = 1;
2062 break;
2063 }
2064 }
2065
2066 /* if no S514 adapter has been found, then exit */
2067 if (!number_S514_cards) {
2068 printk(KERN_INFO "%s: Error, no S514 adapters found\n", modname);
2069 return 0;
2070 }
2071 /* 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 */
2072 else if ((number_S514_cards > 1) && hw->auto_pci_cfg) {
2073 printk(KERN_INFO "%s: Error, PCI Slot autodetect Failed! \n"
2074 "%s: More than one S514 adapter found.\n"
2075 "%s: Disable the Autodetect feature and supply\n"
2076 "%s: the PCISLOT numbers for each card.\n",
2077 modname,modname,modname,modname);
2078 return 0;
2079 }
2080 /* if the user has specified a slot number and the S514 adapter has */
2081 /* not been found in that slot, then exit */
2082 else if (!hw->auto_pci_cfg && !S514_found_in_slot) {
2083 printk(KERN_INFO
2084 "%s: Error, S514 card not found in specified slot #%d\n",
2085 modname, slot_no);
2086 return 0;
2087 }
2088
2089 return (number_S514_cards);
2090 }
2091
2092
2093
2094 /******* Miscellaneous ******************************************************/
2095
2096 /*============================================================================
2097 * Calibrate SDLA memory access delay.
2098 * Count number of idle loops made within 1 second and then calculate the
2099 * number of loops that should be made to achive desired delay.
2100 */
2101 static int calibrate_delay (int mks)
2102 {
2103 unsigned int delay;
2104 unsigned long stop;
2105
2106 for (delay = 0, stop = SYSTEM_TICK + HZ; SYSTEM_TICK < stop; ++delay);
2107 return (delay/(1000000L/mks) + 1);
2108 }
2109
2110 /*============================================================================
2111 * Get option's index into the options list.
2112 * Return option's index (1 .. N) or zero if option is invalid.
2113 */
2114 static int get_option_index (unsigned* optlist, unsigned optval)
2115 {
2116 int i;
2117
2118 for (i = 1; i <= optlist[0]; ++i)
2119 if ( optlist[i] == optval)
2120 return i;
2121 return 0;
2122 }
2123
2124 /*============================================================================
2125 * Check memory region to see if it's available.
2126 * Return: 0 ok.
2127 */
2128 static unsigned check_memregion (void* ptr, unsigned len)
2129 {
2130 volatile unsigned char* p = ptr;
2131
2132 for (; len && (readb (p) == 0xFF); --len, ++p) {
2133 writeb (0, p); /* attempt to write 0 */
2134 if (readb(p) != 0xFF) { /* still has to read 0xFF */
2135 writeb (0xFF, p);/* restore original value */
2136 break; /* not good */
2137 }
2138 }
2139
2140 return len;
2141 }
2142
2143 /*============================================================================
2144 * Test memory region.
2145 * Return: size of the region that passed the test.
2146 * Note: Region size must be multiple of 2 !
2147 */
2148 static unsigned test_memregion (void* ptr, unsigned len)
2149 {
2150 volatile unsigned short* w_ptr;
2151 unsigned len_w = len >> 1; /* region len in words */
2152 unsigned i;
2153
2154 for (i = 0, w_ptr = ptr; i < len_w; ++i, ++w_ptr)
2155 writew (0xAA55, w_ptr);
2156
2157 for (i = 0, w_ptr = ptr; i < len_w; ++i, ++w_ptr)
2158 if (readw (w_ptr) != 0xAA55) {
2159 len_w = i;
2160 break;
2161 }
2162
2163 for (i = 0, w_ptr = ptr; i < len_w; ++i, ++w_ptr)
2164 writew (0x55AA, w_ptr);
2165
2166 for (i = 0, w_ptr = ptr; i < len_w; ++i, ++w_ptr)
2167 if (readw(w_ptr) != 0x55AA) {
2168 len_w = i;
2169 break;
2170 }
2171
2172 for (i = 0, w_ptr = ptr; i < len_w; ++i, ++w_ptr)
2173 writew (0, w_ptr);
2174
2175 return len_w << 1;
2176 }
2177
2178 /*============================================================================
2179 * Calculate 16-bit CRC using CCITT polynomial.
2180 */
2181 static unsigned short checksum (unsigned char* buf, unsigned len)
2182 {
2183 unsigned short crc = 0;
2184 unsigned mask, flag;
2185
2186 for (; len; --len, ++buf) {
2187 for (mask = 0x80; mask; mask >>= 1) {
2188 flag = (crc & 0x8000);
2189 crc <<= 1;
2190 crc |= ((*buf & mask) ? 1 : 0);
2191 if (flag) crc ^= 0x1021;
2192 }
2193 }
2194 return crc;
2195 }
2196
2197 static int init_pci_slot(sdlahw_t *hw)
2198 {
2199
2200 u32 int_status;
2201 int volatile found=0;
2202 int i=0;
2203
2204 /* Check if this is a very first load for a specific
2205 * pci card. If it is, clear the interrput bits, and
2206 * set the flag indicating that this card was initialized.
2207 */
2208
2209 for (i=0; (i<MAX_S514_CARDS) && !found; i++){
2210 if (pci_slot_ar[i] == hw->S514_slot_no){
2211 found=1;
2212 break;
2213 }
2214 if (pci_slot_ar[i] == 0xFF){
2215 break;
2216 }
2217 }
2218
2219 if (!found){
2220 read_S514_int_stat(hw,&int_status);
2221 S514_intack(hw,int_status);
2222 if (i == MAX_S514_CARDS){
2223 printk(KERN_INFO "%s: Critical Error !!!\n",modname);
2224 printk(KERN_INFO
2225 "%s: Number of Sangoma PCI cards exceeded maximum limit.\n",
2226 modname);
2227 printk(KERN_INFO "Please contact Sangoma Technologies\n");
2228 return 1;
2229 }
2230 pci_slot_ar[i] = hw->S514_slot_no;
2231 }
2232 return 0;
2233 }
2234
2235 static int pci_probe(sdlahw_t *hw)
2236 {
2237
2238 unsigned char slot_no;
2239 int number_S514_cards = 0;
2240 u16 PCI_subsys_vendor;
2241 u16 PCI_card_type;
2242
2243 struct pci_dev *pci_dev = NULL;
2244 struct pci_bus *bus = NULL;
2245
2246 slot_no = 0;
2247
2248 while ((pci_dev = pci_find_device(V3_VENDOR_ID, V3_DEVICE_ID, pci_dev))
2249 != NULL) {
2250
2251 pci_read_config_word(pci_dev, PCI_SUBSYS_VENDOR_WORD,
2252 &PCI_subsys_vendor);
2253
2254 if(PCI_subsys_vendor != SANGOMA_SUBSYS_VENDOR)
2255 continue;
2256
2257 pci_read_config_word(pci_dev, PCI_CARD_TYPE,
2258 &PCI_card_type);
2259
2260 bus = pci_dev->bus;
2261
2262 /* A dual cpu card can support up to 4 physical connections,
2263 * where a single cpu card can support up to 2 physical
2264 * connections. The FT1 card can only support a single
2265 * connection, however we cannot distinguish between a Single
2266 * CPU card and an FT1 card. */
2267 if (PCI_card_type == S514_DUAL_CPU){
2268 number_S514_cards += 4;
2269 printk(KERN_INFO
2270 "wanpipe: S514-PCI card found, cpu(s) 2, bus #%d, slot #%d, irq #%d\n",
2271 bus->number,((pci_dev->devfn >> 3) & PCI_DEV_SLOT_MASK),
2272 pci_dev->irq);
2273 }else{
2274 number_S514_cards += 2;
2275 printk(KERN_INFO
2276 "wanpipe: S514-PCI card found, cpu(s) 1, bus #%d, slot #%d, irq #%d\n",
2277 bus->number,((pci_dev->devfn >> 3) & PCI_DEV_SLOT_MASK),
2278 pci_dev->irq);
2279 }
2280 }
2281
2282 return number_S514_cards;
2283
2284 }
2285
2286
2287
2288 EXPORT_SYMBOL(wanpipe_hw_probe);
2289
2290 unsigned wanpipe_hw_probe(void)
2291 {
2292 sdlahw_t hw;
2293 unsigned* opt = s508_port_options;
2294 unsigned cardno=0;
2295 int i;
2296
2297 memset(&hw, 0, sizeof(hw));
2298
2299 for (i = 1; i <= opt[0]; i++) {
2300 if (detect_s508(opt[i])){
2301 /* S508 card can support up to two physical links */
2302 cardno+=2;
2303 printk(KERN_INFO "wanpipe: S508-ISA card found, port 0x%x\n",opt[i]);
2304 }
2305 }
2306
2307 #ifdef CONFIG_PCI
2308 hw.S514_slot_no = 0;
2309 cardno += pci_probe(&hw);
2310 #else
2311 printk(KERN_INFO "wanpipe: Warning, Kernel not compiled for PCI support!\n");
2312 printk(KERN_INFO "wanpipe: PCI Hardware Probe Failed!\n");
2313 #endif
2314
2315 return cardno;
2316 }
2317
2318 /****** End *****************************************************************/
Linux kernel - Deliverables
This page took 0.079593 seconds and 5 git commands to generate.