Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 *****************************************************************/ |