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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
pciIomapLib.c
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：22k
源码类别：

VxWorks

开发平台：

C/C++

pciIomapLib.c：源码内容
  1. /* pciIomapLib.c - Support for PCI drivers */
  3. /* Copyright 1984-2001 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01i,27oct01,dat  Adding warnings about obsolete drivers
  10. 01h,15oct98,dat  SPR 9098, added iv.h and private/semLibP.h
  11. 01g,12jan97,hdn  changed variable name "vender" to "vendor".
  12. 01f,12jan97,hdn  changed variable name "class" to "classCodeReg".
  13. 01e,03dec96,hdn  added single/multi function check.
  14. 01d,16sep96,dat  made pciConfigMech global (for pciIomapShow).
  15. 01c,06aug96,hdn  added pciInt(), pciIntConnect() and pciIntDisconnect().
  16. 01b,14mar96,hdn  re-written.  changed parameters of the functions.
  17.  removed BIOS dependent codes.
  18. 01a,25feb95,bcs  written
  19. */
  22. /*
  23. DESCRIPTION
  25. This library is PCI Revision 2.1 compliant.
  26. This module contains routines to support PCI bus mapped on IO address space
  27. for x86 and PowerPC architecture.  Functions in this library should not be
  28. called from the interrupt level, except pciInt(), since it uses a mutual
  29. exclusion semaphore for consecutive register access.  
  30. The functions addressed here include:
  32.   - Initialize the library.
  33.   - Locate the device by deviceID and vendorID.
  34.   - Locate the device by classCode.
  35.   - Generate the special cycle.
  36.   - Access its configuration registers.
  37.   - Connect a shared interrupt handler.
  38.   - Disconnect a shared interrupt handler.
  39.   - Master shared interrupt handler.
  41. There are functions to access the IO address space.  In x86 architecture,
  42. they are sysInXXX() and sysOutXXX().  Macro PCI_IN_XXX() and PCI_OUT_XXX()
  43. are provided to use other IO address space functions.
  45. Shared PCI interrupt are supported by three functions: pciInt(),
  46. pciIntConnect(), pciIntDisconnect().  pciIntConnect() adds the specified
  47. interrupt handler to the link list and pciIntDisconnect() removes it from
  48. the link list.  Master interrupt handler pciInt() executes these interrupt
  49. handlers in the link list for a PCI interrupt.  Each interrupt handler must
  50. check the device dependent interrupt status bit to determine the source of
  51. the interrupt, since it simply execute all interrupt handlers in the link
  52. list.  pciInt() should be attached by intConnect() function in the BSP 
  53. initialization with its parameter. The parameter is an IRQ associated 
  54. to the PCI interrupt.
  55. */
  57. #include "vxWorks.h"
  58. #include "stdio.h"
  59. #include "stdlib.h"
  60. #include "string.h"
  61. #include "intLib.h"
  62. #include "sysLib.h"
  63. #include "drv/pci/pciIomapLib.h"
  64. #include "iv.h"
  65. #include "private/semLibP.h"
  67. /* pciIomapLib is being obsoleted. Please use pciConfigLib instead. */
  69. #warning "src/drv/pci/pciIomapLib.c is outdated. Please use pciConfigLib"
  71. /* defines */
  73. #ifndef PCI_IN_BYTE
  74. #define PCI_IN_BYTE(x) sysInByte (x)
  75. #endif
  76. #ifndef PCI_IN_WORD
  77. #define PCI_IN_WORD(x) sysInWord (x)
  78. #endif
  79. #ifndef PCI_IN_LONG
  80. #define PCI_IN_LONG(x) sysInLong (x)
  81. #endif
  82. #ifndef PCI_OUT_BYTE
  83. #define PCI_OUT_BYTE(x,y) sysOutByte (x,y)
  84. #endif
  85. #ifndef PCI_OUT_WORD
  86. #define PCI_OUT_WORD(x,y) sysOutWord (x,y)
  87. #endif
  88. #ifndef PCI_OUT_LONG
  89. #define PCI_OUT_LONG(x,y) sysOutLong (x,y)
  90. #endif
  93. /* globals */
  95. STATUS pciLibInitStatus = NONE; /* initialization done */
  96. DL_LIST pciIntList[PCI_IRQ_LINES]; /* link list of int handlers */
  97. int pciConfigMech = NONE; /* 1=mechanism-1, 2=mechanism-2 */
  99. /* locals */
  101. LOCAL int pciConfigAddr0; /* config-addr-reg, CSE-reg*/
  102. LOCAL int pciConfigAddr1; /* config-data-reg, forward-reg */
  103. LOCAL int pciConfigAddr2; /* not-used, base-addr */
  104. LOCAL SEMAPHORE pciMuteSem; /* mutual exclusion semaphore */
  107. /*******************************************************************************
  108. *
  109. * pciIomapLibInit - initialize the configuration access-method and addresses
  110. *
  111. * This routine initializes the configuration access-method and addresses.
  112. *
  113. * Configuration mechanism one utilizes two 32-bit IO ports located at addresses
  114. * 0x0cf8 and 0x0cfc. These two ports are:
  115. *   - 32-bit configuration address port, at 0x0cf8
  116. *   - 32-bit configuration data port, at 0x0cfc
  117. * Accessing a PCI function's configuration port is two step process.
  118. *   - Write the bus number, physical device number, function number and 
  119. *     register number to the configuration address port.
  120. *   - Perform an IO read from or an write to the configuration data port.
  121. *
  122. * Configuration mechanism two uses following two single-byte IO ports.
  123. *   - Configuration space enable, or CSE, register, at 0x0cf8
  124. *   - Forward register, at 0x0cfa
  125. * To generate a PCI configuration transaction, the following actions are
  126. * performed.
  127. *   - Write the target bus number into the forward register.
  128. *   - Write a one byte value to the CSE register at 0x0cf8.  The bit
  129. *     pattern written to this register has three effects: disables the
  130. *     generation of special cycles; enables the generation of configuration
  131. *     transactions; specifies the target PCI functional device.
  132. *   - Perform a one, two or four byte IO read or write transaction within
  133. *     the IO range 0xc000 through 0xcfff.
  134. *
  135. * RETURNS:
  136. * OK, or ERROR if a mechanism is not 1 or 2.
  137. *
  138. */
  140. STATUS pciIomapLibInit
  141.     (
  142.     int mechanism, /* configuration mechanism: 1 or 2 */
  143.     int addr0, /* config-addr-reg / CSE-reg */
  144.     int addr1, /* config-data-reg / Forward-reg */
  145.     int addr2 /* none            / Base-address */
  146.     )
  147.     {
  148.     int ix;
  150.     if (pciLibInitStatus != NONE)
  151. return (pciLibInitStatus);
  153.     switch (mechanism)
  154. {
  155. case PCI_MECHANISM_1:
  156. case PCI_MECHANISM_2:
  157.     pciConfigMech = mechanism;
  158.     pciConfigAddr0 = addr0;
  159.     pciConfigAddr1 = addr1;
  160.     pciConfigAddr2 = addr2;
  161.     pciLibInitStatus = OK;
  162.     break;
  164. default:
  165.          pciLibInitStatus = ERROR;
  166.     break;
  167. }
  169.     semMInit (&pciMuteSem, SEM_Q_PRIORITY | SEM_DELETE_SAFE | 
  170.       SEM_INVERSION_SAFE);
  172.     for (ix = 0; ix < PCI_IRQ_LINES; ix++)
  173.         dllInit (&pciIntList[ix]);
  175.     return (pciLibInitStatus);
  176.     }
  178. /*******************************************************************************
  179. *
  180. * pciFindDevice - find the nth device with the given device & vendor ID
  181. *
  182. * This routine finds the nth device with the given device & vendor ID.
  183. *
  184. * RETURNS:
  185. * OK, or ERROR if the deviceId and vendorId didn't match.
  186. *
  187. */
  189. STATUS pciFindDevice
  190.     (
  191.     int vendorId, /* vendor ID */
  192.     int deviceId, /* device ID */
  193.     int index, /* desired instance of device */
  194.     int * pBusNo, /* bus number */
  195.     int * pDeviceNo, /* device number */
  196.     int * pFuncNo /* function number */
  197.     )
  198.     {
  199.     STATUS status = ERROR;
  200.     int busNo;
  201.     int deviceNo;
  202.     int funcNo;
  203.     short device;
  204.     short vendor;
  205.     char header;
  207.     if (pciLibInitStatus != OK) /* sanity check */
  208.         return (ERROR);
  210.     for (busNo=0; busNo < 0xff; busNo++)
  211.         for (deviceNo=0; deviceNo < 0x1f; deviceNo++)
  212.             for (funcNo=0; funcNo < 0x07; funcNo++)
  213. {
  214. /* avoid a special bus cycle */
  216. if ((deviceNo == 0x1f) && (funcNo == 0x07))
  217.     continue;
  219. pciConfigInWord (busNo, deviceNo, funcNo, PCI_CFG_VENDOR_ID,
  220.  &vendor);
  221. pciConfigInWord (busNo, deviceNo, funcNo, PCI_CFG_DEVICE_ID,
  222.  &device);
  223. if ((vendor == (short)vendorId) && 
  224.     (device == (short)deviceId) &&
  225.     (index-- == 0))
  226.     {
  227.     *pBusNo = busNo;
  228.     *pDeviceNo = deviceNo;
  229.     *pFuncNo = funcNo;
  230.     status = OK;
  231.     break; /* terminate loop */
  232.     }
  234. /* goto next device if it is a single function device */
  236. pciConfigInByte (busNo, deviceNo, funcNo, PCI_CFG_HEADER_TYPE, 
  237.  &header);
  238. if ((header & PCI_HEADER_MULTI_FUNC) != PCI_HEADER_MULTI_FUNC)
  239.     break;
  240. }
  242.     return (status);
  243.     }
  245. /*******************************************************************************
  246. *
  247. * pciFindClass - find the nth device with the given class(3 bytes).
  248. *
  249. * This routine finds the nth device with the given class(class subclass prog).
  250. *
  251. * RETURNS:
  252. * OK, or ERROR if the class didn't match.
  253. *
  254. */
  256. STATUS pciFindClass
  257.     (
  258.     int classCode, /* class code */
  259.     int index, /* desired instance of device */
  260.     int * pBusNo, /* bus number */
  261.     int * pDeviceNo, /* device number */
  262.     int * pFuncNo /* function number */
  263.     )
  264.     {
  265.     STATUS status = ERROR;
  266.     int busNo;
  267.     int deviceNo;
  268.     int funcNo;
  269.     int classCodeReg;
  270.     char header;
  272.     if (pciLibInitStatus != OK) /* sanity check */
  273.         return (ERROR);
  275.     for (busNo=0; busNo < 0xff; busNo++)
  276.         for (deviceNo=0; deviceNo < 0x1f; deviceNo++)
  277.             for (funcNo=0; funcNo < 0x07; funcNo++)
  278. {
  279. /* avoid a special bus cycle */
  281. if ((deviceNo == 0x1f) && (funcNo == 0x07))
  282.     continue;
  284. pciConfigInLong (busNo, deviceNo, funcNo, PCI_CFG_REVISION,
  285.  &classCodeReg);
  286. if ((((classCodeReg >> 8) & 0x00ffffff) == classCode) &&
  287.     (index-- == 0))
  288.     {
  289.     *pBusNo = busNo;
  290.     *pDeviceNo = deviceNo;
  291.     *pFuncNo = funcNo;
  292.     status = OK;
  293.     break; /* terminate loop */
  294.     }
  296. /* goto next device if it is a single function device */
  298. pciConfigInByte (busNo, deviceNo, funcNo, PCI_CFG_HEADER_TYPE, 
  299.  &header);
  300. if ((header & PCI_HEADER_MULTI_FUNC) != PCI_HEADER_MULTI_FUNC)
  301.     break;
  302. }
  304.     return (status);
  305.     }
  307. /*******************************************************************************
  308. *
  309. * pciPack - pack parameters for the Configuration Address Register
  310. *
  311. * This routine packs three parameters into one integer for accessing the
  312. * Configuration Address Register
  313. *
  314. * RETURNS:
  315. * packed integer.
  316. *
  317. */
  319. LOCAL int pciPack
  320.     (
  321.     int busNo, /* bus number */
  322.     int deviceNo, /* device number */
  323.     int funcNo /* function number */
  324.     )
  325.     {
  326.     return (((busNo    << 16) & 0x00ff0000) |
  327.     ((deviceNo << 11) & 0x0000f800) |
  328.     ((funcNo   << 8)  & 0x00000700));
  329.     }
  331. /*******************************************************************************
  332. *
  333. * pciConfigInByte - read one byte from the PCI configuration space
  334. *
  335. * This routine reads one byte from the PCI configuration space
  336. *
  337. * RETURNS:
  338. * OK, or ERROR if this library is not initialized.
  339. *
  340. */
  342. STATUS pciConfigInByte
  343.     (
  344.     int busNo, /* bus number */
  345.     int deviceNo, /* device number */
  346.     int funcNo, /* function number */
  347.     int address, /* address of the configuration space */
  348.     char * pData /* data read from the address */
  349.     )
  350.     {
  351.     int retval = 0;
  353.     if (pciLibInitStatus != OK) /* sanity check */
  354.         return (ERROR);
  356.     semTake (&pciMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  358.     switch (pciConfigMech)
  359. {
  360. case PCI_MECHANISM_1:
  361.     PCI_OUT_LONG (pciConfigAddr0, pciPack (busNo, deviceNo, funcNo) |
  362.           (address & 0xfc) | 0x80000000);
  363.     retval = PCI_IN_BYTE (pciConfigAddr1 + (address & 0x3));
  364.     break;
  366. case PCI_MECHANISM_2:
  367.     PCI_OUT_BYTE (pciConfigAddr0, 0xf0 | (funcNo << 1));
  368.     PCI_OUT_BYTE (pciConfigAddr1, busNo);
  369.     retval = PCI_IN_LONG (pciConfigAddr2 | ((deviceNo & 0x000f) << 8) |
  370.   (address & 0xfc));
  371.     PCI_OUT_BYTE (pciConfigAddr0, 0);
  372.     retval >>= (address & 0x03) * 8;
  373.     break;
  375. default:
  376.     break;
  377. }
  379.     semGive (&pciMuteSem); /* mutual execlusion stop */
  381.     *pData = retval;
  383.     return (OK);
  384.     }
  386. /*******************************************************************************
  387. *
  388. * pciConfigInWord - read one word from the PCI configuration space
  389. *
  390. * This routine reads one word from the PCI configuration space
  391. *
  392. * RETURNS:
  393. * OK, or ERROR if this library is not initialized.
  394. *
  395. */
  397. STATUS pciConfigInWord
  398.     (
  399.     int busNo, /* bus number */
  400.     int deviceNo, /* device number */
  401.     int funcNo, /* function number */
  402.     int address, /* address of the configuration space */
  403.     short * pData /* data read from the address */
  404.     )
  405.     {
  406.     int retval = 0;
  408.     if (pciLibInitStatus != OK) /* sanity check */
  409.         return (ERROR);
  411.     semTake (&pciMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  413.     switch (pciConfigMech)
  414. {
  415. case PCI_MECHANISM_1:
  416.     PCI_OUT_LONG (pciConfigAddr0, pciPack (busNo, deviceNo, funcNo) |
  417.           (address & 0xfc) | 0x80000000);
  418.     retval = PCI_IN_WORD (pciConfigAddr1 + (address & 0x2));
  419.     break;
  421. case PCI_MECHANISM_2:
  422.     PCI_OUT_BYTE (pciConfigAddr0, 0xf0 | (funcNo << 1));
  423.     PCI_OUT_BYTE (pciConfigAddr1, busNo);
  424.     retval = PCI_IN_LONG (pciConfigAddr2 | ((deviceNo & 0x000f) << 8) |
  425.   (address & 0xfc));
  426.     PCI_OUT_BYTE (pciConfigAddr0, 0);
  427.     retval >>= (address & 0x02) * 8;
  428.     break;
  430. default:
  431.     break;
  432. }
  434.     semGive (&pciMuteSem); /* mutual execlusion stop */
  436.     *pData = retval;
  438.     return (OK);
  439.     }
  441. /*******************************************************************************
  442. *
  443. * pciConfigInLong - read one longword from the PCI configuration space
  444. *
  445. * This routine reads one longword from the PCI configuration space
  446. *
  447. * RETURNS:
  448. * OK, or ERROR if this library is not initialized.
  449. *
  450. */
  452. STATUS pciConfigInLong
  453.     (
  454.     int busNo, /* bus number */
  455.     int deviceNo, /* device number */
  456.     int funcNo, /* function number */
  457.     int address, /* address of the configuration space */
  458.     int * pData /* data read from the address */
  459.     )
  460.     {
  461.     int retval = 0;
  463.     if (pciLibInitStatus != OK) /* sanity check */
  464.         return (ERROR);
  466.     semTake (&pciMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  468.     switch (pciConfigMech)
  469. {
  470. case PCI_MECHANISM_1:
  471.     PCI_OUT_LONG (pciConfigAddr0, pciPack (busNo, deviceNo, funcNo) |
  472.           (address & 0xfc) | 0x80000000);
  473.     retval = PCI_IN_LONG (pciConfigAddr1);
  474.     break;
  476. case PCI_MECHANISM_2:
  477.     PCI_OUT_BYTE (pciConfigAddr0, 0xf0 | (funcNo << 1));
  478.     PCI_OUT_BYTE (pciConfigAddr1, busNo);
  479.     retval = PCI_IN_LONG (pciConfigAddr2 | ((deviceNo & 0x000f) << 8) |
  480.   (address & 0xfc));
  481.     PCI_OUT_BYTE (pciConfigAddr0, 0);
  482.     break;
  484. default:
  485.     break;
  486. }
  488.     semGive (&pciMuteSem); /* mutual execlusion stop */
  490.     *pData = retval;
  492.     return (OK);
  493.     }
  495. /*******************************************************************************
  496. *
  497. * pciConfigOutByte - write one byte to the PCI configuration space
  498. *
  499. * This routine writes one byte to the PCI configuration space.
  500. *
  501. * RETURNS:
  502. * OK, or ERROR if this library is not initialized.
  503. *
  504. */
  506. STATUS pciConfigOutByte
  507.     (
  508.     int busNo, /* bus number */
  509.     int deviceNo, /* device number */
  510.     int funcNo, /* function number */
  511.     int address, /* address of the configuration space */
  512.     char data /* data written to the address */
  513.     )
  514.     {
  515.     int retval;
  516.     int mask = 0x000000ff;
  518.     if (pciLibInitStatus != OK) /* sanity check */
  519.         return (ERROR);
  521.     semTake (&pciMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  523.     switch (pciConfigMech)
  524. {
  525. case PCI_MECHANISM_1:
  526.     PCI_OUT_LONG (pciConfigAddr0, pciPack (busNo, deviceNo, funcNo) |
  527.           (address & 0xfc) | 0x80000000);
  528.     PCI_OUT_BYTE ((pciConfigAddr1 + (address & 0x3)), data);
  529.     break;
  531. case PCI_MECHANISM_2:
  532.     PCI_OUT_BYTE (pciConfigAddr0, 0xf0 | (funcNo << 1));
  533.     PCI_OUT_BYTE (pciConfigAddr1, busNo);
  534.     retval = PCI_IN_LONG (pciConfigAddr2 | ((deviceNo & 0x000f) << 8) |
  535.   (address & 0xfc));
  536.     data = (data & mask) << ((address & 0x03) * 8);
  537.     mask <<= (address & 0x03) * 8;
  538.     retval = (retval & ~mask) | data;
  539.     PCI_OUT_LONG ((pciConfigAddr2 | ((deviceNo & 0x000f) << 8) |
  540.   (address & 0xfc)), retval);
  541.     PCI_OUT_BYTE (pciConfigAddr0, 0);
  542.     break;
  544. default:
  545.     break;
  546. }
  548.     semGive (&pciMuteSem); /* mutual execlusion stop */
  550.     return (OK);
  551.     }
  553. /*******************************************************************************
  554. *
  555. * pciConfigOutWord - write one word to the PCI configuration space
  556. *
  557. * This routine writes one word to the PCI configuration space.
  558. *
  559. * RETURNS:
  560. * OK, or ERROR if this library is not initialized.
  561. *
  562. */
  564. STATUS pciConfigOutWord
  565.     (
  566.     int busNo, /* bus number */
  567.     int deviceNo, /* device number */
  568.     int funcNo, /* function number */
  569.     int address, /* address of the configuration space */
  570.     short data /* data written to the address */
  571.     )
  572.     {
  573.     int retval;
  574.     int mask = 0x0000ffff;
  576.     if (pciLibInitStatus != OK) /* sanity check */
  577.         return (ERROR);
  579.     semTake (&pciMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  581.     switch (pciConfigMech)
  582. {
  583. case PCI_MECHANISM_1:
  584.     PCI_OUT_LONG (pciConfigAddr0, pciPack (busNo, deviceNo, funcNo) |
  585.           (address & 0xfc) | 0x80000000);
  586.     PCI_OUT_WORD ((pciConfigAddr1 + (address & 0x2)), data);
  587.     break;
  589. case PCI_MECHANISM_2:
  590.     PCI_OUT_BYTE (pciConfigAddr0, 0xf0 | (funcNo << 1));
  591.     PCI_OUT_BYTE (pciConfigAddr1, busNo);
  592.     retval = PCI_IN_LONG (pciConfigAddr2 | ((deviceNo & 0x000f) << 8) |
  593.   (address & 0xfc));
  594.     data = (data & mask) << ((address & 0x02) * 8);
  595.     mask <<= (address & 0x02) * 8;
  596.     retval = (retval & ~mask) | data;
  597.     PCI_OUT_LONG ((pciConfigAddr2 | ((deviceNo & 0x000f) << 8) |
  598.   (address & 0xfc)), retval);
  599.     PCI_OUT_BYTE (pciConfigAddr0, 0);
  600.     break;
  602. default:
  603.     break;
  604. }
  606.     semGive (&pciMuteSem); /* mutual execlusion stop */
  608.     return (OK);
  609.     }
  611. /*******************************************************************************
  612. *
  613. * pciConfigOutLong - write one longword to the PCI configuration space
  614. *
  615. * This routine writes one longword to the PCI configuration space.
  616. *
  617. * RETURNS:
  618. * OK, or ERROR if this library is not initialized.
  619. *
  620. */
  622. STATUS pciConfigOutLong
  623.     (
  624.     int busNo, /* bus number */
  625.     int deviceNo, /* device number */
  626.     int funcNo, /* function number */
  627.     int address, /* address of the configuration space */
  628.     int data /* data written to the address */
  629.     )
  630.     {
  632.     if (pciLibInitStatus != OK) /* sanity check */
  633.         return (ERROR);
  635.     semTake (&pciMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  637.     switch (pciConfigMech)
  638. {
  639. case PCI_MECHANISM_1:
  640.     PCI_OUT_LONG (pciConfigAddr0, pciPack (busNo, deviceNo, funcNo) |
  641.           (address & 0xfc) | 0x80000000);
  642.     PCI_OUT_LONG (pciConfigAddr1, data);
  643.     break;
  645. case PCI_MECHANISM_2:
  646.     PCI_OUT_BYTE (pciConfigAddr0, 0xf0 | (funcNo << 1));
  647.     PCI_OUT_BYTE (pciConfigAddr1, busNo);
  648.     PCI_OUT_LONG ((pciConfigAddr2 | ((deviceNo & 0x000f) << 8) |
  649.   (address & 0xfc)), data);
  650.     PCI_OUT_BYTE (pciConfigAddr0, 0);
  651.     break;
  653. default:
  654.     break;
  655. }
  657.     semGive (&pciMuteSem); /* mutual execlusion stop */
  659.     return (OK);
  660.     }
  662. /*******************************************************************************
  663. *
  664. * pciSpecialCycle - generate a special cycle with a message
  665. *
  666. * This routine generates a special cycle with a message.
  667. *
  668. * RETURNS:
  669. * OK, or ERROR if this library is not initialized.
  670. *
  671. */
  673. STATUS pciSpecialCycle
  674.     (
  675.     int busNo, /* bus number */
  676.     int message /* data on AD[31:0] during the special cycle */
  677.     )
  678.     {
  679.     int deviceNo = 0x0000001f;
  680.     int funcNo = 0x00000007;
  682.     if (pciLibInitStatus != OK) /* sanity check */
  683.         return (ERROR);
  685.     semTake (&pciMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  687.     switch (pciConfigMech)
  688. {
  689. case PCI_MECHANISM_1:
  690.     PCI_OUT_LONG (pciConfigAddr0, pciPack (busNo, deviceNo, funcNo) |
  691.           0x80000000);
  692.     PCI_OUT_LONG (pciConfigAddr1, message);
  693.     break;
  695. case PCI_MECHANISM_2:
  696.     PCI_OUT_BYTE (pciConfigAddr0, 0xff);
  697.     PCI_OUT_BYTE (pciConfigAddr1, 0x00);
  698.     PCI_OUT_LONG ((pciConfigAddr2 | ((deviceNo & 0x000f) << 8)),
  699.   message);
  700.     PCI_OUT_BYTE (pciConfigAddr0, 0);
  701.     break;
  703. default:
  704.     break;
  705. }
  707.     semGive (&pciMuteSem); /* mutual execlusion stop */
  709.     return (OK);
  710.     }
  712. /*******************************************************************************
  713. *
  714. * pciInt - interrupt handler for shared PCI interrupt.
  715. *
  716. * This routine executes multiple interrupt handlers for a PCI interrupt.
  717. * Each interrupt handler must check the device dependent interrupt status bit
  718. * to determine the source of the interrupt, since it simply execute all
  719. * interrupt handlers in the link list.
  720. *
  721. * RETURNS: N/A
  722. *
  723. */
  725. VOID pciInt
  726.     (
  727.     int irq /* IRQ associated to the PCI interrupt */
  728.     )
  729.     {
  730.     PCI_INT_RTN *pRtn;
  732.     for (pRtn = (PCI_INT_RTN *)DLL_FIRST (&pciIntList[irq]); pRtn != NULL;
  733.  pRtn = (PCI_INT_RTN *)DLL_NEXT (&pRtn->node))
  734. (* pRtn->routine) (pRtn->parameter);
  735.     }
  737. /*******************************************************************************
  738. *
  739. * pciIntConnect - connect the interrupt handler to the PCI interrupt.
  740. *
  741. * This routine connects an interrupt handler to the PCI interrupt line(A - D).
  742. * Link list is created if multiple handlers are assigned to the single PCI
  743. * interrupt.
  744. *
  745. * RETURNS:
  746. * OK, or ERROR if the interrupt handler cannot be built.
  747. *
  748. */
  750. STATUS pciIntConnect
  751.     (
  752.     VOIDFUNCPTR *vector,        /* interrupt vector to attach to     */
  753.     VOIDFUNCPTR routine,        /* routine to be called              */
  754.     int parameter               /* parameter to be passed to routine */
  755.     )
  756.     {
  757.     int irq = IVEC_TO_INUM ((int)vector) - INT_NUM_IRQ0;
  758.     PCI_INT_RTN *pRtn;
  759.     int oldLevel;
  761.     if (pciLibInitStatus != OK)
  762. return (ERROR);
  764.     pRtn = (PCI_INT_RTN *)malloc (sizeof (PCI_INT_RTN));
  765.     if (pRtn == NULL)
  766. return (ERROR);
  768.     pRtn->routine   = routine;
  769.     pRtn->parameter = parameter;
  771.     oldLevel = intLock (); /* LOCK INTERRUPT */
  772.     dllAdd (&pciIntList[irq], &pRtn->node);
  773.     intUnlock (oldLevel); /* UNLOCK INTERRUPT */
  775.     return (OK);
  776.     }
  778. /*******************************************************************************
  779. *
  780. * pciIntDisconnect - disconnect the interrupt handler from the PCI interrupt.
  781. *
  782. * This routine disconnects the interrupt handler from the PCI interrupt line.
  783. *
  784. * RETURNS:
  785. * OK, or ERROR if the interrupt handler cannot be removed.
  786. *
  787. */
  789. STATUS pciIntDisconnect
  790.     (
  791.     VOIDFUNCPTR *vector,        /* interrupt vector to attach to     */
  792.     VOIDFUNCPTR routine         /* routine to be called              */
  793.     )
  794.     {
  795.     int irq = IVEC_TO_INUM ((int)vector) - INT_NUM_IRQ0;
  796.     PCI_INT_RTN *pRtn;
  797.     int oldLevel;
  799.     if (pciLibInitStatus != OK)
  800. return (ERROR);
  802.     for (pRtn = (PCI_INT_RTN *)DLL_FIRST (&pciIntList[irq]); pRtn != NULL;
  803.  pRtn = (PCI_INT_RTN *)DLL_NEXT (&pRtn->node))
  804. {
  805. if (pRtn->routine == routine)
  806.     {
  807.     oldLevel = intLock (); /* LOCK INTERRUPT */
  808.     dllRemove (&pciIntList[irq], &pRtn->node);
  809.     intUnlock (oldLevel); /* UNLOCK INTERRUPT */
  811.     free ((char *)pRtn);
  812.     return (OK);
  813.     }
  814. }
  816.     return (ERROR);
  817.     }