开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
sdladrv.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：71k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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. *****************************************************************************/
  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.  ****************************************************************************/
  89. #define _LINUX_
  91. #if defined(_LINUX_) /****** Linux *******************************/
  93. #include <linux/config.h>
  94. #include <linux/version.h>
  95. #include <linux/kernel.h> /* printk(), and other useful stuff */
  96. #include <linux/stddef.h> /* offsetof(), etc. */
  97. #include <linux/errno.h> /* return codes */
  98. #include <linux/string.h> /* inline memset(), etc. */
  99. #include <linux/module.h> /* support for loadable modules */
  100. #include <linux/sched.h> /* for jiffies, HZ, etc. */
  101. #include <linux/sdladrv.h> /* API definitions */
  102. #include <linux/sdlasfm.h> /* SDLA firmware module definitions */
  103. #include <linux/sdlapci.h> /* SDLA PCI hardware definitions */
  104. #include <linux/pci.h> /* PCI defines and function prototypes */
  105. #include <asm/io.h> /* for inb(), outb(), etc. */
  107. #define _INB(port) (inb(port))
  108. #define _OUTB(port, byte) (outb((byte),(port)))
  109. #define SYSTEM_TICK jiffies
  112. #if defined(LINUX_2_1) || defined(LINUX_2_4) 
  113.  #include <linux/init.h>
  114. #else
  115.  #include <linux/bios32.h>/* BIOS32, PCI BIOS functions and definitions */
  116.  #define ioremap vremap
  117.  #define iounmap vfree
  118.  extern void * vremap (unsigned long offset, unsigned long size);
  119.  extern void vfree (void *addr);
  120. #endif
  122. #elif defined(_SCO_UNIX_) /****** SCO Unix ****************************/
  124. #if !defined(INKERNEL)
  125. #error This code MUST be compiled in kernel mode!
  126. #endif
  127. #include <sys/sdladrv.h> /* API definitions */
  128. #include <sys/sdlasfm.h> /* SDLA firmware module definitions */
  129. #include <sys/inline.h> /* for inb(), outb(), etc. */
  130. #define _INB(port) (inb(port))
  131. #define _OUTB(port, byte) (outb((port),(byte)))
  132. #define SYSTEM_TICK lbolt
  134. #else
  135. #error Unknown system type!
  136. #endif
  138. #define MOD_VERSION 3
  139. #define MOD_RELEASE 0
  141. #define SDLA_IODELAY 100 /* I/O Rd/Wr delay, 10 works for 486DX2-66 */
  142. #define EXEC_DELAY 20 /* shared memory access delay, mks */
  143. #define EXEC_TIMEOUT (HZ*2) /* command timeout, in ticks */
  145. /* I/O port address range */
  146. #define S502A_IORANGE 3
  147. #define S502E_IORANGE 4
  148. #define S503_IORANGE 3
  149. #define S507_IORANGE 4
  150. #define S508_IORANGE 4
  152. /* Maximum amount of memory */
  153. #define S502_MAXMEM 0x10000L
  154. #define S503_MAXMEM 0x10000L
  155. #define S507_MAXMEM 0x40000L
  156. #define S508_MAXMEM 0x40000L
  158. /* Minimum amount of memory */
  159. #define S502_MINMEM 0x8000L
  160. #define S503_MINMEM 0x8000L
  161. #define S507_MINMEM 0x20000L
  162. #define S508_MINMEM 0x20000L
  163. #define NO_PORT         -1
  169. /****** Function Prototypes *************************************************/
  171. /* Module entry points. These are called by the OS and must be public. */
  172. int init_module (void);
  173. void cleanup_module (void);
  175. /* Hardware-specific functions */
  176. static int sdla_detect (sdlahw_t* hw);
  177. static int sdla_autodpm (sdlahw_t* hw);
  178. static int sdla_setdpm (sdlahw_t* hw);
  179. static int sdla_load (sdlahw_t* hw, sfm_t* sfm, unsigned len);
  180. static int sdla_init (sdlahw_t* hw);
  181. static unsigned long sdla_memtest (sdlahw_t* hw);
  182. static int sdla_bootcfg (sdlahw_t* hw, sfm_info_t* sfminfo);
  183. static unsigned char make_config_byte (sdlahw_t* hw);
  184. static int sdla_start (sdlahw_t* hw, unsigned addr);
  186. static int init_s502a (sdlahw_t* hw);
  187. static int init_s502e (sdlahw_t* hw);
  188. static int init_s503 (sdlahw_t* hw);
  189. static int init_s507 (sdlahw_t* hw);
  190. static int init_s508 (sdlahw_t* hw);
  191.             
  192. static int detect_s502a (int port);
  193. static int detect_s502e (int port);
  194. static int detect_s503 (int port);
  195. static int detect_s507 (int port);
  196. static int detect_s508 (int port);
  197. static int detect_s514  (sdlahw_t* hw);
  198. static int find_s514_adapter(sdlahw_t* hw, char find_first_S514_card);
  200. /* Miscellaneous functions */
  201. static void peek_by_4 (unsigned long src, void* buf, unsigned len);
  202. static void poke_by_4 (unsigned long dest, void* buf, unsigned len);
  203. static int calibrate_delay (int mks);
  204. static int get_option_index (unsigned* optlist, unsigned optval);
  205. static unsigned check_memregion (void* ptr, unsigned len);
  206. static unsigned test_memregion (void* ptr, unsigned len);
  207. static unsigned short checksum (unsigned char* buf, unsigned len);
  208. static int init_pci_slot(sdlahw_t *);
  210. static int pci_probe(sdlahw_t *hw);
  212. /****** Global Data **********************************************************
  213.  * Note: All data must be explicitly initialized!!!
  214.  */
  216. static struct pci_device_id sdladrv_pci_tbl[] __initdata = {
  217. { V3_VENDOR_ID, V3_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, },
  218. { } /* Terminating entry */
  219. };
  220. MODULE_DEVICE_TABLE(pci, sdladrv_pci_tbl);
  222. MODULE_LICENSE("GPL");
  224. /* private data */
  225. static char modname[] = "sdladrv";
  226. static char fullname[] = "SDLA Support Module";
  227. static char copyright[] = "(c) 1995-1999 Sangoma Technologies Inc.";
  228. static unsigned exec_idle;
  230. /* Hardware configuration options.
  231.  * These are arrays of configuration options used by verification routines.
  232.  * The first element of each array is its size (i.e. number of options).
  233.  */
  234. static unsigned s502_port_options[] =
  235. { 4, 0x250, 0x300, 0x350, 0x360 }
  236. ;
  237. static unsigned s503_port_options[] =
  238. { 8, 0x250, 0x254, 0x300, 0x304, 0x350, 0x354, 0x360, 0x364 }
  239. ;
  240. static unsigned s508_port_options[] =
  241. { 8, 0x250, 0x270, 0x280, 0x300, 0x350, 0x360, 0x380, 0x390 }
  242. ;
  244. static unsigned s502a_irq_options[] = { 0 };
  245. static unsigned s502e_irq_options[] = { 4, 2, 3, 5, 7 };
  246. static unsigned s503_irq_options[]  = { 5, 2, 3, 4, 5, 7 };
  247. static unsigned s508_irq_options[]  = { 8, 3, 4, 5, 7, 10, 11, 12, 15 };
  249. static unsigned s502a_dpmbase_options[] =
  250. {
  251. 28,
  252. 0xA0000, 0xA2000, 0xA4000, 0xA6000, 0xA8000, 0xAA000, 0xAC000,
  253. 0xC0000, 0xC2000, 0xC4000, 0xC6000, 0xC8000, 0xCA000, 0xCC000,
  254. 0xD0000, 0xD2000, 0xD4000, 0xD6000, 0xD8000, 0xDA000, 0xDC000,
  255. 0xE0000, 0xE2000, 0xE4000, 0xE6000, 0xE8000, 0xEA000, 0xEC000,
  256. };
  257. static unsigned s507_dpmbase_options[] =
  258. {
  259. 32,
  260. 0xA0000, 0xA2000, 0xA4000, 0xA6000, 0xA8000, 0xAA000, 0xAC000, 0xAE000,
  261. 0xB0000, 0xB2000, 0xB4000, 0xB6000, 0xB8000, 0xBA000, 0xBC000, 0xBE000,
  262. 0xC0000, 0xC2000, 0xC4000, 0xC6000, 0xC8000, 0xCA000, 0xCC000, 0xCE000,
  263. 0xE0000, 0xE2000, 0xE4000, 0xE6000, 0xE8000, 0xEA000, 0xEC000, 0xEE000,
  264. };
  265. static unsigned s508_dpmbase_options[] = /* incl. S502E and S503 */
  266. {
  267. 32,
  268. 0xA0000, 0xA2000, 0xA4000, 0xA6000, 0xA8000, 0xAA000, 0xAC000, 0xAE000,
  269. 0xC0000, 0xC2000, 0xC4000, 0xC6000, 0xC8000, 0xCA000, 0xCC000, 0xCE000,
  270. 0xD0000, 0xD2000, 0xD4000, 0xD6000, 0xD8000, 0xDA000, 0xDC000, 0xDE000,
  271. 0xE0000, 0xE2000, 0xE4000, 0xE6000, 0xE8000, 0xEA000, 0xEC000, 0xEE000,
  272. };
  274. /*
  275. static unsigned s502_dpmsize_options[] = { 2, 0x2000, 0x10000 };
  276. static unsigned s507_dpmsize_options[] = { 2, 0x2000, 0x4000 };
  277. static unsigned s508_dpmsize_options[] = { 1, 0x2000 };
  278. */
  280. static unsigned s502a_pclk_options[] = { 2, 3600, 7200 };
  281. static unsigned s502e_pclk_options[] = { 5, 3600, 5000, 7200, 8000, 10000 };
  282. static unsigned s503_pclk_options[]  = { 3, 7200, 8000, 10000 };
  283. static unsigned s507_pclk_options[]  = { 1, 12288 };
  284. static unsigned s508_pclk_options[]  = { 1, 16000 };
  286. /* Host memory control register masks */
  287. static unsigned char s502a_hmcr[] =
  288. {
  289. 0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, /* A0000 - AC000 */
  290. 0x20, 0x22, 0x24, 0x26, 0x28, 0x2A, 0x2C, /* C0000 - CC000 */
  291. 0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, /* D0000 - DC000 */
  292. 0x30, 0x32, 0x34, 0x36, 0x38, 0x3A, 0x3C, /* E0000 - EC000 */
  293. };
  294. static unsigned char s502e_hmcr[] =
  295. {
  296. 0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E, /* A0000 - AE000 */
  297. 0x20, 0x22, 0x24, 0x26, 0x28, 0x2A, 0x2C, 0x2E, /* C0000 - CE000 */
  298. 0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E, /* D0000 - DE000 */
  299. 0x30, 0x32, 0x34, 0x36, 0x38, 0x3A, 0x3C, 0x3E, /* E0000 - EE000 */
  300. };
  301. static unsigned char s507_hmcr[] =
  302. {
  303. 0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E, /* A0000 - AE000 */
  304. 0x40, 0x42, 0x44, 0x46, 0x48, 0x4A, 0x4C, 0x4E, /* B0000 - BE000 */
  305. 0x80, 0x82, 0x84, 0x86, 0x88, 0x8A, 0x8C, 0x8E, /* C0000 - CE000 */
  306. 0xC0, 0xC2, 0xC4, 0xC6, 0xC8, 0xCA, 0xCC, 0xCE, /* E0000 - EE000 */
  307. };
  308. static unsigned char s508_hmcr[] =
  309. {
  310. 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, /* A0000 - AE000 */
  311. 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, /* C0000 - CE000 */
  312. 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, /* D0000 - DE000 */
  313. 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, /* E0000 - EE000 */
  314. };
  316. static unsigned char s507_irqmask[] =
  317. {
  318. 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xE0
  319. };
  321. static int pci_slot_ar[MAX_S514_CARDS];
  323. /******* Kernel Loadable Module Entry Points ********************************/
  325. /*============================================================================
  326.  * Module 'insert' entry point.
  327.  * o print announcement
  328.  * o initialize static data
  329.  * o calibrate SDLA shared memory access delay.
  330.  *
  331.  * Return: 0 Ok
  332.  * < 0 error.
  333.  * Context: process
  334.  */
  336. #ifdef MODULE
  337. int init_module (void)
  338. #else
  339. int sdladrv_init(void)
  340. #endif
  341. {
  342. int i=0;
  344. printk(KERN_INFO "%s v%u.%u %sn",
  345. fullname, MOD_VERSION, MOD_RELEASE, copyright);
  346. exec_idle = calibrate_delay(EXEC_DELAY);
  347. #ifdef WANDEBUG
  348. printk(KERN_DEBUG "%s: exec_idle = %dn", modname, exec_idle);
  349. #endif
  351. /* Initialize the PCI Card array, which
  352.          * will store flags, used to mark 
  353.          * card initialization state */
  354. for (i=0; i<MAX_S514_CARDS; i++)
  355. pci_slot_ar[i] = 0xFF;
  357. return 0;
  358. }
  360. #ifdef MODULE
  361. /*============================================================================
  362.  * Module 'remove' entry point.
  363.  * o release all remaining system resources
  364.  */
  365. void cleanup_module (void)
  366. {
  367. }
  368. #endif
  370. /******* Kernel APIs ********************************************************/
  372. /*============================================================================
  373.  * Set up adapter.
  374.  * o detect adapter type
  375.  * o verify hardware configuration options
  376.  * o check for hardware conflicts
  377.  * o set up adapter shared memory
  378.  * o test adapter memory
  379.  * o load firmware
  380.  * Return: 0 ok.
  381.  * < 0 error
  382.  */
  384. #if defined(LINUX_2_1) || defined(LINUX_2_4) 
  385. EXPORT_SYMBOL(sdla_setup);
  386. #endif
  388. int sdla_setup (sdlahw_t* hw, void* sfm, unsigned len)
  389. {
  390. unsigned* irq_opt = NULL; /* IRQ options */
  391. unsigned* dpmbase_opt = NULL; /* DPM window base options */
  392. unsigned* pclk_opt = NULL; /* CPU clock rate options */
  393. int err=0;
  395. if (sdla_detect(hw)) {
  396.                 if(hw->type != SDLA_S514)
  397.                         printk(KERN_INFO "%s: no SDLA card found at port 0x%Xn",
  398.                         modname, hw->port);
  399. return -EINVAL;
  400. }
  402. if(hw->type != SDLA_S514) {
  403.                 printk(KERN_INFO "%s: found S%04u card at port 0x%X.n",
  404.                 modname, hw->type, hw->port);
  406.                 hw->dpmsize = SDLA_WINDOWSIZE;
  407.                 switch (hw->type) {
  408.                 case SDLA_S502A:
  409.                         hw->io_range    = S502A_IORANGE;
  410.                         irq_opt         = s502a_irq_options;
  411.                         dpmbase_opt     = s502a_dpmbase_options;
  412.                         pclk_opt        = s502a_pclk_options;
  413.                         break;
  415.                 case SDLA_S502E:
  416.                         hw->io_range    = S502E_IORANGE;
  417.                         irq_opt         = s502e_irq_options;
  418.                         dpmbase_opt     = s508_dpmbase_options;
  419.                         pclk_opt        = s502e_pclk_options;
  420.                         break;
  422.                 case SDLA_S503:
  423.                         hw->io_range    = S503_IORANGE;
  424.                         irq_opt         = s503_irq_options;
  425.                         dpmbase_opt     = s508_dpmbase_options;
  426.                         pclk_opt        = s503_pclk_options;
  427.                         break;
  429.                 case SDLA_S507:
  430.                         hw->io_range    = S507_IORANGE;
  431.                         irq_opt         = s508_irq_options;
  432.                         dpmbase_opt     = s507_dpmbase_options;
  433.                         pclk_opt        = s507_pclk_options;
  434.                         break;
  436.                 case SDLA_S508:
  437.                         hw->io_range    = S508_IORANGE;
  438.                         irq_opt         = s508_irq_options;
  439.                         dpmbase_opt     = s508_dpmbase_options;
  440.                         pclk_opt        = s508_pclk_options;
  441.                         break;
  442.                 }
  444.                 /* Verify IRQ configuration options */
  445.                 if (!get_option_index(irq_opt, hw->irq)) {
  446.                         printk(KERN_INFO "%s: IRQ %d is illegal!n",
  447.                          modname, hw->irq);
  448.                       return -EINVAL;
  449.                 } 
  451.                 /* Verify CPU clock rate configuration options */
  452.                 if (hw->pclk == 0)
  453.                         hw->pclk = pclk_opt[1];  /* use default */
  454.         
  455.                 else if (!get_option_index(pclk_opt, hw->pclk)) {
  456.                         printk(KERN_INFO "%s: CPU clock %u is illegal!n",
  457. modname, hw->pclk);
  458.                         return -EINVAL;
  459.                 } 
  460.                 printk(KERN_INFO "%s: assuming CPU clock rate of %u kHz.n",
  461. modname, hw->pclk);
  463.                 /* Setup adapter dual-port memory window and test memory */
  464.                 if (hw->dpmbase == 0) {
  465.                         err = sdla_autodpm(hw);
  466.                         if (err) {
  467.                                 printk(KERN_INFO
  468. "%s: can't find available memory region!n",
  469. modname);
  470.                                 return err;
  471.                         }
  472.                 }
  473.                 else if (!get_option_index(dpmbase_opt,
  474. virt_to_phys(hw->dpmbase))) {
  475.                         printk(KERN_INFO
  476. "%s: memory address 0x%lX is illegal!n",
  477. modname, virt_to_phys(hw->dpmbase));
  478.                         return -EINVAL;
  479.                 }               
  480.                 else if (sdla_setdpm(hw)) {
  481.                         printk(KERN_INFO
  482. "%s: 8K memory region at 0x%lX is not available!n",
  483. modname, virt_to_phys(hw->dpmbase));
  484.                         return -EINVAL;
  485.                 } 
  486.                 printk(KERN_INFO
  487. "%s: dual-port memory window is set at 0x%lX.n",
  488. modname, virt_to_phys(hw->dpmbase));
  491. /* If we find memory in 0xE**** Memory region, 
  492.                  * warn the user to disable the SHADOW RAM.  
  493.                  * Since memory corruption can occur if SHADOW is
  494.                  * enabled. This can causes random crashes ! */
  495. if (virt_to_phys(hw->dpmbase) >= 0xE0000){
  496. printk(KERN_WARNING "n%s: !!!!!!!!  WARNING !!!!!!!!n",modname);
  497. printk(KERN_WARNING "%s: WANPIPE is using 0x%lX memory region !!!n",
  498. modname, virt_to_phys(hw->dpmbase));
  499. printk(KERN_WARNING "         Please disable the SHADOW RAM, otherwisen");
  500. printk(KERN_WARNING "         your system might crash randomly from time to time !n");
  501. printk(KERN_WARNING "%s: !!!!!!!!  WARNING !!!!!!!!nn",modname);
  502. }
  503.         }
  505. else {
  506. hw->memory = test_memregion((void*)hw->dpmbase, 
  507. MAX_SIZEOF_S514_MEMORY);
  508. if(hw->memory < (256 * 1024)) {
  509. printk(KERN_INFO
  510. "%s: error in testing S514 memory (0x%lX)n",
  511. modname, hw->memory);
  512. sdla_down(hw);
  513. return -EINVAL;
  514. }
  515. }
  516.     
  517. printk(KERN_INFO "%s: found %luK bytes of on-board memoryn",
  518. modname, hw->memory / 1024);
  520. /* Load firmware. If loader fails then shut down adapter */
  521. err = sdla_load(hw, sfm, len);
  522. if (err) sdla_down(hw); /* shutdown adapter */
  524. return err;
  525. } 
  527. /*============================================================================
  528.  * Shut down SDLA: disable shared memory access and interrupts, stop CPU, etc.
  529.  */
  531. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  532. EXPORT_SYMBOL(sdla_down);
  533. #endif
  535. int sdla_down (sdlahw_t* hw)
  536. {
  537. unsigned port = hw->port;
  538. int i;
  539.         unsigned char CPU_no;
  540.         u32 int_config, int_status;
  542.         if(!port && (hw->type != SDLA_S514))
  543.                 return -EFAULT;
  545. switch (hw->type) {
  546. case SDLA_S502A:
  547. _OUTB(port, 0x08); /* halt CPU */
  548. _OUTB(port, 0x08);
  549. _OUTB(port, 0x08);
  550. hw->regs[0] = 0x08;
  551. _OUTB(port + 1, 0xFF); /* close memory window */
  552. hw->regs[1] = 0xFF;
  553. break;
  555. case SDLA_S502E:
  556. _OUTB(port + 3, 0); /* stop CPU */
  557. _OUTB(port, 0); /* reset board */
  558. for (i = 0; i < S502E_IORANGE; ++i)
  559. hw->regs[i] = 0
  560. ;
  561. break;
  563. case SDLA_S503:
  564. case SDLA_S507:
  565. case SDLA_S508:
  566. _OUTB(port, 0); /* reset board logic */
  567. hw->regs[0] = 0;
  568. break;
  570. case SDLA_S514:
  571. /* halt the adapter */
  572.                 *(char *)hw->vector = S514_CPU_HALT;
  573.          CPU_no = hw->S514_cpu_no[0];
  575. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  576. /* disable the PCI IRQ and disable memory access */
  577.                 pci_read_config_dword(hw->pci_dev, PCI_INT_CONFIG, &int_config);
  578.         int_config &= (CPU_no == S514_CPU_A) ? ~PCI_DISABLE_IRQ_CPU_A : ~PCI_DISABLE_IRQ_CPU_B;
  579.                 pci_write_config_dword(hw->pci_dev, PCI_INT_CONFIG, int_config);
  580. read_S514_int_stat(hw, &int_status);
  581. S514_intack(hw, int_status);
  582. if(CPU_no == S514_CPU_A)
  583.                         pci_write_config_dword(hw->pci_dev, PCI_MAP0_DWORD,
  584. PCI_CPU_A_MEM_DISABLE);
  585. else
  586.                         pci_write_config_dword(hw->pci_dev, PCI_MAP1_DWORD,
  587. PCI_CPU_B_MEM_DISABLE);
  588. #else
  589.                 /* disable the PCI IRQ and disable memory access */
  590.               pcibios_read_config_dword(hw->pci_bus, hw->pci_dev_func,
  591. PCI_INT_CONFIG, &int_config);
  592.         int_config &= (CPU_no == S514_CPU_A) ? ~PCI_DISABLE_IRQ_CPU_A : ~PCI_DISABLE_IRQ_CPU_B;
  593.          pcibios_write_config_dword(hw->pci_bus, hw->pci_dev_func,
  594. PCI_INT_CONFIG, int_config);
  595.                 read_S514_int_stat(hw, &int_status);
  596.                 S514_intack(hw, int_status);
  597.       // disable PCI memory access
  598. if(CPU_no == S514_CPU_A)
  599.       pcibios_write_config_dword(hw->pci_bus,hw->pci_dev_func,
  600. PCI_MAP0_DWORD, PCI_CPU_A_MEM_DISABLE);
  601. else
  602.                         pcibios_write_config_dword(hw->pci_bus,hw->pci_dev_func, PCI_MAP1_DWORD, PCI_CPU_B_MEM_DISABLE);
  603. #endif
  605. /* free up the allocated virtual memory */
  606.   iounmap((void *)hw->dpmbase);
  607.          iounmap((void *)hw->vector);
  608.   break;
  611. default:
  612. return -EINVAL;
  613. }
  614. return 0;
  615. }
  617. /*============================================================================
  618.  * Map shared memory window into SDLA address space.
  619.  */
  621. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  622. EXPORT_SYMBOL(sdla_mapmem);
  623. #endif
  625. int sdla_mapmem (sdlahw_t* hw, unsigned long addr)
  626. {
  627. unsigned port = hw->port;
  628. register int tmp;
  630. switch (hw->type) {
  631. case SDLA_S502A:
  632. case SDLA_S502E:
  633. if (addr < S502_MAXMEM) { /* verify parameter */
  634. tmp = addr >> 13; /* convert to register mask */
  635. _OUTB(port + 2, tmp);
  636. hw->regs[2] = tmp;
  637. }
  638. else return -EINVAL;
  639. break;
  641. case SDLA_S503:
  642. if (addr < S503_MAXMEM) { /* verify parameter */
  643. tmp = (hw->regs[0] & 0x8F) | ((addr >> 9) & 0x70);
  644. _OUTB(port, tmp);
  645. hw->regs[0] = tmp;
  646. }
  647. else return -EINVAL;
  648. break;
  650. case SDLA_S507:
  651. if (addr < S507_MAXMEM) {
  652. if (!(_INB(port) & 0x02))
  653. return -EIO;
  654. tmp = addr >> 13; /* convert to register mask */
  655. _OUTB(port + 2, tmp);
  656. hw->regs[2] = tmp;
  657. }
  658. else return -EINVAL;
  659. break;
  661. case SDLA_S508:
  662. if (addr < S508_MAXMEM) {
  663. tmp = addr >> 13; /* convert to register mask */
  664. _OUTB(port + 2, tmp);
  665. hw->regs[2] = tmp;
  666. }
  667. else return -EINVAL;
  668. break;
  670. case SDLA_S514:
  671. return 0;
  673.   default:
  674. return -EINVAL;
  675. }
  676. hw->vector = addr & 0xFFFFE000L;
  677. return 0;
  678. }
  680. /*============================================================================
  681.  * Enable interrupt generation.
  682.  */
  684. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  685. EXPORT_SYMBOL(sdla_inten);
  686. #endif
  688. int sdla_inten (sdlahw_t* hw)
  689. {
  690. unsigned port = hw->port;
  691. int tmp, i;
  693. switch (hw->type) {
  694. case SDLA_S502E:
  695. /* Note thar interrupt control operations on S502E are allowed
  696.  * only if CPU is enabled (bit 0 of status register is set).
  697.  */
  698. if (_INB(port) & 0x01) {
  699. _OUTB(port, 0x02); /* bit1 = 1, bit2 = 0 */
  700. _OUTB(port, 0x06); /* bit1 = 1, bit2 = 1 */
  701. hw->regs[0] = 0x06;
  702. }
  703. else return -EIO;
  704. break;
  706. case SDLA_S503:
  707. tmp = hw->regs[0] | 0x04;
  708. _OUTB(port, tmp);
  709. hw->regs[0] = tmp; /* update mirror */
  710. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  711. if (!(_INB(port) & 0x02)) /* verify */
  712. return -EIO;
  713. break;
  715. case SDLA_S508:
  716. tmp = hw->regs[0] | 0x10;
  717. _OUTB(port, tmp);
  718. hw->regs[0] = tmp; /* update mirror */
  719. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  720. if (!(_INB(port + 1) & 0x10)) /* verify */
  721. return -EIO;
  722. break;
  724. case SDLA_S502A:
  725. case SDLA_S507:
  726. break;
  728.         case SDLA_S514:
  729.                 break;
  731. default:
  732. return -EINVAL;
  734. }
  735. return 0;
  736. }
  738. /*============================================================================
  739.  * Disable interrupt generation.
  740.  */
  742. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  743. EXPORT_SYMBOL(sdla_intde);
  744. #endif
  746. int sdla_intde (sdlahw_t* hw)
  747. {
  748. unsigned port = hw->port;
  749. int tmp, i;
  751. switch (hw->type) {
  752. case SDLA_S502E:
  753. /* Notes:
  754.  *  1) interrupt control operations are allowed only if CPU is
  755.  *     enabled (bit 0 of status register is set).
  756.  *  2) disabling interrupts using bit 1 of control register
  757.  *     causes IRQ line go high, therefore we are going to use
  758.  *     0x04 instead: lower it to inhibit interrupts to PC.
  759.  */
  760. if (_INB(port) & 0x01) {
  761. _OUTB(port, hw->regs[0] & ~0x04);
  762. hw->regs[0] &= ~0x04;
  763. }
  764. else return -EIO;
  765. break;
  767. case SDLA_S503:
  768. tmp = hw->regs[0] & ~0x04;
  769. _OUTB(port, tmp);
  770. hw->regs[0] = tmp; /* update mirror */
  771. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  772. if (_INB(port) & 0x02) /* verify */
  773. return -EIO;
  774. break;
  776. case SDLA_S508:
  777. tmp = hw->regs[0] & ~0x10;
  778. _OUTB(port, tmp);
  779. hw->regs[0] = tmp; /* update mirror */
  780. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  781. if (_INB(port) & 0x10) /* verify */
  782. return -EIO;
  783. break;
  785. case SDLA_S502A:
  786. case SDLA_S507:
  787. break;
  789. default:
  790. return -EINVAL;
  791. }
  792. return 0;
  793. }
  795. /*============================================================================
  796.  * Acknowledge SDLA hardware interrupt.
  797.  */
  799. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  800. EXPORT_SYMBOL(sdla_intack);
  801. #endif
  803. int sdla_intack (sdlahw_t* hw)
  804. {
  805. unsigned port = hw->port;
  806. int tmp;
  808. switch (hw->type) {
  809. case SDLA_S502E:
  810. /* To acknoledge hardware interrupt we have to toggle bit 3 of
  811.  * control register: _/
  812.  * Note that interrupt control operations on S502E are allowed
  813.  * only if CPU is enabled (bit 1 of status register is set).
  814.  */
  815. if (_INB(port) & 0x01) {
  816. tmp = hw->regs[0] & ~0x04;
  817. _OUTB(port, tmp);
  818. tmp |= 0x04;
  819. _OUTB(port, tmp);
  820. hw->regs[0] = tmp;
  821. }
  822. else return -EIO;
  823. break;
  825. case SDLA_S503:
  826. if (_INB(port) & 0x04) {
  827. tmp = hw->regs[0] & ~0x08;
  828. _OUTB(port, tmp);
  829. tmp |= 0x08;
  830. _OUTB(port, tmp);
  831. hw->regs[0] = tmp;
  832. }
  833. break;
  835. case SDLA_S502A:
  836. case SDLA_S507:
  837. case SDLA_S508:
  838. break;
  840. default:
  841. return -EINVAL;
  842. }
  843. return 0;
  844. }
  847. /*============================================================================
  848.  * Acknowledge S514 hardware interrupt.
  849.  */
  851. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  852. EXPORT_SYMBOL(S514_intack);
  853. #endif
  855. void S514_intack (sdlahw_t* hw, u32 int_status)
  856. {
  857. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  858.         pci_write_config_dword(hw->pci_dev, PCI_INT_STATUS, int_status);
  859. #else
  860. pcibios_write_config_dword(hw->pci_bus, hw->pci_dev_func,
  861.                 PCI_INT_STATUS, int_status);
  862. #endif
  863. }
  866. /*============================================================================
  867.  * Read the S514 hardware interrupt status.
  868.  */
  870. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  871. EXPORT_SYMBOL(read_S514_int_stat);
  872. #endif
  874. void read_S514_int_stat (sdlahw_t* hw, u32* int_status)
  875. {
  876. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  877. pci_read_config_dword(hw->pci_dev, PCI_INT_STATUS, int_status);
  878. #else
  879.         pcibios_read_config_dword(hw->pci_bus, hw->pci_dev_func, PCI_INT_STATUS,
  880. int_status);
  881. #endif
  882. }
  885. /*============================================================================
  886.  * Generate an interrupt to adapter's CPU.
  887.  */
  889. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  890. EXPORT_SYMBOL(sdla_intr);
  891. #endif
  893. int sdla_intr (sdlahw_t* hw)
  894. {
  895. unsigned port = hw->port;
  897. switch (hw->type) {
  898. case SDLA_S502A:
  899. if (!(_INB(port) & 0x40)) {
  900. _OUTB(port, 0x10); /* issue NMI to CPU */
  901. hw->regs[0] = 0x10;
  902. }
  903. else return -EIO;
  904. break;
  906. case SDLA_S507:
  907. if ((_INB(port) & 0x06) == 0x06) {
  908. _OUTB(port + 3, 0);
  909. }
  910. else return -EIO;
  911. break;
  913. case SDLA_S508:
  914. if (_INB(port + 1) & 0x02) {
  915. _OUTB(port, 0x08);
  916. }
  917. else return -EIO;
  918. break;
  920. case SDLA_S502E:
  921. case SDLA_S503:
  922. default:
  923. return -EINVAL;
  924. }
  925. return 0;
  926. }
  928. /*============================================================================
  929.  * Execute Adapter Command.
  930.  * o Set exec flag.
  931.  * o Busy-wait until flag is reset.
  932.  * o Return number of loops made, or 0 if command timed out.
  933.  */
  935. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  936. EXPORT_SYMBOL(sdla_exec);
  937. #endif
  939. int sdla_exec (void* opflag)
  940. {
  941. volatile unsigned char* flag = opflag;
  942. unsigned long tstop;
  943. int nloops;
  945. if(readb(flag) != 0x00) {
  946. printk(KERN_INFO
  947. "WANPIPE: opp flag set on entry to sdla_execn");
  948. return 0;
  949. }
  951. writeb(0x01, flag);
  953. tstop = SYSTEM_TICK + EXEC_TIMEOUT;
  955. for (nloops = 1; (readb(flag) == 0x01); ++ nloops) {
  956. unsigned delay = exec_idle;
  957. while (-- delay); /* delay */
  958. if (SYSTEM_TICK > tstop) return 0; /* time is up! */
  959. }
  960. return nloops;
  961. }
  963. /*============================================================================
  964.  * Read absolute adapter memory.
  965.  * Transfer data from adapter's memory to data buffer.
  966.  *
  967.  * Note:
  968.  * Care should be taken when crossing dual-port memory window boundary.
  969.  * This function is not atomic, so caller must disable interrupt if
  970.  * interrupt routines are accessing adapter shared memory.
  971.  */
  973. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  974. EXPORT_SYMBOL(sdla_peek);
  975. #endif
  977. int sdla_peek (sdlahw_t* hw, unsigned long addr, void* buf, unsigned len)
  978. {
  980. if (addr + len > hw->memory) /* verify arguments */
  981. return -EINVAL;
  983.         if(hw->type == SDLA_S514) { /* copy data for the S514 adapter */
  984.                 peek_by_4 ((unsigned long)hw->dpmbase + addr, buf, len);
  985.                 return 0;
  986. }
  988.         else { /* copy data for the S508 adapter */
  989.         unsigned long oldvec = hw->vector;
  990.          unsigned winsize = hw->dpmsize;
  991.         unsigned curpos, curlen;   /* current offset and block size */
  992.          unsigned long curvec;      /* current DPM window vector */
  993.         int err = 0;
  995.                 while (len && !err) {
  996.                         curpos = addr % winsize;  /* current window offset */
  997.                         curvec = addr - curpos;   /* current window vector */
  998.                         curlen = (len > (winsize - curpos)) ?
  999. (winsize - curpos) : len;
  1000.                         /* Relocate window and copy block of data */
  1001.                         err = sdla_mapmem(hw, curvec);
  1002.                         peek_by_4 ((unsigned long)hw->dpmbase + curpos, buf,
  1003. curlen);
  1004.                         addr       += curlen;
  1005.                         (char*)buf += curlen;
  1006.                         len        -= curlen;
  1007.                 }
  1009.                 /* Restore DPM window position */
  1010.                 sdla_mapmem(hw, oldvec);
  1011.                 return err;
  1012.         }
  1013. }
  1016. /*============================================================================
  1017.  * Read data from adapter's memory to a data buffer in 4-byte chunks.
  1018.  * Note that we ensure that the SDLA memory address is on a 4-byte boundary
  1019.  * before we begin moving the data in 4-byte chunks.
  1020. */
  1022. static void peek_by_4 (unsigned long src, void* buf, unsigned len)
  1023. {
  1025.         /* byte copy data until we get to a 4-byte boundary */
  1026.         while (len && (src & 0x03)) {
  1027.                 *(char *)buf ++ = readb(src ++);
  1028.                 len --;
  1029.         }
  1031.         /* copy data in 4-byte chunks */
  1032.         while (len >= 4) {
  1033.                 *(unsigned long *)buf = readl(src);
  1034.                 buf += 4;
  1035.                 src += 4;
  1036.                 len -= 4;
  1037.         }
  1039.         /* byte copy any remaining data */
  1040.         while (len) {
  1041.                 *(char *)buf ++ = readb(src ++);
  1042.                 len --;
  1043.         }
  1044. }
  1047. /*============================================================================
  1048.  * Write Absolute Adapter Memory.
  1049.  * Transfer data from data buffer to adapter's memory.
  1050.  *
  1051.  * Note:
  1052.  * Care should be taken when crossing dual-port memory window boundary.
  1053.  * This function is not atomic, so caller must disable interrupt if
  1054.  * interrupt routines are accessing adapter shared memory.
  1055.  */
  1057. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  1058. EXPORT_SYMBOL(sdla_poke);
  1059. #endif
  1060.  
  1061. int sdla_poke (sdlahw_t* hw, unsigned long addr, void* buf, unsigned len)
  1062. {
  1064. if (addr + len > hw->memory) /* verify arguments */
  1065. return -EINVAL;
  1066.    
  1067.         if(hw->type == SDLA_S514) { /* copy data for the S514 adapter */
  1068.                 poke_by_4 ((unsigned long)hw->dpmbase + addr, buf, len);
  1069.                 return 0;
  1070. }
  1072. else { /* copy data for the S508 adapter */
  1073.      unsigned long oldvec = hw->vector;
  1074.         unsigned winsize = hw->dpmsize;
  1075.          unsigned curpos, curlen;     /* current offset and block size */
  1076.          unsigned long curvec;        /* current DPM window vector */
  1077.          int err = 0;
  1079. while (len && !err) {
  1080.                         curpos = addr % winsize;    /* current window offset */
  1081.                         curvec = addr - curpos;     /* current window vector */
  1082.                         curlen = (len > (winsize - curpos)) ?
  1083. (winsize - curpos) : len;
  1084.                         /* Relocate window and copy block of data */
  1085.                         sdla_mapmem(hw, curvec);
  1086.                         poke_by_4 ((unsigned long)hw->dpmbase + curpos, buf,
  1087. curlen);
  1088.                 addr       += curlen;
  1089.                         (char*)buf += curlen;
  1090.                         len        -= curlen;
  1091.                 }
  1093.                 /* Restore DPM window position */
  1094.                 sdla_mapmem(hw, oldvec);
  1095.                 return err;
  1096.         }
  1097. }
  1100. /*============================================================================
  1101.  * Write from a data buffer to adapter's memory in 4-byte chunks.
  1102.  * Note that we ensure that the SDLA memory address is on a 4-byte boundary
  1103.  * before we begin moving the data in 4-byte chunks.
  1104. */
  1106. static void poke_by_4 (unsigned long dest, void* buf, unsigned len)
  1107. {
  1109.         /* byte copy data until we get to a 4-byte boundary */
  1110.         while (len && (dest & 0x03)) {
  1111.                 writeb (*(char *)buf ++, dest ++);
  1112.                 len --;
  1113.         }
  1115.         /* copy data in 4-byte chunks */
  1116.         while (len >= 4) {
  1117.                 writel (*(unsigned long *)buf, dest);
  1118.                 dest += 4;
  1119.                 buf += 4;
  1120.                 len -= 4;
  1121.         }
  1123.         /* byte copy any remaining data */
  1124.         while (len) {
  1125.                 writeb (*(char *)buf ++ , dest ++);
  1126.                 len --;
  1127.         }
  1128. }
  1131. #ifdef DONT_COMPIPLE_THIS
  1132. #endif /* DONT_COMPIPLE_THIS */
  1134. /****** Hardware-Specific Functions *****************************************/
  1136. /*============================================================================
  1137.  * Detect adapter type.
  1138.  * o if adapter type is specified then call detection routine for that adapter
  1139.  *   type.  Otherwise call detection routines for every adapter types until
  1140.  *   adapter is detected.
  1141.  *
  1142.  * Notes:
  1143.  * 1) Detection tests are destructive! Adapter will be left in shutdown state
  1144.  *    after the test.
  1145.  */
  1146. static int sdla_detect (sdlahw_t* hw)
  1147. {
  1148. unsigned port = hw->port;
  1149. int err = 0;
  1151. if (!port && (hw->type != SDLA_S514))
  1152. return -EFAULT;
  1154.      switch (hw->type) {
  1155. case SDLA_S502A:
  1156. if (!detect_s502a(port)) err = -ENODEV;
  1157. break;
  1159. case SDLA_S502E:
  1160. if (!detect_s502e(port)) err = -ENODEV;
  1161. break;
  1163. case SDLA_S503:
  1164. if (!detect_s503(port)) err = -ENODEV;
  1165. break;
  1167. case SDLA_S507:
  1168. if (!detect_s507(port)) err = -ENODEV;
  1169. break;
  1171. case SDLA_S508:
  1172. if (!detect_s508(port)) err = -ENODEV;
  1173. break;
  1175. case SDLA_S514:
  1176.                 if (!detect_s514(hw)) err = -ENODEV;
  1177. break;
  1179. default:
  1180. if (detect_s502a(port))
  1181. hw->type = SDLA_S502A;
  1182. else if (detect_s502e(port))
  1183. hw->type = SDLA_S502E;
  1184. else if (detect_s503(port))
  1185. hw->type = SDLA_S503;
  1186. else if (detect_s507(port))
  1187. hw->type = SDLA_S507;
  1188. else if (detect_s508(port))
  1189. hw->type = SDLA_S508;
  1190. else err = -ENODEV;
  1191. }
  1192. return err;
  1193. }
  1195. /*============================================================================
  1196.  * Autoselect memory region. 
  1197.  * o try all available DMP address options from the top down until success.
  1198.  */
  1199. static int sdla_autodpm (sdlahw_t* hw)
  1200. {
  1201. int i, err = -EINVAL;
  1202. unsigned* opt;
  1204. switch (hw->type) {
  1205. case SDLA_S502A:
  1206. opt = s502a_dpmbase_options;
  1207. break;
  1209. case SDLA_S502E:
  1210. case SDLA_S503:
  1211. case SDLA_S508:
  1212. opt = s508_dpmbase_options;
  1213. break;
  1215. case SDLA_S507:
  1216. opt = s507_dpmbase_options;
  1217. break;
  1219. default:
  1220. return -EINVAL;
  1221. }
  1223. /* Start testing from 8th position, address
  1224.          * 0xC8000 from the 508 address table. 
  1225.          * We don't want to test A**** addresses, since
  1226.          * they are usually used for Video */
  1227. for (i = 8; i <= opt[0] && err; i++) {
  1228. hw->dpmbase = phys_to_virt(opt[i]);
  1229. err = sdla_setdpm(hw);
  1230. }
  1231. return err;
  1232. }
  1234. /*============================================================================
  1235.  * Set up adapter dual-port memory window. 
  1236.  * o shut down adapter
  1237.  * o make sure that no physical memory exists in this region, i.e entire
  1238.  *   region reads 0xFF and is not writable when adapter is shut down.
  1239.  * o initialize adapter hardware
  1240.  * o make sure that region is usable with SDLA card, i.e. we can write to it
  1241.  *   when adapter is configured.
  1242.  */
  1243. static int sdla_setdpm (sdlahw_t* hw)
  1244. {
  1245. int err;
  1247. /* Shut down card and verify memory region */
  1248. sdla_down(hw);
  1249. if (check_memregion(hw->dpmbase, hw->dpmsize))
  1250. return -EINVAL;
  1252. /* Initialize adapter and test on-board memory segment by segment.
  1253.  * If memory size appears to be less than shared memory window size,
  1254.  * assume that memory region is unusable.
  1255.  */
  1256. err = sdla_init(hw);
  1257. if (err) return err;
  1259. if (sdla_memtest(hw) < hw->dpmsize) { /* less than window size */
  1260. sdla_down(hw);
  1261. return -EIO;
  1262. }
  1263. sdla_mapmem(hw, 0L); /* set window vector at bottom */
  1264. return 0;
  1265. }
  1267. /*============================================================================
  1268.  * Load adapter from the memory image of the SDLA firmware module. 
  1269.  * o verify firmware integrity and compatibility
  1270.  * o start adapter up
  1271.  */
  1272. static int sdla_load (sdlahw_t* hw, sfm_t* sfm, unsigned len)
  1273. {
  1275. int i;
  1277. /* Verify firmware signature */
  1278. if (strcmp(sfm->signature, SFM_SIGNATURE)) {
  1279. printk(KERN_INFO "%s: not SDLA firmware!n",
  1280. modname);
  1281. return -EINVAL;
  1282. }
  1284. /* Verify firmware module format version */
  1285. if (sfm->version != SFM_VERSION) {
  1286. printk(KERN_INFO
  1287. "%s: firmware format %u rejected! Expecting %u.n",
  1288. modname, sfm->version, SFM_VERSION);
  1289. return -EINVAL;
  1290. }
  1292. /* Verify firmware module length and checksum */
  1293. if ((len - offsetof(sfm_t, image) != sfm->info.codesize) ||
  1294. (checksum((void*)&sfm->info,
  1295. sizeof(sfm_info_t) + sfm->info.codesize) != sfm->checksum)) {
  1296. printk(KERN_INFO "%s: firmware corrupted!n", modname);
  1297. return -EINVAL;
  1298. }
  1300. /* Announce */
  1301. printk(KERN_INFO "%s: loading %s (ID=%u)...n", modname,
  1302. (sfm->descr[0] != '') ? sfm->descr : "unknown firmware",
  1303. sfm->info.codeid);
  1305. if(hw->type == SDLA_S514)
  1306. printk(KERN_INFO "%s: loading S514 adapter, CPU %cn",
  1307. modname, hw->S514_cpu_no[0]);
  1309. /* Scan through the list of compatible adapters and make sure our
  1310.  * adapter type is listed.
  1311.  */
  1312. for (i = 0;
  1313.      (i < SFM_MAX_SDLA) && (sfm->info.adapter[i] != hw->type);
  1314.      ++i);
  1316. if (i == SFM_MAX_SDLA) {
  1317. printk(KERN_INFO "%s: firmware is not compatible with S%u!n",
  1318. modname, hw->type);
  1319. return -EINVAL;
  1320. }
  1323. /* Make sure there is enough on-board memory */
  1324. if (hw->memory < sfm->info.memsize) {
  1325. printk(KERN_INFO
  1326. "%s: firmware needs %lu bytes of on-board memory!n",
  1327. modname, sfm->info.memsize);
  1328. return -EINVAL;
  1329. }
  1331. /* Move code onto adapter */
  1332. if (sdla_poke(hw, sfm->info.codeoffs, sfm->image, sfm->info.codesize)) {
  1333. printk(KERN_INFO "%s: failed to load code segment!n",
  1334. modname);
  1335. return -EIO;
  1336. }
  1338. /* Prepare boot-time configuration data and kick-off CPU */
  1339. sdla_bootcfg(hw, &sfm->info);
  1340. if (sdla_start(hw, sfm->info.startoffs)) {
  1341. printk(KERN_INFO "%s: Damn... Adapter won't start!n",
  1342. modname);
  1343. return -EIO;
  1344. }
  1346. /* position DPM window over the mailbox and enable interrupts */
  1347.         if (sdla_mapmem(hw, sfm->info.winoffs) || sdla_inten(hw)) {
  1348. printk(KERN_INFO "%s: adapter hardware failure!n",
  1349. modname);
  1350. return -EIO;
  1351. }
  1352. hw->fwid = sfm->info.codeid; /* set firmware ID */
  1353. return 0;
  1354. }
  1356. /*============================================================================
  1357.  * Initialize SDLA hardware: setup memory window, IRQ, etc.
  1358.  */
  1359. static int sdla_init (sdlahw_t* hw)
  1360. {
  1361. int i;
  1363. for (i = 0; i < SDLA_MAXIORANGE; ++i)
  1364. hw->regs[i] = 0;
  1366. switch (hw->type) {
  1367. case SDLA_S502A: return init_s502a(hw);
  1368. case SDLA_S502E: return init_s502e(hw);
  1369. case SDLA_S503:  return init_s503(hw);
  1370. case SDLA_S507:  return init_s507(hw);
  1371. case SDLA_S508:  return init_s508(hw);
  1372. }
  1373. return -EINVAL;
  1374. }
  1376. /*============================================================================
  1377.  * Test adapter on-board memory.
  1378.  * o slide DPM window from the bottom up and test adapter memory segment by
  1379.  *   segment.
  1380.  * Return adapter memory size.
  1381.  */
  1382. static unsigned long sdla_memtest (sdlahw_t* hw)
  1383. {
  1384. unsigned long memsize;
  1385. unsigned winsize;
  1387. for (memsize = 0, winsize = hw->dpmsize;
  1388.      !sdla_mapmem(hw, memsize) &&
  1389. (test_memregion(hw->dpmbase, winsize) == winsize)
  1390.      ;
  1391.      memsize += winsize)
  1392. ;
  1393. hw->memory = memsize;
  1394. return memsize;
  1395. }
  1397. /*============================================================================
  1398.  * Prepare boot-time firmware configuration data.
  1399.  * o position DPM window
  1400.  * o initialize configuration data area
  1401.  */
  1402. static int sdla_bootcfg (sdlahw_t* hw, sfm_info_t* sfminfo)
  1403. {
  1404. unsigned char* data;
  1406. if (!sfminfo->datasize) return 0; /* nothing to do */
  1408. if (sdla_mapmem(hw, sfminfo->dataoffs) != 0)
  1409. return -EIO;
  1411. if(hw->type == SDLA_S514)
  1412.                 data = (void*)(hw->dpmbase + sfminfo->dataoffs);
  1413.         else
  1414.                 data = (void*)((u8 *)hw->dpmbase +
  1415.                         (sfminfo->dataoffs - hw->vector));
  1417. memset_io (data, 0, sfminfo->datasize);
  1419. writeb (make_config_byte(hw), &data[0x00]);
  1421. switch (sfminfo->codeid) {
  1422. case SFID_X25_502:
  1423. case SFID_X25_508:
  1424.                 writeb (3, &data[0x01]);        /* T1 timer */
  1425.                 writeb (10, &data[0x03]);       /* N2 */
  1426.                 writeb (7, &data[0x06]);        /* HDLC window size */
  1427.                 writeb (1, &data[0x0B]);        /* DTE */
  1428.                 writeb (2, &data[0x0C]);        /* X.25 packet window size */
  1429.                 writew (128, &data[0x0D]); /* default X.25 data size */
  1430.                 writew (128, &data[0x0F]); /* maximum X.25 data size */
  1431. break;
  1432. }
  1433. return 0;
  1434. }
  1436. /*============================================================================
  1437.  * Prepare configuration byte identifying adapter type and CPU clock rate.
  1438.  */
  1439. static unsigned char make_config_byte (sdlahw_t* hw)
  1440. {
  1441. unsigned char byte = 0;
  1443. switch (hw->pclk) {
  1444. case 5000:  byte = 0x01; break;
  1445. case 7200:  byte = 0x02; break;
  1446. case 8000:  byte = 0x03; break;
  1447. case 10000: byte = 0x04; break;
  1448. case 16000: byte = 0x05; break;
  1449. }
  1451. switch (hw->type) {
  1452. case SDLA_S502E: byte |= 0x80; break;
  1453. case SDLA_S503:  byte |= 0x40; break;
  1454. }
  1455. return byte;
  1456. }
  1458. /*============================================================================
  1459.  * Start adapter's CPU.
  1460.  * o calculate a pointer to adapter's cold boot entry point
  1461.  * o position DPM window
  1462.  * o place boot instruction (jp addr) at cold boot entry point
  1463.  * o start CPU
  1464.  */
  1465. static int sdla_start (sdlahw_t* hw, unsigned addr)
  1466. {
  1467. unsigned port = hw->port;
  1468. unsigned char *bootp;
  1469. int err, tmp, i;
  1471. if (!port && (hw->type != SDLA_S514)) return -EFAULT;
  1473.   switch (hw->type) {
  1474. case SDLA_S502A:
  1475. bootp = hw->dpmbase;
  1476. bootp += 0x66;
  1477. break;
  1479. case SDLA_S502E:
  1480. case SDLA_S503:
  1481. case SDLA_S507:
  1482. case SDLA_S508:
  1483. case SDLA_S514:
  1484. bootp = hw->dpmbase;
  1485. break;
  1487. default:
  1488. return -EINVAL;
  1489. }
  1491. err = sdla_mapmem(hw, 0);
  1492. if (err) return err;
  1494.        writeb (0xC3, bootp);   /* Z80: 'jp' opcode */
  1495. bootp ++;
  1496. writew (addr, bootp);
  1498. switch (hw->type) {
  1499. case SDLA_S502A:
  1500. _OUTB(port, 0x10); /* issue NMI to CPU */
  1501. hw->regs[0] = 0x10;
  1502. break;
  1504. case SDLA_S502E:
  1505. _OUTB(port + 3, 0x01); /* start CPU */
  1506. hw->regs[3] = 0x01;
  1507. for (i = 0; i < SDLA_IODELAY; ++i);
  1508. if (_INB(port) & 0x01) { /* verify */
  1509. /*
  1510.  * Enabling CPU changes functionality of the
  1511.  * control register, so we have to reset its
  1512.  * mirror.
  1513.  */
  1514. _OUTB(port, 0); /* disable interrupts */
  1515. hw->regs[0] = 0;
  1516. }
  1517. else return -EIO;
  1518. break;
  1520. case SDLA_S503:
  1521. tmp = hw->regs[0] | 0x09; /* set bits 0 and 3 */
  1522. _OUTB(port, tmp);
  1523. hw->regs[0] = tmp; /* update mirror */
  1524. for (i = 0; i < SDLA_IODELAY; ++i);
  1525. if (!(_INB(port) & 0x01)) /* verify */
  1526. return -EIO;
  1527. break;
  1529. case SDLA_S507:
  1530. tmp = hw->regs[0] | 0x02;
  1531. _OUTB(port, tmp);
  1532. hw->regs[0] = tmp; /* update mirror */
  1533. for (i = 0; i < SDLA_IODELAY; ++i);
  1534. if (!(_INB(port) & 0x04)) /* verify */
  1535. return -EIO;
  1536. break;
  1538. case SDLA_S508:
  1539. tmp = hw->regs[0] | 0x02;
  1540. _OUTB(port, tmp);
  1541. hw->regs[0] = tmp; /* update mirror */
  1542. for (i = 0; i < SDLA_IODELAY; ++i);
  1543. if (!(_INB(port + 1) & 0x02)) /* verify */
  1544. return -EIO;
  1545. break;
  1547. case SDLA_S514:
  1548. writeb (S514_CPU_START, hw->vector);
  1549. break;
  1551. default:
  1552. return -EINVAL;
  1553. }
  1554. return 0;
  1555. }
  1557. /*============================================================================
  1558.  * Initialize S502A adapter.
  1559.  */
  1560. static int init_s502a (sdlahw_t* hw)
  1561. {
  1562. unsigned port = hw->port;
  1563. int tmp, i;
  1565. if (!detect_s502a(port))
  1566. return -ENODEV;
  1568. hw->regs[0] = 0x08;
  1569. hw->regs[1] = 0xFF;
  1571. /* Verify configuration options */
  1572. i = get_option_index(s502a_dpmbase_options, virt_to_phys(hw->dpmbase));
  1573. if (i == 0)
  1574. return -EINVAL;
  1576. tmp = s502a_hmcr[i - 1];
  1577. switch (hw->dpmsize) {
  1578. case 0x2000:
  1579. tmp |= 0x01;
  1580. break;
  1582. case 0x10000L:
  1583. break;
  1585. default:
  1586. return -EINVAL;
  1587. }
  1589. /* Setup dual-port memory window (this also enables memory access) */
  1590. _OUTB(port + 1, tmp);
  1591. hw->regs[1] = tmp;
  1592. hw->regs[0] = 0x08;
  1593. return 0;
  1594. }
  1596. /*============================================================================
  1597.  * Initialize S502E adapter.
  1598.  */
  1599. static int init_s502e (sdlahw_t* hw)
  1600. {
  1601. unsigned port = hw->port;
  1602. int tmp, i;
  1604. if (!detect_s502e(port))
  1605. return -ENODEV;
  1607. /* Verify configuration options */
  1608. i = get_option_index(s508_dpmbase_options, virt_to_phys(hw->dpmbase));
  1609. if (i == 0)
  1610. return -EINVAL;
  1612. tmp = s502e_hmcr[i - 1];
  1613. switch (hw->dpmsize) {
  1614. case 0x2000:
  1615. tmp |= 0x01;
  1616. break;
  1618. case 0x10000L:
  1619. break;
  1621. default:
  1622. return -EINVAL;
  1623. }
  1625. /* Setup dual-port memory window */
  1626. _OUTB(port + 1, tmp);
  1627. hw->regs[1] = tmp;
  1629. /* Enable memory access */
  1630. _OUTB(port, 0x02);
  1631. hw->regs[0] = 0x02;
  1632. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1633. return (_INB(port) & 0x02) ? 0 : -EIO;
  1634. }
  1636. /*============================================================================
  1637.  * Initialize S503 adapter.
  1638.  * ---------------------------------------------------------------------------
  1639.  */
  1640. static int init_s503 (sdlahw_t* hw)
  1641. {
  1642. unsigned port = hw->port;
  1643. int tmp, i;
  1645. if (!detect_s503(port))
  1646. return -ENODEV;
  1648. /* Verify configuration options */
  1649. i = get_option_index(s508_dpmbase_options, virt_to_phys(hw->dpmbase));
  1650. if (i == 0)
  1651. return -EINVAL;
  1653. tmp = s502e_hmcr[i - 1];
  1654. switch (hw->dpmsize) {
  1655. case 0x2000:
  1656. tmp |= 0x01;
  1657. break;
  1659. case 0x10000L:
  1660. break;
  1662. default:
  1663. return -EINVAL;
  1664. }
  1666. /* Setup dual-port memory window */
  1667. _OUTB(port + 1, tmp);
  1668. hw->regs[1] = tmp;
  1670. /* Enable memory access */
  1671. _OUTB(port, 0x02);
  1672. hw->regs[0] = 0x02; /* update mirror */
  1673. return 0;
  1674. }
  1676. /*============================================================================
  1677.  * Initialize S507 adapter.
  1678.  */
  1679. static int init_s507 (sdlahw_t* hw)
  1680. {
  1681. unsigned port = hw->port;
  1682. int tmp, i;
  1684. if (!detect_s507(port))
  1685. return -ENODEV;
  1687. /* Verify configuration options */
  1688. i = get_option_index(s507_dpmbase_options, virt_to_phys(hw->dpmbase));
  1689. if (i == 0)
  1690. return -EINVAL;
  1692. tmp = s507_hmcr[i - 1];
  1693. switch (hw->dpmsize) {
  1694. case 0x2000:
  1695. tmp |= 0x01;
  1696. break;
  1698. case 0x10000L:
  1699. break;
  1701. default:
  1702. return -EINVAL;
  1703. }
  1705. /* Enable adapter's logic */
  1706. _OUTB(port, 0x01);
  1707. hw->regs[0] = 0x01;
  1708. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1709. if (!(_INB(port) & 0x20))
  1710. return -EIO;
  1712. /* Setup dual-port memory window */
  1713. _OUTB(port + 1, tmp);
  1714. hw->regs[1] = tmp;
  1716. /* Enable memory access */
  1717. tmp = hw->regs[0] | 0x04;
  1718. if (hw->irq) {
  1719. i = get_option_index(s508_irq_options, hw->irq);
  1720. if (i) tmp |= s507_irqmask[i - 1];
  1721. }
  1722. _OUTB(port, tmp);
  1723. hw->regs[0] = tmp; /* update mirror */
  1724. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1725. return (_INB(port) & 0x08) ? 0 : -EIO;
  1726. }
  1728. /*============================================================================
  1729.  * Initialize S508 adapter.
  1730.  */
  1731. static int init_s508 (sdlahw_t* hw)
  1732. {
  1733. unsigned port = hw->port;
  1734. int tmp, i;
  1736. if (!detect_s508(port))
  1737. return -ENODEV;
  1739. /* Verify configuration options */
  1740. i = get_option_index(s508_dpmbase_options, virt_to_phys(hw->dpmbase));
  1741. if (i == 0)
  1742. return -EINVAL;
  1744. /* Setup memory configuration */
  1745. tmp = s508_hmcr[i - 1];
  1746. _OUTB(port + 1, tmp);
  1747. hw->regs[1] = tmp;
  1749. /* Enable memory access */
  1750. _OUTB(port, 0x04);
  1751. hw->regs[0] = 0x04; /* update mirror */
  1752. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1753. return (_INB(port + 1) & 0x04) ? 0 : -EIO;
  1754. }
  1756. /*============================================================================
  1757.  * Detect S502A adapter.
  1758.  * Following tests are used to detect S502A adapter:
  1759.  * 1. All registers other than status (BASE) should read 0xFF
  1760.  * 2. After writing 00001000b to control register, status register should
  1761.  *    read 01000000b.
  1762.  * 3. After writing 0 to control register, status register should still
  1763.  *    read  01000000b.
  1764.  * 4. After writing 00000100b to control register, status register should
  1765.  *    read 01000100b.
  1766.  * Return 1 if detected o.k. or 0 if failed.
  1767.  * Note: This test is destructive! Adapter will be left in shutdown
  1768.  * state after the test.
  1769.  */
  1770. static int detect_s502a (int port)
  1771. {
  1772. int i, j;
  1774. if (!get_option_index(s502_port_options, port))
  1775. return 0;
  1777. for (j = 1; j < SDLA_MAXIORANGE; ++j) {
  1778. if (_INB(port + j) != 0xFF)
  1779. return 0;
  1780. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1781. }
  1783. _OUTB(port, 0x08); /* halt CPU */
  1784. _OUTB(port, 0x08);
  1785. _OUTB(port, 0x08);
  1786. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1787. if (_INB(port) != 0x40)
  1788. return 0;
  1789. _OUTB(port, 0x00);
  1790. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1791. if (_INB(port) != 0x40)
  1792. return 0;
  1793. _OUTB(port, 0x04);
  1794. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1795. if (_INB(port) != 0x44)
  1796. return 0;
  1798. /* Reset adapter */
  1799. _OUTB(port, 0x08);
  1800. _OUTB(port, 0x08);
  1801. _OUTB(port, 0x08);
  1802. _OUTB(port + 1, 0xFF);
  1803. return 1;
  1804. }
  1806. /*============================================================================
  1807.  * Detect S502E adapter.
  1808.  * Following tests are used to verify adapter presence:
  1809.  * 1. All registers other than status (BASE) should read 0xFF.
  1810.  * 2. After writing 0 to CPU control register (BASE+3), status register
  1811.  *    (BASE) should read 11111000b.
  1812.  * 3. After writing 00000100b to port BASE (set bit 2), status register
  1813.  *    (BASE) should read 11111100b.
  1814.  * Return 1 if detected o.k. or 0 if failed.
  1815.  * Note: This test is destructive! Adapter will be left in shutdown
  1816.  * state after the test.
  1817.  */
  1818. static int detect_s502e (int port)
  1819. {
  1820. int i, j;
  1822. if (!get_option_index(s502_port_options, port))
  1823. return 0;
  1824. for (j = 1; j < SDLA_MAXIORANGE; ++j) {
  1825. if (_INB(port + j) != 0xFF)
  1826. return 0;
  1827. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1828. }
  1830. _OUTB(port + 3, 0); /* CPU control reg. */
  1831. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1832. if (_INB(port) != 0xF8) /* read status */
  1833. return 0;
  1834. _OUTB(port, 0x04); /* set bit 2 */
  1835. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1836. if (_INB(port) != 0xFC) /* verify */
  1837. return 0;
  1839. /* Reset adapter */
  1840. _OUTB(port, 0);
  1841. return 1;
  1842. }
  1844. /*============================================================================
  1845.  * Detect s503 adapter.
  1846.  * Following tests are used to verify adapter presence:
  1847.  * 1. All registers other than status (BASE) should read 0xFF.
  1848.  * 2. After writing 0 to control register (BASE), status register (BASE)
  1849.  *    should read 11110000b.
  1850.  * 3. After writing 00000100b (set bit 2) to control register (BASE),
  1851.  *    status register should read 11110010b.
  1852.  * Return 1 if detected o.k. or 0 if failed.
  1853.  * Note: This test is destructive! Adapter will be left in shutdown
  1854.  * state after the test.
  1855.  */
  1856. static int detect_s503 (int port)
  1857. {
  1858. int i, j;
  1860. if (!get_option_index(s503_port_options, port))
  1861. return 0;
  1862. for (j = 1; j < SDLA_MAXIORANGE; ++j) {
  1863. if (_INB(port + j) != 0xFF)
  1864. return 0;
  1865. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1866. }
  1868. _OUTB(port, 0); /* reset control reg.*/
  1869. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1870. if (_INB(port) != 0xF0) /* read status */
  1871. return 0;
  1872. _OUTB(port, 0x04); /* set bit 2 */
  1873. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1874. if (_INB(port) != 0xF2) /* verify */
  1875. return 0;
  1877. /* Reset adapter */
  1878. _OUTB(port, 0);
  1879. return 1;
  1880. }
  1882. /*============================================================================
  1883.  * Detect s507 adapter.
  1884.  * Following tests are used to detect s507 adapter:
  1885.  * 1. All ports should read the same value.
  1886.  * 2. After writing 0x00 to control register, status register should read
  1887.  *    ?011000?b.
  1888.  * 3. After writing 0x01 to control register, status register should read
  1889.  *    ?011001?b.
  1890.  * Return 1 if detected o.k. or 0 if failed.
  1891.  * Note: This test is destructive! Adapter will be left in shutdown
  1892.  * state after the test.
  1893.  */
  1894. static int detect_s507 (int port)
  1895. {
  1896. int tmp, i, j;
  1898. if (!get_option_index(s508_port_options, port))
  1899. return 0;
  1900. tmp = _INB(port);
  1901. for (j = 1; j < S507_IORANGE; ++j) {
  1902. if (_INB(port + j) != tmp)
  1903. return 0;
  1904. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1905. }
  1907. _OUTB(port, 0x00);
  1908. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1909. if ((_INB(port) & 0x7E) != 0x30)
  1910. return 0;
  1911. _OUTB(port, 0x01);
  1912. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1913. if ((_INB(port) & 0x7E) != 0x32)
  1914. return 0;
  1916. /* Reset adapter */
  1917. _OUTB(port, 0x00);
  1918. return 1;
  1919. }
  1921. /*============================================================================
  1922.  * Detect s508 adapter.
  1923.  * Following tests are used to detect s508 adapter:
  1924.  * 1. After writing 0x00 to control register, status register should read
  1925.  *    ??000000b.
  1926.  * 2. After writing 0x10 to control register, status register should read
  1927.  *    ??010000b
  1928.  * Return 1 if detected o.k. or 0 if failed.
  1929.  * Note: This test is destructive! Adapter will be left in shutdown
  1930.  * state after the test.
  1931.  */
  1932. static int detect_s508 (int port)
  1933. {
  1934. int i;
  1936. if (!get_option_index(s508_port_options, port))
  1937. return 0;
  1938. _OUTB(port, 0x00);
  1939. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1940. if ((_INB(port + 1) & 0x3F) != 0x00)
  1941. return 0;
  1942. _OUTB(port, 0x10);
  1943. for (i = 0; i < SDLA_IODELAY; ++i); /* delay */
  1944. if ((_INB(port + 1) & 0x3F) != 0x10)
  1945. return 0;
  1947. /* Reset adapter */
  1948. _OUTB(port, 0x00);
  1949. return 1;
  1950. }
  1952. /*============================================================================
  1953.  * Detect s514 PCI adapter.
  1954.  *      Return 1 if detected o.k. or 0 if failed.
  1955.  *      Note:   This test is destructive! Adapter will be left in shutdown
  1956.  *              state after the test.
  1957.  */
  1958. static int detect_s514 (sdlahw_t* hw)
  1959. {
  1960. unsigned char CPU_no, slot_no, auto_slot_cfg;
  1961. int number_S514_cards = 0;
  1962. u32 S514_mem_base_addr = 0;
  1963. u32 ut_u32;
  1965. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  1966. struct pci_dev *pci_dev;
  1967. #else
  1968. u8 ut_u8;
  1969. #endif
  1972. #ifdef CONFIG_PCI
  1973. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  1974.         if(!pci_present())
  1975. #else
  1976. if(!pcibios_present())
  1977. #endif
  1978.         {
  1979.                 printk(KERN_INFO "%s: PCI BIOS not present!n", modname);
  1980.                 return 0;
  1981.         }
  1982. #else
  1983.         printk(KERN_INFO "%s: Linux not compiled for PCI usage!n", modname);
  1984.         return 0;
  1985. #endif
  1987. /*
  1988. The 'setup()' procedure in 'sdlamain.c' passes the CPU number and the
  1989. slot number defined in 'router.conf' via the 'port' definition.
  1990. */
  1991. CPU_no = hw->S514_cpu_no[0];
  1992. slot_no = hw->S514_slot_no;
  1993. auto_slot_cfg = hw->auto_pci_cfg;
  1995. if (auto_slot_cfg){
  1996. printk(KERN_INFO "%s: srch... S514 card, CPU %c, Slot=Auton",
  1997. modname, CPU_no);
  1999. }else{
  2000. printk(KERN_INFO "%s: srch... S514 card, CPU %c, Slot #%dn",
  2001. modname, CPU_no, slot_no);
  2002. }
  2004. /* check to see that CPU A or B has been selected in 'router.conf' */
  2005. switch(CPU_no) {
  2006. case S514_CPU_A:
  2007. case S514_CPU_B:
  2008. break;
  2010. default:
  2011. printk(KERN_INFO "%s: S514 CPU definition invalid.n", 
  2012. modname);
  2013. printk(KERN_INFO "Must be 'A' or 'B'n");
  2014. return 0;
  2015. }
  2017. number_S514_cards = find_s514_adapter(hw, 0);
  2018. if(!number_S514_cards)
  2019. return 0;
  2021. /* we are using a single S514 adapter with a slot of 0 so re-read the */
  2022. /* location of this adapter */
  2023. if((number_S514_cards == 1) && auto_slot_cfg) {
  2024.          number_S514_cards = find_s514_adapter(hw, 1);
  2025. if(!number_S514_cards) {
  2026. printk(KERN_INFO "%s: Error finding PCI cardn",
  2027. modname);
  2028. return 0;
  2029. }
  2030. }
  2032.       #if defined(LINUX_2_4)
  2033. pci_dev = hw->pci_dev;
  2034. /* read the physical memory base address */
  2035. S514_mem_base_addr = (CPU_no == S514_CPU_A) ? 
  2036. (pci_dev->resource[1].start) :
  2037. (pci_dev->resource[2].start);
  2039.       #elif defined (LINUX_2_1)
  2040. pci_dev = hw->pci_dev;
  2041. /* read the physical memory base address */
  2042. S514_mem_base_addr = (CPU_no == S514_CPU_A) ? 
  2043. (pci_dev->base_address[1] & PCI_BASE_ADDRESS_MEM_MASK) :
  2044. (pci_dev->base_address[2] & PCI_BASE_ADDRESS_MEM_MASK);
  2046.       #else
  2047. pcibios_read_config_dword(hw->pci_bus, hw->pci_dev_func,
  2048. (CPU_no == S514_CPU_A) ? PCI_MEM_BASE0_DWORD :
  2049. PCI_MEM_BASE1_DWORD, &S514_mem_base_addr);
  2050.       #endif
  2052. printk(KERN_INFO "%s: S514 PCI memory at 0x%Xn",
  2053. modname, S514_mem_base_addr);
  2054. if(!S514_mem_base_addr) {
  2055. if(CPU_no == S514_CPU_B)
  2056. printk(KERN_INFO "%s: CPU #B not present on the cardn",  modname);
  2057. else
  2058. printk(KERN_INFO "%s: No PCI memory allocated to cardn", modname);
  2059. return 0;
  2060. }
  2062. /* enable the PCI memory */
  2063. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  2064. pci_read_config_dword(pci_dev, 
  2065. (CPU_no == S514_CPU_A) ? PCI_MAP0_DWORD : PCI_MAP1_DWORD,
  2066. &ut_u32);
  2067. pci_write_config_dword(pci_dev,
  2068. (CPU_no == S514_CPU_A) ? PCI_MAP0_DWORD : PCI_MAP1_DWORD,
  2069. (ut_u32 | PCI_MEMORY_ENABLE));
  2070. #else
  2071.         pcibios_read_config_dword(hw->pci_bus, hw->pci_dev_func,
  2072. (CPU_no == S514_CPU_A) ? PCI_MAP0_DWORD : PCI_MAP1_DWORD,
  2073. &ut_u32); 
  2074.         pcibios_write_config_dword(hw->pci_bus, hw->pci_dev_func,
  2075. (CPU_no == S514_CPU_A) ? PCI_MAP0_DWORD : PCI_MAP1_DWORD,
  2076. (ut_u32 | PCI_MEMORY_ENABLE));
  2077. #endif
  2079. /* check the IRQ allocated and enable IRQ usage */
  2080. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  2081. if(!(hw->irq = pci_dev->irq)) {
  2082. printk(KERN_INFO "%s: IRQ not allocated to S514 adaptern",
  2083. modname);
  2084.                 return 0;
  2085. }
  2087. /* BUG FIX : Mar 6 2000
  2088.    * On a initial loading of the card, we must check
  2089.          * and clear PCI interrupt bits, due to a reset
  2090.          * problem on some other boards.  i.e. An interrupt
  2091.          * might be pending, even after system bootup, 
  2092.          * in which case, when starting wanrouter the machine
  2093.          * would crash. 
  2094.  */
  2095. if (init_pci_slot(hw))
  2096. return 0;
  2098.         pci_read_config_dword(pci_dev, PCI_INT_CONFIG, &ut_u32);
  2099.         ut_u32 |= (CPU_no == S514_CPU_A) ?
  2100.                 PCI_ENABLE_IRQ_CPU_A : PCI_ENABLE_IRQ_CPU_B;
  2101.         pci_write_config_dword(pci_dev, PCI_INT_CONFIG, ut_u32);
  2102. #else
  2103. /* the INTPIN must not be 0 - if it is, then the S514 adapter is not */
  2104. /* configured for IRQ usage */
  2105. pcibios_read_config_byte(hw->pci_bus, hw->pci_dev_func,
  2106. PCI_INT_PIN_BYTE, &ut_u8);
  2107.         if(!ut_u8) {
  2108.                 printk(KERN_INFO "%s: invalid setting for INTPIN on S514 cardn", modname);
  2109.                 printk(KERN_INFO "Please contact your Sangoma representativen");
  2110.                 return 0;
  2111.         }
  2112.         pcibios_read_config_byte(hw->pci_bus, hw->pci_dev_func,
  2113. PCI_INT_LINE_BYTE, (unsigned char *)&hw->irq);
  2114.         if(hw->irq == PCI_IRQ_NOT_ALLOCATED) {
  2115.                 printk(KERN_INFO "%s: IRQ not allocated to S514 adaptern",
  2116. modname);
  2117.                 return 0;
  2118.         }
  2119. pcibios_read_config_dword(hw->pci_bus, hw->pci_dev_func, PCI_INT_CONFIG, &ut_u32);
  2120. ut_u32 |= (CPU_no == S514_CPU_A) ?
  2121. PCI_ENABLE_IRQ_CPU_A : PCI_ENABLE_IRQ_CPU_B;
  2122.         pcibios_write_config_dword(hw->pci_bus, hw->pci_dev_func, 
  2123. PCI_INT_CONFIG, ut_u32);
  2124. #endif
  2126. printk(KERN_INFO "%s: IRQ %d allocated to the S514 cardn",
  2127. modname, hw->irq);
  2129. /* map the physical PCI memory to virtual memory */
  2130. (void *)hw->dpmbase = ioremap((unsigned long)S514_mem_base_addr,
  2131. (unsigned long)MAX_SIZEOF_S514_MEMORY);
  2132.      /* map the physical control register memory to virtual memory */
  2133. (void *)hw->vector = ioremap(
  2134. (unsigned long)(S514_mem_base_addr + S514_CTRL_REG_BYTE),
  2135. (unsigned long)16);
  2136.      
  2137.         if(!hw->dpmbase || !hw->vector) {
  2138. printk(KERN_INFO "%s: PCI virtual memory allocation failedn",
  2139. modname);
  2140.                 return 0;
  2141. }
  2143. /* halt the adapter */
  2144. writeb (S514_CPU_HALT, hw->vector);
  2146. return 1;
  2147. }
  2149. /*============================================================================
  2150.  * Find the S514 PCI adapter in the PCI bus.
  2151.  *      Return the number of S514 adapters found (0 if no adapter found).
  2152.  */
  2153. static int find_s514_adapter(sdlahw_t* hw, char find_first_S514_card)
  2154. {
  2155.         unsigned char slot_no;
  2156.         int number_S514_cards = 0;
  2157. char S514_found_in_slot = 0;
  2158.         u16 PCI_subsys_vendor;
  2160. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  2161.         struct pci_dev *pci_dev = NULL;
  2162. #else
  2163.         int pci_index;
  2164. #endif
  2165.  
  2166.        slot_no = hw->S514_slot_no;
  2167.   
  2168. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  2169. while ((pci_dev = pci_find_device(V3_VENDOR_ID, V3_DEVICE_ID, pci_dev))
  2170.          != NULL) {
  2171.                 
  2172. pci_read_config_word(pci_dev, PCI_SUBSYS_VENDOR_WORD,
  2173.                         &PCI_subsys_vendor);
  2174.                 
  2175. if(PCI_subsys_vendor != SANGOMA_SUBSYS_VENDOR)
  2176.                  continue;
  2177.         
  2178. hw->pci_dev = pci_dev;
  2180. if(find_first_S514_card)
  2181. return(1);
  2183.                 number_S514_cards ++;
  2184.                 
  2185. printk(KERN_INFO
  2186. "%s: S514 card found, slot #%d (devfn 0x%X)n",
  2187.                         modname, ((pci_dev->devfn >> 3) & PCI_DEV_SLOT_MASK),
  2188. pci_dev->devfn);
  2190. if (hw->auto_pci_cfg){
  2191. hw->S514_slot_no = ((pci_dev->devfn >> 3) & PCI_DEV_SLOT_MASK);
  2192. slot_no = hw->S514_slot_no;
  2194. }else if (((pci_dev->devfn >> 3) & PCI_DEV_SLOT_MASK) == slot_no){
  2195.                         S514_found_in_slot = 1;
  2196.                         break;
  2197.                 }
  2198.         }
  2200. #else
  2201. //LINUX VERSION 2.0.X 
  2202.         for (pci_index = 0; pci_index < MAX_S514_CARDS; pci_index ++) {
  2203.                 if (pcibios_find_device(V3_VENDOR_ID, V3_DEVICE_ID, pci_index,
  2204.                         &hw->pci_bus, &hw->pci_dev_func)!=PCIBIOS_SUCCESSFUL) {
  2205.                                 break;
  2206.                 }
  2207.                 
  2208. pcibios_read_config_word(hw->pci_bus, hw->pci_dev_func,
  2209.                         PCI_SUBSYS_VENDOR_WORD, &PCI_subsys_vendor);
  2210.                 
  2211. if (PCI_subsys_vendor != SANGOMA_SUBSYS_VENDOR)
  2212.                         continue;
  2213.                 
  2214. if (find_first_S514_card)
  2215.                         return(1);
  2216.            
  2217. number_S514_cards ++;
  2219.                 printk(KERN_INFO "%s: S514 card found, bus #%d, slot #%dn",
  2220.                         modname, hw->pci_bus,
  2221.                         ((hw->pci_dev_func >> 3) & PCI_DEV_SLOT_MASK));
  2223. if (hw->auto_pci_cfg){
  2224. hw->S514_slot_no = ((hw->pci_dev_func >> 3) & PCI_DEV_SLOT_MASK)
  2225. slot_no = hw->S514_slot_no;
  2227. }else if (((hw->pci_dev_func >> 3) & PCI_DEV_SLOT_MASK) == slot_no) {
  2228.                         S514_found_in_slot = 1;
  2229.                         break;
  2230.                 }
  2231.         }
  2232. #endif
  2234. /* if no S514 adapter has been found, then exit */
  2235.         if (!number_S514_cards) {
  2236.                 printk(KERN_INFO "%s: Error, no S514 adapters foundn", modname);
  2237.                 return 0;
  2238.         }
  2239.         /* 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 */
  2240.         else if ((number_S514_cards > 1) && hw->auto_pci_cfg) {
  2241.                 printk(KERN_INFO "%s: Error, PCI Slot autodetect Failed! n"
  2242.  "%s:        More than one S514 adapter found.n"
  2243.  "%s:        Disable the Autodetect feature and supplyn"
  2244.  "%s:        the PCISLOT numbers for each card.n",
  2245.                         modname,modname,modname,modname);
  2246.                 return 0;
  2247.         }
  2248.         /* if the user has specified a slot number and the S514 adapter has */
  2249.         /* not been found in that slot, then exit */
  2250.         else if (!hw->auto_pci_cfg && !S514_found_in_slot) {
  2251.                 printk(KERN_INFO
  2252. "%s: Error, S514 card not found in specified slot #%dn",
  2253.                         modname, slot_no);
  2254.                 return 0;
  2255.         }
  2257. return (number_S514_cards);
  2258. }
  2262. /******* Miscellaneous ******************************************************/
  2264. /*============================================================================
  2265.  * Calibrate SDLA memory access delay.
  2266.  * Count number of idle loops made within 1 second and then calculate the
  2267.  * number of loops that should be made to achive desired delay.
  2268.  */
  2269. static int calibrate_delay (int mks)
  2270. {
  2271. unsigned int delay;
  2272. unsigned long stop;
  2274. for (delay = 0, stop = SYSTEM_TICK + HZ; SYSTEM_TICK < stop; ++delay);
  2275. return (delay/(1000000L/mks) + 1);
  2276. }
  2278. /*============================================================================
  2279.  * Get option's index into the options list.
  2280.  * Return option's index (1 .. N) or zero if option is invalid.
  2281.  */
  2282. static int get_option_index (unsigned* optlist, unsigned optval)
  2283. {
  2284. int i;
  2286. for (i = 1; i <= optlist[0]; ++i)
  2287. if ( optlist[i] == optval)
  2288. return i;
  2289. return 0;
  2290. }
  2292. /*============================================================================
  2293.  * Check memory region to see if it's available. 
  2294.  * Return: 0 ok.
  2295.  */
  2296. static unsigned check_memregion (void* ptr, unsigned len)
  2297. {
  2298. volatile unsigned char* p = ptr;
  2300.         for (; len && (readb (p) == 0xFF); --len, ++p) {
  2301.                 writeb (0, p);          /* attempt to write 0 */
  2302.                 if (readb(p) != 0xFF) { /* still has to read 0xFF */
  2303.                         writeb (0xFF, p);/* restore original value */
  2304.                         break;          /* not good */
  2305.                 }
  2306.         }
  2308. return len;
  2309. }
  2311. /*============================================================================
  2312.  * Test memory region.
  2313.  * Return: size of the region that passed the test.
  2314.  * Note: Region size must be multiple of 2 !
  2315.  */
  2316. static unsigned test_memregion (void* ptr, unsigned len)
  2317. {
  2318. volatile unsigned short* w_ptr;
  2319. unsigned len_w = len >> 1; /* region len in words */
  2320. unsigned i;
  2322.         for (i = 0, w_ptr = ptr; i < len_w; ++i, ++w_ptr)
  2323.                 writew (0xAA55, w_ptr);
  2324.         
  2325. for (i = 0, w_ptr = ptr; i < len_w; ++i, ++w_ptr)
  2326.                 if (readw (w_ptr) != 0xAA55) {
  2327.                         len_w = i;
  2328.                         break;
  2329.                 }
  2331.         for (i = 0, w_ptr = ptr; i < len_w; ++i, ++w_ptr)
  2332.                 writew (0x55AA, w_ptr);
  2333.         
  2334.         for (i = 0, w_ptr = ptr; i < len_w; ++i, ++w_ptr)
  2335.                 if (readw(w_ptr) != 0x55AA) {
  2336.                         len_w = i;
  2337.                         break;
  2338.                 }
  2339.         
  2340.         for (i = 0, w_ptr = ptr; i < len_w; ++i, ++w_ptr)
  2341. writew (0, w_ptr);
  2343.         return len_w << 1;
  2344. }
  2346. /*============================================================================
  2347.  * Calculate 16-bit CRC using CCITT polynomial.
  2348.  */
  2349. static unsigned short checksum (unsigned char* buf, unsigned len)
  2350. {
  2351. unsigned short crc = 0;
  2352. unsigned mask, flag;
  2354. for (; len; --len, ++buf) {
  2355. for (mask = 0x80; mask; mask >>= 1) {
  2356. flag = (crc & 0x8000);
  2357. crc <<= 1;
  2358. crc |= ((*buf & mask) ? 1 : 0);
  2359. if (flag) crc ^= 0x1021;
  2360. }
  2361. }
  2362. return crc;
  2363. }
  2365. static int init_pci_slot(sdlahw_t *hw)
  2366. {
  2368. u32 int_status;
  2369. int volatile found=0;
  2370. int i=0;
  2372. /* Check if this is a very first load for a specific
  2373.          * pci card. If it is, clear the interrput bits, and
  2374.          * set the flag indicating that this card was initialized.
  2375.  */
  2377. for (i=0; (i<MAX_S514_CARDS) && !found; i++){
  2378. if (pci_slot_ar[i] == hw->S514_slot_no){
  2379. found=1;
  2380. break;
  2381. }
  2382. if (pci_slot_ar[i] == 0xFF){
  2383. break;
  2384. }
  2385. }
  2387. if (!found){
  2388. read_S514_int_stat(hw,&int_status);
  2389. S514_intack(hw,int_status);
  2390. if (i == MAX_S514_CARDS){
  2391. printk(KERN_INFO "%s: Critical Error !!!n",modname);
  2392. printk(KERN_INFO 
  2393. "%s: Number of Sangoma PCI cards exceeded maximum limit.n",
  2394. modname);
  2395. printk(KERN_INFO "Please contact Sangoma Technologiesn");
  2396. return 1;
  2397. }
  2398. pci_slot_ar[i] = hw->S514_slot_no;
  2399. }
  2400. return 0;
  2401. }
  2403. static int pci_probe(sdlahw_t *hw)
  2404. {
  2406.         unsigned char slot_no;
  2407.         int number_S514_cards = 0;
  2408.         u16 PCI_subsys_vendor;
  2409. u16 PCI_card_type;
  2411. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  2412.         struct pci_dev *pci_dev = NULL;
  2413. struct pci_bus *bus = NULL;
  2414. #else
  2415.         int pci_index;
  2416. u8 irq;
  2417. #endif
  2418.  
  2419.        slot_no = 0;
  2420.   
  2421. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  2422. while ((pci_dev = pci_find_device(V3_VENDOR_ID, V3_DEVICE_ID, pci_dev))
  2423.          != NULL) {
  2425.                 pci_read_config_word(pci_dev, PCI_SUBSYS_VENDOR_WORD,
  2426.                         &PCI_subsys_vendor);
  2428.                 if(PCI_subsys_vendor != SANGOMA_SUBSYS_VENDOR)
  2429.                  continue;
  2431. pci_read_config_word(pci_dev, PCI_CARD_TYPE,
  2432.                         &PCI_card_type);
  2434. bus = pci_dev->bus;
  2436. /* A dual cpu card can support up to 4 physical connections,
  2437.  * where a single cpu card can support up to 2 physical
  2438.  * connections.  The FT1 card can only support a single 
  2439.  * connection, however we cannot distinguish between a Single
  2440.  * CPU card and an FT1 card. */
  2441. if (PCI_card_type == S514_DUAL_CPU){
  2442.                  number_S514_cards += 4;
  2443.  printk(KERN_INFO
  2444. "wanpipe: S514-PCI card found, cpu(s) 2, bus #%d, slot #%d, irq #%dn",
  2445.                          bus->number,((pci_dev->devfn >> 3) & PCI_DEV_SLOT_MASK),
  2446. pci_dev->irq);
  2447. }else{
  2448. number_S514_cards += 2;
  2449. printk(KERN_INFO
  2450. "wanpipe: S514-PCI card found, cpu(s) 1, bus #%d, slot #%d, irq #%dn",
  2451.                          bus->number,((pci_dev->devfn >> 3) & PCI_DEV_SLOT_MASK),
  2452. pci_dev->irq);
  2453. }
  2454.         }
  2456. #else
  2457.         for (pci_index = 0; pci_index < MAX_S514_CARDS; pci_index ++) {
  2459.                 if(pcibios_find_device(V3_VENDOR_ID, V3_DEVICE_ID, pci_index,
  2460.                         &hw->pci_bus, &hw->pci_dev_func)!=PCIBIOS_SUCCESSFUL) {
  2461.                                 break;
  2462.                 }
  2463.                 pcibios_read_config_word(hw->pci_bus, hw->pci_dev_func,
  2464.                         PCI_SUBSYS_VENDOR_WORD, &PCI_subsys_vendor);
  2465.                 if(PCI_subsys_vendor != SANGOMA_SUBSYS_VENDOR)
  2466.                         continue;
  2468. pcibios_read_config_word(hw->pci_bus,hw->pci_dev_func,PCI_CARD_TYPE,
  2469.                         &PCI_card_type);
  2471. pcibios_read_config_byte(hw->pci_bus, hw->pci_dev_func,
  2472. PCI_INT_LINE_BYTE, &irq);
  2474. /* A dual cpu card can support up to 4 physical connections,
  2475.  * where a single cpu card can support up to 2 physical
  2476.  * connections.  The FT1 card can only support a single 
  2477.  * connection, however we cannot distinguish between a Single
  2478.  * CPU card and an FT1 card. */
  2479. if (PCI_card_type == S514_DUAL_CPU){
  2480.                  number_S514_cards += 4;
  2481.  printk(KERN_INFO "%s: S514-PCI card found, cpu(s) 2, bus #%d, slot #%d, irq #%dn",
  2482.                          modname, hw->pci_bus,
  2483.                          ((hw->pci_dev_func >> 3) & PCI_DEV_SLOT_MASK),irq);
  2484. }else{
  2485. printk(KERN_INFO "%s: S514-PCI card found, cpu(s) 1, bus #%d, slot #%d, irq #%dn",
  2486.                          modname, hw->pci_bus,
  2487.                          ((hw->pci_dev_func >> 3) & PCI_DEV_SLOT_MASK),irq);
  2488. number_S514_cards += 2;
  2489. }
  2490.         }
  2491. #endif
  2493. return number_S514_cards;
  2495. }
  2499. #if defined(LINUX_2_1) || defined(LINUX_2_4)
  2500. EXPORT_SYMBOL(wanpipe_hw_probe);
  2501. #endif
  2503. unsigned wanpipe_hw_probe(void)
  2504. {
  2505. sdlahw_t hw;
  2506. unsigned* opt = s508_port_options; 
  2507. unsigned cardno=0;
  2508. int i;
  2510. memset(&hw, 0, sizeof(hw));
  2512. for (i = 1; i <= opt[0]; i++) {
  2513. if (detect_s508(opt[i])){
  2514. /* S508 card can support up to two physical links */
  2515. cardno+=2;
  2516. printk(KERN_INFO "wanpipe: S508-ISA card found, port 0x%xn",opt[i]);
  2517. }
  2518. }
  2520.       #ifdef CONFIG_PCI
  2521. hw.S514_slot_no = 0;
  2522. cardno += pci_probe(&hw);
  2523.       #else
  2524. printk(KERN_INFO "wanpipe: Warning, Kernel not compiled for PCI support!n");
  2525. printk(KERN_INFO "wanpipe: PCI Hardware Probe Failed!n");
  2526.       #endif
  2528. return cardno;
  2529. }
  2531. /****** End *****************************************************************/