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

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

VxWorks

开发平台：

C/C++

pcic.c：源码内容
  1. /* pcic.c - Intel 82365SL PCMCIA host bus adaptor chip library */
  3. /* Copyright 1984-1996 Wind River Systems, Inc. */
  4. /* Copyright (c) 1994 David A. Hinds -- All Rights Reserved */
  5. #include "copyright_wrs.h"
  7. /*
  8. modification history
  9. --------------------
  10. 01h,01apr98,hdn  set PCIC_ENA_MEMCS16 if MAP_16BIT is specified.
  11. 01g,19jan98,hdn  removed taskDelay().
  12. 01f,01nov96,hdn  fixed PCIC_PORT().
  13. 01e,29mar96,jdi  doc: fixed error.
  14. 01d,28mar96,jdi  doc: cleaned up language and format.
  15. 01c,08mar96,hdn  added more descriptions.
  16. 01b,22feb96,hdn  cleaned up
  17. 01a,19jan95,hdn  written based on David Hinds's version 2.2.3.
  18. */
  21. /*
  22. DESCRIPTION
  23. This library contains routines to manipulate the PCMCIA functions on the
  24. Intel 82365 series PCMCIA chip.
  25. The following compatible chips are also supported:
  27.     - Cirrus Logic PD6712/20/22
  28.     - Vadem VG468
  29.     - VLSI 82c146
  30.     - Ricoh RF5C series
  32. The initialization routine pcicInit() is the only global function and is
  33. included in the PCMCIA chip table `pcmciaAdapter'.  If pcicInit() finds
  34. the PCIC chip, it registers all function pointers of the PCMCIA_CHIP
  35. structure.
  37. */
  40. #include "vxWorks.h"
  41. #include "taskLib.h"
  42. #include "intLib.h"
  43. #include "sysLib.h"
  44. #include "drv/pcmcia/pcmciaLib.h"
  45. #include "drv/pcmcia/pcic.h"
  46. #include "drv/pcmcia/pd67.h"
  47. #include "drv/pcmcia/vg468.h"
  48. #include "drv/pcmcia/ricoh.h"
  51. /* defines */
  53. #define PCIC_PORT(slot) (pcicBase + (2*((slot) >> 2)))
  54. #define PCIC_REG(slot, reg) ((((slot) & 3) * 0x40) + reg)
  57. /* imports */
  59. IMPORT PCMCIA_CTRL pcmciaCtrl;
  62. /* globals */
  64. int pcicBase;
  67. /* locals */
  69. LOCAL SEMAPHORE pcicMuteSem;
  72. /* forward declarations */
  74. LOCAL STATUS pcicReset (int sock);
  75. LOCAL int pcicStatus (int sock);
  76. LOCAL int pcicFlagGet (int sock);
  77. LOCAL STATUS pcicFlagSet (int sock, int flag);
  78. LOCAL STATUS pcicCscOn (int sock, int irq);
  79. LOCAL STATUS pcicCscOff (int sock, int irq);
  80. LOCAL int pcicCscPoll (int sock);
  81. LOCAL int pcicIrqGet (int sock);
  82. LOCAL STATUS pcicIrqSet (int sock, int irq);
  83. LOCAL STATUS pcicIowinGet (int sock, PCMCIA_IOWIN *io);
  84. LOCAL STATUS pcicIowinSet (int sock, PCMCIA_IOWIN *io);
  85. LOCAL STATUS pcicMemwinGet (int sock, PCMCIA_MEMWIN *mem);
  86. LOCAL STATUS pcicMemwinSet (int sock, PCMCIA_MEMWIN *mem);
  87. LOCAL int pcicGet (int sock, int reg);
  88. LOCAL int pcicGet2 (int sock, int reg);
  89. LOCAL void pcicSet (int sock, int reg, char value);
  90. LOCAL void pcicSet2 (int sock, int reg, short value);
  91. LOCAL void pcicBset (int sock, int reg, char mask);
  92. LOCAL void pcicBclr (int sock, int reg, char mask);
  95. /*******************************************************************************
  96. *
  97. * pcicInit - initialize the PCIC chip
  98. *
  99. * This routine initializes the PCIC chip.
  100. *
  101. * RETURNS: OK, or ERROR if the PCIC chip cannot be found.
  102. */
  104. STATUS pcicInit
  105.     (
  106.     int     ioBase, /* IO base address */
  107.     int     intVec, /* interrupt vector */
  108.     int     intLevel, /* interrupt level */
  109.     FUNCPTR showRtn /* show routine */
  110.     )
  111.     {
  112.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  113.     PCMCIA_CHIP *pChip = &pCtrl->chip;
  114.     BOOL done = FALSE;
  115.     int ix;
  116.     int value;
  117.     int sock;
  118.     
  119.     pcicBase = ioBase;
  121.     for (sock = 0; sock < PCIC_MAX_SOCKS; sock++)
  122. {
  123. value = pcicGet (sock, PCIC_IDENT);
  124. switch (value)
  125.     {
  126.     case 0x82:
  127.     case 0x83:
  128. pChip->name = "INTEL 82365SL";
  129. pChip->type = PCIC_I82365;
  131. /* check for Vadem VG-468 chip */
  133. sysOutByte (PCIC_PORT (sock), 0x0e);
  134. sysOutByte (PCIC_PORT (sock), 0x37);
  135. pcicBset (sock, VG468_MISC, VG468_MISC_VADEMREV);
  136. value = pcicGet (sock, PCIC_IDENT);
  137. if (value & PCIC_IDENT_VADEM)
  138.     {
  139.     pChip->name = "VADEM Clone";
  140.     pChip->type = PCIC_VG468;
  141.     pcicBclr (sock, VG468_MISC, VG468_MISC_VADEMREV);
  142.     }
  143. break;
  145.     case 0x84:
  146. pChip->name = "VLSI 82C146";
  147. pChip->type = PCIC_VLSI;
  148. break;
  150.     case 0x88:
  151.     case 0x89:
  152. pChip->name = "IBM Clone";
  153. pChip->type = PCIC_IBM;
  154. break;
  156.     case 0x8b:
  157. pChip->name = "VADEM Clone";
  158. pChip->type = PCIC_VG468;
  159. pcicBclr (sock, VG468_MISC, VG468_MISC_VADEMREV);
  160. break;
  162.     default:
  163. done = 1;
  164.     }
  165. if (done)
  166.     break;
  167. pcicSet (sock, PCIC_CSCINT, sock);
  168. }
  170.     if (sock == 0)
  171. return (ERROR);
  173.     semMInit (&pcicMuteSem, SEM_Q_PRIORITY | SEM_DELETE_SAFE | 
  174.       SEM_INVERSION_SAFE);
  175.     semTake (&pcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  177.     /* Check for bogus clones that ignore top bit of index register */
  179.     if ((sock == 4) && (pcicGet (0, PCIC_CSCINT) == 2))
  180. sock = 2;
  181.     
  182.     /* Check for Ricoh chips */
  184.     value = pcicGet (0, RF5C_CHIP_ID);
  185.     if ((value == RF5C_CHIP_RF5C296) || (value == RF5C_CHIP_RF5C396))
  186. {
  187. pChip->name = "RICOH Clone";
  188. pChip->type = PCIC_RICOH;
  189. }
  191.     /* Check for Cirrus CL-PD67xx chips */
  193.     pcicSet (0, PD67_CHIP_INFO, 0);
  194.     value = pcicGet (0, PD67_CHIP_INFO);
  195.     if ((value & PD67_INFO_CHIP_ID) == PD67_INFO_CHIP_ID)
  196. {
  197. value = pcicGet (0, PD67_CHIP_INFO);
  198. if ((value & PD67_INFO_CHIP_ID) == 0)
  199.     {
  200.     if (value & PD67_INFO_SLOTS)
  201. {
  202. pChip->name = "Cirrus CL-PD672x";
  203. pChip->type = PCIC_PD672X;
  204. }
  205.     else
  206. {
  207. pChip->name = "Cirrus CL-PD6710";
  208. pChip->type = PCIC_PD6710;
  209. sock = 1;
  210.         }
  211.     }
  212.         }
  214.     for (ix = 0; ix < sock; ix++)
  215. {
  216.         pcicSet (sock, PCIC_CSCINT, 0);
  217.         pcicSet (sock, PCIC_GENCTL, 0);
  218.         pcicSet (sock, PCIC_GBLCTL, 0);
  219. }
  220.     
  221.     pChip->reset = (FUNCPTR) pcicReset;
  222.     pChip->status = (FUNCPTR) pcicStatus;
  223.     pChip->flagGet = (FUNCPTR) pcicFlagGet;
  224.     pChip->flagSet = (FUNCPTR) pcicFlagSet;
  225.     pChip->cscOn = (FUNCPTR) pcicCscOn;
  226.     pChip->cscOff = (FUNCPTR) pcicCscOff;
  227.     pChip->cscPoll = (FUNCPTR) pcicCscPoll;
  228.     pChip->irqGet = (FUNCPTR) pcicIrqGet;
  229.     pChip->irqSet = (FUNCPTR) pcicIrqSet;
  230.     pChip->iowinGet = (FUNCPTR) pcicIowinGet;
  231.     pChip->iowinSet = (FUNCPTR) pcicIowinSet;
  232.     pChip->memwinGet = (FUNCPTR) pcicMemwinGet;
  233.     pChip->memwinSet = (FUNCPTR) pcicMemwinSet;
  234.     pChip->type = PCMCIA_PCIC;
  235.     pChip->socks = sock;
  236.     pChip->installed = TRUE;
  237.     pChip->intLevel = intLevel;
  238.     pChip->memWindows = PCIC_MEM_WINDOWS;
  239.     pChip->ioWindows = PCIC_IO_WINDOWS;
  240.     pChip->showRtn = showRtn;
  242.     semGive (&pcicMuteSem);   /* mutual execlusion stop */
  244.     return (OK);
  245.     }
  246.   
  247. /*******************************************************************************
  248. *
  249. * pcicStatus - Get status of the socket.
  250. *
  251. * This routine gets status of the socket.
  252. * This routine can be called in interrupt level.
  253. *
  254. * RETURNS: The status of the socket.
  255. */
  257. LOCAL int pcicStatus
  258.     (
  259.     int sock /* socket no. */
  260.     )
  261.     {
  262.     BOOL intMode = intContext ();
  263.     int status = 0;
  264.     char value;
  266.     if (!intMode)
  267.         semTake (&pcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  269.     value  = pcicGet (sock, PCIC_STATUS);
  271.     if ((value & PCIC_CS_DETECT) == PCIC_CS_DETECT) /* CD1=1 and CD2=1 */
  272.         status = PC_IS_CARD;
  274.     if ((value & PCIC_CS_DETECT) != PCIC_CS_DETECT) /* CD1=0 or CD2=0 */
  275.         status = PC_NO_CARD;
  277.     if (pcicGet (sock, PCIC_INTCTL) & PCIC_PC_IOCARD)
  278. status |= (value & PCIC_CS_STSCHG) ? 0 : PC_STSCHG;
  279.     else
  280. {
  281. status |= (value & PCIC_CS_BVD1) ? 0 : PC_BATDEAD;
  282. status |= (value & PCIC_CS_BVD2) ? 0 : PC_BATWARN;
  283.         }
  284.     status |= (value & PCIC_CS_WRPROT) ? PC_WRPROT : 0;
  285.     status |= (value & PCIC_CS_READY) ? PC_READY : 0;
  286.     status |= (value & PCIC_CS_POWERON) ? PC_POWERON : 0;
  288.     if (!intMode)
  289.         semGive (&pcicMuteSem);   /* mutual execlusion stop */
  291.     return (status);
  292.     }
  294. /*******************************************************************************
  295. *
  296. * pcicFlagGet - Get configuration flag from the socket.
  297. *
  298. * This routine gets configuration flag from the socket.
  299. *
  300. * RETURNS: The configuration flag of the socket.
  301. */
  303. LOCAL int pcicFlagGet
  304.     (
  305.     int sock /* socket no. */
  306.     )
  307.     {
  308.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  309.     PCMCIA_CHIP *pChip = &pCtrl->chip;
  310.     char value;
  311.     char vcc;
  312.     char vpp;
  313.     int flag;
  315.     semTake (&pcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  317.     value = pcicGet (sock, PCIC_POWER);
  318.     vcc   = value & PCIC_VCC_MASK;
  319.     vpp   = value & PCIC_VPP_MASK;
  321.     flag  = (value & PCIC_PWR_AUTO) ? PC_PWR_AUTO : 0;
  322.     switch (pChip->type)
  323. {
  324. case PCIC_PD672X:
  325. case PCIC_PD6710:
  326.     if (pcicGet (sock, PD67_MISC_CTL_1) & PD67_MC1_VCC_3V)
  327. {
  328. flag |= (value & PCIC_VCC_5V) ? PC_VCC_3V : 0;
  329. flag |= (vpp & PCIC_VPP_5V) ? PC_VPP_5V : 0;
  330. flag |= (vpp & PCIC_VPP_12V) ? PC_VPP_12V : 0;
  331. }
  332.     else
  333. {
  334. flag |= (value & PCIC_VCC_5V) ? PC_VCC_5V : 0;
  335. flag |= (vpp & PCIC_VPP_5V) ? PC_VPP_5V : 0;
  336. flag |= (vpp & PCIC_VPP_12V) ? PC_VPP_12V : 0;
  337. }
  338.     break;
  340. case PCIC_VG468:
  341.     if (value & PCIC_VCC_5V)
  342. {
  343. flag = PC_VCC_5V;
  344. flag |= (vpp & PCIC_VPP_5V) ? PC_VPP_5V : 0;
  345. flag |= (vpp & PCIC_VPP_12V) ? PC_VPP_12V : 0;
  346. }
  347.     break;
  349. default:
  350.             flag |= (vcc & PCIC_VCC_3V) ? PC_VCC_3V : 0;
  351.             flag |= (vcc & PCIC_VCC_5V) ? PC_VCC_5V : 0;
  352.             flag |= (vpp & PCIC_VPP_5V) ? PC_VPP_5V : 0;
  353.             flag |= (vpp & PCIC_VPP_12V) ? PC_VPP_12V : 0;
  354.             break;
  355. }
  357.     value = pcicGet (sock, PCIC_INTCTL);
  358.     flag |= (value & PCIC_PC_IOCARD) ? PC_IOCARD : 0;
  359.     flag |= (value & PCIC_PC_RESET) ? 0 : PC_RESET;
  361.     semGive (&pcicMuteSem);   /* mutual execlusion stop */
  363.     return (flag);
  364.     }
  366. /*******************************************************************************
  367. *
  368. * pcicFlagSet - Set configuration flag into the socket.
  369. *
  370. * This routine sets configuration flag into the socket.
  371. *
  372. * RETURNS: OK (always).
  373. */
  375. LOCAL STATUS pcicFlagSet
  376.     (
  377.     int sock, /* socket no. */
  378.     int flag /* configuration flag */
  379.     )
  380.     {
  381.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  382.     PCMCIA_CHIP *pChip = &pCtrl->chip;
  383.     char value;
  385.     semTake (&pcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  387.     value  = pcicGet (sock, PCIC_POWER);
  388.     value &= ~(PCIC_PWR_AUTO | PCIC_VCC_MASK | PCIC_VPP_MASK);
  389.     value |= (flag & PC_PWR_AUTO) ? PCIC_PWR_AUTO : 0;
  391.     switch (pChip->type)
  392. {
  393. case PCIC_PD672X:
  394. case PCIC_PD6710:
  395.     if (flag & PC_VPP_MASK)
  396. {
  397. if (flag & PC_VPP_12V)
  398.     value |= PCIC_VPP_12V;
  399. else if ((flag & PC_VPP_5V) && (flag & PC_VCC_5V))
  400.     value |= PCIC_VPP_5V;
  401. }
  402.     if (flag & PC_VCC_MASK)
  403. {
  404. if (flag & PC_VCC_3V)
  405.     {
  406.     value |= PCIC_VCC_5V | PCIC_PWR_OUT;
  407.     pcicBset (sock, PD67_MISC_CTL_1, PD67_MC1_VCC_3V);
  408.     }
  409. else if (flag & PC_VCC_5V)
  410.     {
  411.     value |= PCIC_VCC_5V | PCIC_PWR_OUT;
  412.     pcicBclr (sock, PD67_MISC_CTL_1, PD67_MC1_VCC_3V);
  413.     }
  414. }
  415.     break;
  417. case PCIC_VG468:
  418.             value |= (flag & PC_VCC_5V) ? PCIC_VCC_5V | PCIC_PWR_OUT : 0;
  419.             value |= (flag & PC_VPP_5V) ? PCIC_VPP_5V : 0;
  420.             value |= (flag & PC_VPP_12V) ? PCIC_VPP_12V : 0;
  421.     break;
  423. default:
  424.             value |= (flag & PC_VCC_3V) ? PCIC_VCC_3V | PCIC_PWR_OUT : 0;
  425.             value |= (flag & PC_VCC_5V) ? PCIC_VCC_5V | PCIC_PWR_OUT : 0;
  426.             value |= (flag & PC_VPP_5V) ? PCIC_VPP_5V : 0;
  427.             value |= (flag & PC_VPP_12V) ? PCIC_VPP_12V : 0;
  428.     break;
  429. }
  431.     pcicSet (sock, PCIC_POWER, value);
  433.     value = pcicGet (sock, PCIC_INTCTL);
  434.     value &= ~(PCIC_PC_IOCARD | PCIC_PC_RESET);
  435.     /* Note that the reset signal is inverted */
  436.     value |= (flag & PC_RESET) ? 0 : PCIC_PC_RESET;
  437.     value |= (flag & PC_IOCARD) ? PCIC_PC_IOCARD : 0;
  438.     pcicSet (sock, PCIC_INTCTL, value);
  440.     semGive (&pcicMuteSem);   /* mutual execlusion stop */
  442.     return (OK);
  443.     }
  445. /*******************************************************************************
  446. *
  447. * pcicCscOn - Enables the card status change interrupt.
  448. *
  449. * This routine enables the card status change interrupt.
  450. *
  451. * RETURNS: OK (always).
  452. */
  454. LOCAL STATUS pcicCscOn
  455.     (
  456.     int sock, /* socket no. */
  457.     int irq /* IRQ level for CSC */
  458.     )
  459.     {
  461.     semTake (&pcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  463.     /* Turn on all card status change interrupts */
  465.     pcicSet (sock, PCIC_CSCINT, (irq << 4) | PCIC_CSC_ANY);
  466.     pcicBclr (sock, PCIC_INTCTL, PCIC_INTR_ENA);
  468.     semGive (&pcicMuteSem);   /* mutual execlusion stop */
  470.     return (OK);
  471.     }
  473. /*******************************************************************************
  474. *
  475. * pcicCscOff - Disable the card status change interrupt.
  476. *
  477. * This routine Disables the card status change interrupt.
  478. *
  479. * RETURNS: OK (always).
  480. */
  482. LOCAL STATUS pcicCscOff
  483.     (
  484.     int sock, /* socket no. */
  485.     int irq /* IRQ level for CSC */
  486.     )
  487.     {
  489.     semTake (&pcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  491.     /* Turn off all card status change interrupts */
  493.     pcicSet (sock, PCIC_CSCINT, (irq << 4) | 0x00);
  495.     semGive (&pcicMuteSem);   /* mutual execlusion stop */
  497.     return (OK);
  498.     }
  500. /*******************************************************************************
  501. *
  502. * pcicCscPoll - Get the card status by polling the register.
  503. *
  504. * This routine gets the card status by polling the register.
  505. * This routine can be called in interrupt level.
  506. *
  507. * RETURNS: The card status of the socket.
  508. */
  510. LOCAL int pcicCscPoll
  511.     (
  512.     int sock /* socket no. */
  513.     )
  514.     {
  515.     BOOL intMode = intContext ();
  516.     int  value;
  517.     int  value0;
  518.     int  status;
  520.     if (!intMode)
  521.         semTake (&pcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  523.     value = pcicGet (sock, PCIC_CSC);
  524.     while ((value0 = pcicGet (sock, PCIC_CSC)) != 0)
  525.         value |= value0;
  527.     if (pcicGet (sock, PCIC_INTCTL) & PCIC_PC_IOCARD)
  528. status  = (value & PCIC_CSC_STSCHG) ? PC_STSCHG : 0;
  529.     else
  530. {
  531. status  = (value & PCIC_CSC_BVD1) ? PC_BATDEAD : 0;
  532. status |= (value & PCIC_CSC_BVD2) ? PC_BATWARN : 0;
  533.         }
  534.     status |= (value & PCIC_CSC_READY) ? PC_READY : 0;
  535.     status |= (value & PCIC_CSC_DETECT) ? PC_DETECT : 0;
  537.     if (!intMode)
  538.         semGive (&pcicMuteSem);   /* mutual execlusion stop */
  540.     return (status);
  541.     }
  543. /*******************************************************************************
  544. *
  545. * pcicIrqGet - Get IRQ level of the socket.
  546. *
  547. * This routine gets IRQ level of the socket.
  548. *
  549. * RETURNS: The IRQ level of the socket.
  550. */
  552. LOCAL int pcicIrqGet
  553.     (
  554.     int sock /* socket no. */
  555.     )
  556.     {
  557.     char value;
  559.     semTake (&pcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  561.     value = pcicGet (sock, PCIC_INTCTL);
  563.     semGive (&pcicMuteSem);   /* mutual execlusion stop */
  565.     return (value & PCIC_IRQ_MASK);
  566.     }
  568. /*******************************************************************************
  569. *
  570. * pcicIrqSet - Set IRQ level of the socket.
  571. *
  572. * This routine sets IRQ level of the socket.
  573. *
  574. * RETURNS: OK, or ERROR if the IRQ level is greater than 15.
  575. */
  577. LOCAL STATUS pcicIrqSet
  578.     (
  579.     int sock, /* socket no. */
  580.     int irq /* IRQ level for the PC card */
  581.     )
  582.     {
  583.     char value;
  585.     if (irq > 15)
  586. return (ERROR);
  588.     semTake (&pcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  590.     value = pcicGet (sock, PCIC_INTCTL);
  591.     value = (value & ~PCIC_IRQ_MASK) | irq;
  592.     pcicSet (sock, PCIC_INTCTL, value);
  594.     semGive (&pcicMuteSem);   /* mutual execlusion stop */
  596.     return (OK);
  597.     }
  599. /*******************************************************************************
  600. *
  601. * pcicReset - Reset a card in the socket.
  602. *
  603. * This routine reset a card in the socket.
  604. *
  605. * RETURNS: OK (always).
  606. */
  608. LOCAL STATUS pcicReset
  609.     (
  610.     int sock /* socket no. */
  611.     )
  612.     {
  614.     semTake (&pcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  616.     /* Turn off interrupts, select memory-only interface */
  618.     pcicBclr (sock, PCIC_INTCTL, PCIC_PC_IOCARD | PCIC_IRQ_MASK);
  620.     /* Turn off all IO and Memory windows */
  622.     pcicBclr (sock, PCIC_ADDRWIN, PCIC_ENA_ALL);
  624.     semGive (&pcicMuteSem);   /* mutual execlusion stop */
  626.     return (OK);
  627.     }
  629. /*******************************************************************************
  630. *
  631. * pcicIowinGet - Get the IO window of the socket.
  632. *
  633. * This routine gets the IO window of the socket.
  634. *
  635. * RETURNS: OK, or ERROR if the window number is greater than max windows.
  636. */
  638. LOCAL STATUS pcicIowinGet
  639.     (
  640.     int  sock, /* socket no. */
  641.     PCMCIA_IOWIN *io /* io window structure to get */
  642.     )
  643.     {
  644.     char window = io->window;
  645.     char ioctl;
  646.     char addr;
  648.     if (window >= PCIC_IO_WINDOWS)
  649. return (ERROR);
  651.     semTake (&pcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  653.     ioctl = pcicGet (sock, PCIC_IOCTL);
  654.     addr = pcicGet (sock, PCIC_ADDRWIN);
  656.     io->start = pcicGet2 (sock, PCIC_IO(window)+PCIC_W_START);
  657.     io->stop = pcicGet2 (sock, PCIC_IO(window)+PCIC_W_STOP);
  658.     io->extraws = (ioctl & PCIC_IOCTL_WAIT(window)) ? 1 : 0;
  659.     io->flags = (addr & PCIC_ENA_IO(window)) ? MAP_ACTIVE : 0;
  660.     io->flags  |= (ioctl & PCIC_IOCTL_0WS(window)) ? MAP_0WS : 0;
  661.     io->flags  |= (ioctl & PCIC_IOCTL_CS16(window)) ? MAP_CS16 : 0;
  662.     io->flags  |= (ioctl & PCIC_IOCTL_16BIT(window)) ? MAP_16BIT : 0;
  664.     semGive (&pcicMuteSem);   /* mutual execlusion stop */
  666.     return (OK);
  667.     }
  669. /*******************************************************************************
  670. *
  671. * pcicIowinSet - Set the IO window of the socket.
  672. *
  673. * This routine sets the IO window of the socket.
  674. *
  675. * RETURNS: OK, or ERROR if there is an error.
  676. */
  678. LOCAL STATUS pcicIowinSet
  679.     (
  680.     int  sock, /* socket no. */
  681.     PCMCIA_IOWIN *io /* io window structure to set */
  682.     )
  683.     {
  684.     char window = io->window;
  685.     char ioctl;
  687.     if ((window >= PCIC_IO_WINDOWS) || (io->start > 0xffff) ||
  688. (io->stop > 0xffff) || (io->stop < io->start))
  689. return (ERROR);
  691.     semTake (&pcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  693.     ioctl = pcicGet (sock, PCIC_IOCTL) & ~PCIC_IOCTL_MASK(window);
  695.     /* Turn off the window before changing anything */
  696.     if (pcicGet (sock, PCIC_ADDRWIN) & PCIC_ENA_IO(window))
  697. pcicBclr (sock, PCIC_ADDRWIN, PCIC_ENA_IO(window));
  699.     pcicSet2 (sock, PCIC_IO(window)+PCIC_W_START, io->start);
  700.     pcicSet2 (sock, PCIC_IO(window)+PCIC_W_STOP, io->stop);
  701.     if (io->extraws) 
  702. ioctl |= PCIC_IOCTL_WAIT(window);
  703.     if (io->flags & MAP_0WS) 
  704. ioctl |= PCIC_IOCTL_0WS(window);
  705.     if (io->flags & MAP_CS16) 
  706. ioctl |= PCIC_IOCTL_CS16(window);
  707.     if (io->flags & MAP_16BIT) 
  708. ioctl |= PCIC_IOCTL_16BIT(window);
  709.     pcicSet (sock, PCIC_IOCTL, ioctl);
  711.     /* Turn on the window if necessary */
  712.     if (io->flags & MAP_ACTIVE)
  713. pcicBset (sock, PCIC_ADDRWIN, PCIC_ENA_IO(window));
  715.     semGive (&pcicMuteSem);   /* mutual execlusion stop */
  717.     return (OK);
  718.     }
  720. /*******************************************************************************
  721. *
  722. * pcicMemwinGet - Get the Memory window of the socket.
  723. *
  724. * This routine gets the Memory window of the socket.
  725. *
  726. * RETURNS: OK, or ERROR if the window number is greater than max windows.
  727. */
  729. LOCAL STATUS pcicMemwinGet
  730.     (
  731.     int   sock, /* socket no. */
  732.     PCMCIA_MEMWIN *mem /* memory window structure to get */
  733.     )
  734.     {
  735.     char window = mem->window;
  736.     char addr;
  737.     short base;
  738.     short value;
  739.     
  740.     if (window >= PCIC_MEM_WINDOWS)
  741. return (ERROR);
  743.     semTake (&pcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  745.     addr     = pcicGet (sock, PCIC_ADDRWIN);
  746.     base     = PCIC_MEM(window);
  748.     mem->flags     = (addr & PCIC_ENA_MEM(window)) ? MAP_ACTIVE : 0;
  749.     
  750.     value = pcicGet2 (sock, base+PCIC_W_START);
  751.     mem->flags     |= (value & PCIC_MEM_16BIT) ? MAP_16BIT : 0;
  752.     mem->flags     |= (value & PCIC_MEM_0WS) ? MAP_0WS : 0;
  753.     mem->start      = ((long)(value & 0x0fff) << 12);
  754.     
  755.     value = pcicGet2 (sock, base+PCIC_W_STOP);
  756.     mem->extraws    = (value & PCIC_MEM_WS0) ? 1 : 0;
  757.     mem->extraws   += (value & PCIC_MEM_WS1) ? 2 : 0;
  758.     mem->stop     = ((long)(value & 0x0fff) << 12) + 0x0fff;
  759.     
  760.     value = pcicGet2 (sock, base+PCIC_W_OFF);
  761.     mem->flags    |= (value & PCIC_MEM_WRPROT) ? MAP_WRPROT : 0;
  762.     mem->flags    |= (value & PCIC_MEM_REG) ? MAP_ATTRIB : 0;
  763.     mem->cardstart  = ((long)(value & 0x3fff) << 12) + mem->start;
  764.     mem->cardstart &= 0x3ffffff;
  766.     semGive (&pcicMuteSem);   /* mutual execlusion stop */
  768.     return (OK);
  769.     }
  771. /*******************************************************************************
  772. *
  773. * pcicMemwinSet - Set the Memory window of the socket.
  774. *
  775. * This routine sets the Memory window of the socket.
  776. *
  777. * RETURNS: OK, or ERROR if there is an error.
  778. */
  780. LOCAL STATUS pcicMemwinSet
  781.     (
  782.     int   sock, /* socket no. */
  783.     PCMCIA_MEMWIN *mem /* memory window structure to set */
  784.     )
  785.     {
  786.     char window = mem->window;
  787.     short base;
  788.     short value;
  789.     
  790.     if ((window >= PCIC_MEM_WINDOWS) || (mem->cardstart > 0x3ffffff) ||
  791. (mem->start > 0xffffff) || (mem->stop > 0xffffff) ||
  792. (mem->start > mem->stop) || (mem->extraws > 3))
  793. return (ERROR);
  795.     semTake (&pcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  797.     base = PCIC_MEM(window);
  799.     /* Turn off the window before changing anything */
  800.     if (pcicGet (sock, PCIC_ADDRWIN) & PCIC_ENA_MEM(window))
  801. pcicBclr (sock, PCIC_ADDRWIN, PCIC_ENA_MEM(window));
  802.     
  803.     value = mem->start >> 12;
  804.     if (mem->flags & MAP_16BIT)
  805. {
  806. value |= PCIC_MEM_16BIT;
  807. pcicBset (sock, PCIC_ADDRWIN, PCIC_ENA_MEMCS16);
  808. }
  809.     if (mem->flags & MAP_0WS)
  810. value |= PCIC_MEM_0WS;
  811.     pcicSet2 (sock, base+PCIC_W_START, value);
  812.     
  813.     value = mem->stop >> 12;
  814.     if (mem->extraws & 1)
  815. value |= PCIC_MEM_WS0;
  816.     if (mem->extraws & 2)
  817. value |= PCIC_MEM_WS1;
  818.     pcicSet2 (sock, base+PCIC_W_STOP, value);
  819.     
  820.     value = ((mem->cardstart - mem->start) >> 12) & 0x3fff;
  821.     if (mem->flags & MAP_WRPROT)
  822. value |= PCIC_MEM_WRPROT;
  823.     if (mem->flags & MAP_ATTRIB)
  824. value |= PCIC_MEM_REG;
  825.     pcicSet2 (sock, base+PCIC_W_OFF, value);
  826.     
  827.     /* Turn on the window if necessary */
  828.     if (mem->flags & MAP_ACTIVE)
  829. pcicBset (sock, PCIC_ADDRWIN, PCIC_ENA_MEM(window));
  831.     semGive (&pcicMuteSem);   /* mutual execlusion stop */
  833.     return (OK);
  834.     }
  836. /*******************************************************************************
  837. *
  838. * pcicGet - Get a value from the register.
  839. *
  840. * This routine gets a value from the register.
  841. *
  842. * RETURNS: A value of the register.
  843. */
  845. LOCAL int pcicGet
  846.     (
  847.     int sock, /* socket no. */
  848.     int reg /* register no. */
  849.     )
  850.     {
  851.     short port = PCIC_PORT (sock);
  852.     char offset = PCIC_REG (sock, reg);
  854.     sysOutByte (port, offset);
  855.     return (sysInByte (port+1));
  856.     }
  858. /*******************************************************************************
  859. *
  860. * pcicSet - Set a value into the register.
  861. *
  862. * This routine sets a value into the register.
  863. *
  864. * RETURNS: N/A
  865. */
  867. LOCAL void pcicSet
  868.     (
  869.     int  sock, /* socket no. */
  870.     int  reg, /* register no. */
  871.     char value /* value to set */
  872.     )
  873.     {
  874.     short port = PCIC_PORT (sock);
  875.     char offset = PCIC_REG (sock, reg);
  877.     sysOutByte (port, offset);
  878.     sysOutByte (port+1, value);
  879.     }
  881. /*******************************************************************************
  882. *
  883. * pcicBset - Set specified bits in the register.
  884. *
  885. * This routine sets specified bits in the register.
  886. *
  887. * RETURNS: N/A
  888. */
  890. LOCAL void pcicBset
  891.     (
  892.     int  sock, /* socket no. */
  893.     int  reg, /* register no. */
  894.     char mask /* bits to set */
  895.     )
  896.     {
  897.     char value = pcicGet (sock, reg);
  899.     value |= mask;
  900.     pcicSet (sock, reg, value);
  901.     }
  903. /*******************************************************************************
  904. *
  905. * pcicBclr - Clear specified bits in the register.
  906. *
  907. * This routine clears specified bits in the register.
  908. *
  909. * RETURNS: N/A
  910. */
  912. LOCAL void pcicBclr
  913.     (
  914.     int  sock, /* socket no. */
  915.     int  reg, /* register no. */
  916.     char mask /* bits to clear */
  917.     )
  918.     {
  919.     char value = pcicGet (sock, reg);
  921.     value &= ~mask;
  922.     pcicSet (sock, reg, value);
  923.     }
  925. /*******************************************************************************
  926. *
  927. * pcicGet2 - Get a value from the consecutive registers.
  928. *
  929. * This routine gets a value from the consecutive registers.
  930. *
  931. * RETURNS: a value of the register
  932. */
  934. LOCAL int pcicGet2
  935.     (
  936.     int sock, /* socket no. */
  937.     int reg /* register no. */
  938.     )
  939.     {
  940.     short a = pcicGet (sock, reg);
  941.     short b = pcicGet (sock, reg+1);
  943.     return (a + (b<<8));
  944.     }
  946. /*******************************************************************************
  947. *
  948. * pcicSet2 - Set a value into the consecutive registers.
  949. *
  950. * This routine sets a value into the consecutive registers.
  951. *
  952. * RETURNS: N/A
  953. */
  955. LOCAL void pcicSet2
  956.     (
  957.     int   sock, /* socket no. */
  958.     int   reg, /* register no. */
  959.     short value /* value to set */
  960.     )
  961.     {
  962.     pcicSet (sock, reg, value & 0xff);
  963.     pcicSet (sock, reg+1, value >> 8);
  964.     }