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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
cisLib.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：25k
源码类别：

VxWorks

开发平台：

C/C++

cisLib.c：源码内容
  1. /* cisLib.c - PCMCIA CIS library */
  3. /* Copyright 1984-1996 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01f,21jun00,rsh  upgrade to dosFs 2.0
  10. 01g,17sep98,lrn  reworked DosFs 2.0 support and memory leak issues
  11. 01f,14jul98,lrn  DosFs2.0: can not delete DOS devices
  12. 01e,16jan97,hdn  added pCtrl->memBase, CIS_MAX_TUPLES.
  13. 01d,28mar96,jdi  doc: cleaned up language and format.
  14. 01c,08mar96,hdn  added more descriptions.
  15. 01b,22feb96,hdn  cleaned up
  16. 01a,10feb95,hdn  written.
  17. */
  20. /*
  21. DESCRIPTION
  22. This library contains routines to manipulate the CIS (Configuration
  23. Information Structure) tuples and the card configuration registers.
  24. The library uses a memory window which is defined in `pcmciaMemwin'
  25. to access the CIS of a PC card.
  26. All CIS tuples in a PC card are read and stored in a linked list,
  27. `cisTupleList'.  If there are configuration tuples, they are interpreted
  28. and stored in another link list, `cisConifigList'.  After the CIS is read,
  29. the PC card's enabler routine allocates resources and initializes a device
  30. driver for the PC card.
  32. If a PC card is inserted, the CSC (Card Status Change) interrupt handler
  33. gets a CSC event from the PCMCIA chip and adds a cisGet() job to the
  34. PCMCIA daemon.  The PCMCIA daemon initiates the cisGet() work.  The CIS
  35. library reads the CIS from the PC card and makes a linked list of CIS
  36. tuples.  It then enables the card.
  38. If the PC card is removed, the CSC interrupt handler gets a CSC event from
  39. the PCMCIA chip and adds a cisFree() job to the PCMCIA daemon.  The PCMCIA
  40. daemon initiates the cisFree() work.  The CIS library frees allocated 
  41. memory for the linked list of CIS tuples.
  42. */
  45. #include "vxWorks.h"
  46. #include "taskLib.h"
  47. #include "sysLib.h"
  48. #include "stdlib.h"
  49. #include "string.h"
  50. #include "drv/pcmcia/pcmciaLib.h"
  51. #include "drv/pcmcia/cisLib.h"
  54. /* defines */
  57. /* imports */
  59. IMPORT PCMCIA_CTRL pcmciaCtrl;
  60. IMPORT PCMCIA_MEMWIN pcmciaMemwin[];
  61. IMPORT PCCARD_ENABLER   pccardEnabler[];
  62. IMPORT int pccardEnablerNumEnt;
  65. /* globals */
  67. SEMAPHORE cisMuteSem;
  70. /* locals */
  72. LOCAL u_char powerMantissa [] = {10, 12, 13, 15, 20, 25, 30, 35,
  73.  40, 45, 50, 55, 60, 70, 80, 90};
  74. LOCAL u_char powerExponent [] = {0, 0, 0, 0, 0, 1, 10, 100};
  77. /* forward declarations */
  79. LOCAL STATUS cisTupleGet (int sock);
  80. LOCAL STATUS cisConfigGet (int sock);
  81. LOCAL STATUS cisResourceGet (int sock);
  84. /*******************************************************************************
  85. *
  86. * cisGet - get information from a PC card's CIS
  87. *
  88. * This routine gets information from a PC card's CIS, configures the PC card,
  89. * and allocates resources for the PC card.
  90. *
  91. * RETURNS: OK, or ERROR if it cannot get the CIS information,
  92. * configure the PC card, or allocate resources.
  93. */
  95. STATUS cisGet
  96.     (
  97.     int sock /* socket no. */
  98.     )
  99.     {
  100.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  101.     PCMCIA_CHIP *pChip = &pCtrl->chip;
  102.     PCMCIA_CARD *pCard = &pCtrl->card[sock];
  103.     STATUS status = ERROR;
  104.     DL_NODE *pNode;
  105.     DL_NODE *pTemp;
  108.     semTake (&cisMuteSem, WAIT_FOREVER); /* mutual exclusion begin */
  109.     (void) (* pChip->cscOff) (sock, pChip->intLevel);
  111.     for (pNode = DLL_FIRST(&pCard->cisTupleList); pNode != NULL; pNode = pTemp)
  112. {
  113. pTemp = DLL_NEXT(pNode);
  114. free (pNode);
  115. }
  117.     for (pNode = DLL_FIRST(&pCard->cisConfigList); pNode != NULL; pNode = pTemp)
  118. {
  119. pTemp = DLL_NEXT(pNode);
  120. free (pNode);
  121. }
  123.     dllInit (&pCard->cisTupleList);
  124.     dllInit (&pCard->cisConfigList);
  126.     if ((cisTupleGet (sock) == OK) &&
  127. (cisConfigGet (sock) == OK) &&
  128.      (cisResourceGet (sock) == OK))
  129. status = OK;
  131.     (void) (* pChip->cscPoll) (sock);
  133.     (void) (* pChip->cscOn) (sock, pChip->intLevel);
  134.     semGive (&cisMuteSem); /* mutual exclusion end */
  136.     return (status);
  137.     }
  139. /*******************************************************************************
  140. *
  141. * cisTupleGet - get tuples from PC card and attach it to the link list
  142. *
  143. * This routine get tuples from PC card and attach it to the link list.
  144. *
  145. * RETURNS: OK, or ERROR if it couldn't set a value to the PCMCIA chip.
  146. */
  148. LOCAL STATUS cisTupleGet
  149.     (
  150.     int sock /* socket no. */
  151.     )
  153.     {
  154.     BOOL endList = FALSE;
  155.     BOOL noLink = FALSE;
  156.     u_long longlinkA = 0;
  157.     u_long longlinkC = 0;
  158.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  159.     PCMCIA_CHIP *pChip = &pCtrl->chip;
  160.     PCMCIA_CARD *pCard = &pCtrl->card[sock];
  161.     int ix = 0;
  162.     PCMCIA_MEMWIN cisMemwin;
  163.     CIS_TUPLE_A *pTupleA;
  164.     CIS_TUPLE_C *pTupleC;
  165.     DL_NODE *pNode;
  166.     u_char *pChar;
  167.     u_char *pd;
  168.     u_char *ps;
  169.     int flag;
  170.     int tuples;
  172.     /* XXX
  173.      * Assumption
  174.      * 1. CIS tuple chain is in between start and stop in pcmciaMemwin[0].
  175.      * 2. Longlink from Common memory to Attribute memory doesn't occur
  176.      *
  177.      * Card reset/power signal sequence (See p.60 PCMCIA Developer's guide)
  178.      *                  ______________________________________________
  179.      *   Card detect  __|
  180.      *                   >50ms-
  181.      *                         _______________________________________
  182.      *   Vcc          _________|
  183.      *                          >300ms--------
  184.      *   Card signal                          ________________________
  185.      *       enabled  ________________________|
  186.      *                                        __________
  187.      *   Reset        ________________________|        |______________
  188.      *                                         >10ms---
  189.      *                                                  >20ms----
  190.      *   Card access                                             _____
  191.      *       allowed  ___________________________________________|
  192.      */
  194.     if (pChip->installed != TRUE)
  195. return (ERROR);
  197.     taskDelay (sysClkRateGet() >> 3); /* 7 * 16ms = 112ms */
  199.     if ((* pChip->reset)(sock) != OK)
  200. return (ERROR);
  202.     flag = PC_PWR_AUTO | PC_VCC_5V | PC_VPP_5V;
  203.     if ((* pChip->flagSet)(sock, flag) != OK)
  204. return (ERROR);
  206.     taskDelay (sysClkRateGet() >> 1); /* 30 * 16ms = 500ms */
  208.     flag = PC_PWR_AUTO | PC_VCC_5V | PC_VPP_5V | PC_RESET;
  209.     if ((* pChip->flagSet)(sock, flag) != OK)
  210. return (ERROR);
  212.     taskDelay (sysClkRateGet() >> 4); /* 3 * 16ms = 48ms */
  214.     flag = PC_PWR_AUTO | PC_VCC_5V | PC_VPP_5V;
  215.     if ((* pChip->flagSet)(sock, flag) != OK)
  216. return (ERROR);
  218.     taskDelay (sysClkRateGet() >> 2); /* 15 * 16ms = 240ms */
  220.     flag = PC_READY | PC_POWERON;
  221.     while ((((* pChip->status)(sock) & flag) != flag) && (ix++ < 8))
  222. taskDelay (sysClkRateGet() >> 2);
  224.     do  {
  226. /* map attribute memory */
  228. pChar = (u_char *)pcmciaMemwin[CIS_MEM_TUPLE].start +
  229.   pCtrl->memBase;
  230.         cisMemwin.window = PCMCIA_CIS_WINDOW;
  231.         cisMemwin.flags = MAP_ACTIVE | MAP_16BIT | MAP_ATTRIB;
  232.         cisMemwin.extraws = 2;
  233.         cisMemwin.start = pcmciaMemwin[CIS_MEM_TUPLE].start;
  234.         cisMemwin.stop = pcmciaMemwin[CIS_MEM_TUPLE].stop;
  235.         cisMemwin.cardstart = longlinkA;
  236. if ((* pChip->memwinSet)(sock, &cisMemwin) != OK)
  237.     return (ERROR);
  239. /* check the link target tuple if we had longlink tuple */
  241. if (longlinkA != 0)
  242.     {
  243.     longlinkA = 0;
  244.     pTupleA = (CIS_TUPLE_A *)pChar;
  245.     if (pTupleA->code == CISTPL_LINKTARGET)
  246. pChar += (pTupleA->link + 2) * 2;
  247.     else
  248. break;
  249.     }
  251. /* parse the tuple chain */
  253. endList = FALSE;
  254. for (tuples = 0; !endList; tuples++)
  255.     {
  256.     pTupleA = (CIS_TUPLE_A *)pChar;
  258.     switch (pTupleA->code)
  259. {
  260. case CISTPL_NULL:
  261.     pChar += 2;
  262.     break;
  264. case CISTPL_LONGLINK_A:
  265.     ps = pChar + 4;
  266.     pd = (u_char *)&longlinkA;
  267.     for (ix = 0; ix < 4; ix++)
  268. *pd++ = *ps++;
  269.     pChar += (pTupleA->link + 2) * 2;
  270.     break;
  272. case CISTPL_LONGLINK_C:
  273.     ps = pChar + 4;
  274.     pd = (u_char *)&longlinkC;
  275.     for (ix = 0; ix < 4; ix++)
  276. *pd++ = *ps++;
  277.     pChar += (pTupleA->link + 2) * 2;
  278.     break;
  280. case CISTPL_NO_LINK:
  281.     noLink = TRUE;
  282.     pChar += (pTupleA->link + 2) * 2;
  283.     break;
  285. case CISTPL_END:
  286.     if (tuples != 0)
  287.         endList = TRUE;
  288.     pChar += (pTupleA->link + 2) * 2;
  289.     break;
  291. case CISTPL_CHECKSUM:
  292.     /* XXX ignore now */
  293.     pChar += (pTupleA->link + 2) * 2;
  294.     break;
  296. default:
  297.     pNode = (DL_NODE *)malloc (pTupleA->link + 2 +
  298.        sizeof(DL_NODE));
  299.     pd = (u_char *)pNode + sizeof(DL_NODE);
  300.     ps = pChar;
  301.     for (ix = 0; ix < (pTupleA->link + 2); ix++)
  302. {
  303. *pd++ = *ps++;
  304. ps++;
  305. }
  306.     dllAdd (&pCard->cisTupleList, pNode);
  307.     pChar += (pTupleA->link + 2) * 2;
  308.     break;
  309. }
  310.     if ((pTupleA->link == 0xff) || (tuples >= CIS_MAX_TUPLES))
  311. endList = TRUE;
  312.     }
  313. } while (longlinkA != 0);
  315.     if (noLink)
  316. {
  317.         /* unmap memory window */
  319.         cisMemwin.window = 0;
  320.         cisMemwin.flags = 0;
  321.         cisMemwin.extraws = 0;
  322.         cisMemwin.start = 0;
  323.         cisMemwin.stop = 0;
  324.         cisMemwin.cardstart = 0;
  325.         if ((* pChip->memwinSet)(sock, &cisMemwin) != OK)
  326.             return (ERROR);
  327.         return (OK);
  328. }
  331.     do  {
  333. /* map common memory */
  335. pChar = (u_char *)pcmciaMemwin[CIS_MEM_TUPLE].start +
  336.   pCtrl->memBase;
  337.         cisMemwin.window = PCMCIA_CIS_WINDOW;
  338.         cisMemwin.flags = MAP_ACTIVE | MAP_16BIT;
  339.         cisMemwin.extraws = 2;
  340.         cisMemwin.start = pcmciaMemwin[CIS_MEM_TUPLE].start;
  341.         cisMemwin.stop = pcmciaMemwin[CIS_MEM_TUPLE].stop;
  342.         cisMemwin.cardstart = longlinkC;
  343. if ((* pChip->memwinSet)(sock, &cisMemwin) != OK)
  344.     return (ERROR);
  346. /* check the link target tuple */
  348. pTupleC = (CIS_TUPLE_C *)pChar;
  349. if (pTupleC->code == CISTPL_LINKTARGET)
  350.     pChar += pTupleC->link + 2;
  351. else
  352.     break;
  354. /* parse the tuple chain */
  356. endList = FALSE;
  357. for (tuples = 0; !endList; tuples++)
  358.     {
  359.     pTupleC = (CIS_TUPLE_C *)pChar;
  360.     switch (pTupleC->code)
  361. {
  362. case CISTPL_NULL:
  363.     pChar++;
  364.     break;
  366. case CISTPL_LONGLINK_A:
  367.     ps = pChar + 2;
  368.     pd = (u_char *)&longlinkA;
  369.     for (ix = 0; ix < 4; ix++)
  370. *pd++ = *ps++;
  371.     
  372.     pChar += pTupleC->link + 2;
  373.     break;
  375. case CISTPL_LONGLINK_C:
  376.     ps = pChar + 2;
  377.     pd = (u_char *)&longlinkC;
  378.     for (ix = 0; ix < 4; ix++)
  379. *pd++ = *ps++;
  380.     
  381.     pChar += pTupleC->link + 2;
  382.     break;
  384. case CISTPL_NO_LINK:
  385.     noLink = TRUE;
  386.     pChar += pTupleC->link + 2;
  387.     break;
  389. case CISTPL_END:
  390.     if (tuples != 0)
  391.         endList = TRUE;
  392.     pChar += pTupleC->link + 2;
  393.     break;
  395. case CISTPL_CHECKSUM:
  396.     /* XXX ignore now */
  397.     pChar += pTupleC->link + 2;
  398.     break;
  400. default:
  401.     pNode = (DL_NODE *)malloc (pTupleC->link + 2 + 
  402.        sizeof(DL_NODE));
  403.     pd = (u_char *)pNode + sizeof(DL_NODE);
  404.     ps = pChar;
  405.     for (ix = 0; ix < (pTupleC->link + 2); ix++)
  406. *pd++ = *ps++;
  407.     dllAdd (&pCard->cisTupleList, pNode);
  408.     pChar += pTupleC->link + 2;
  409.     break;
  410. }
  411.     if ((pTupleC->link == 0xff) || (tuples >= CIS_MAX_TUPLES))
  412. endList = TRUE;
  413.     }
  414. } while (longlinkC != 0);
  416.     /* unmap memory window */
  418.     cisMemwin.window = 0;
  419.     cisMemwin.flags = 0;
  420.     cisMemwin.extraws = 0;
  421.     cisMemwin.start = 0;
  422.     cisMemwin.stop = 0;
  423.     cisMemwin.cardstart = 0;
  424.     if ((* pChip->memwinSet)(sock, &cisMemwin) != OK)
  425.         return (ERROR);
  427.     return (OK);
  428.     }
  430. /*******************************************************************************
  431. *
  432. * cisConfigGet - get configuration information from the CIS tuple link list
  433. *
  434. * Get configuration information from the CIS tuple link list.
  435. *
  436. * RETURNS: OK (always).
  437. */
  439. LOCAL STATUS cisConfigGet
  440.     (
  441.     int sock /* socket no. */
  442.     )
  444.     {
  445.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  446.     PCMCIA_CARD *pCard = &pCtrl->card[sock];
  447.     CIS_CONFIG *pDefault = 0;
  448.     CIS_CONFIG *pConfig;
  449.     DL_NODE *pNode;
  450.     CIS_TUPLE *pTuple;
  451.     CIS_BYTE4 base;
  452.     CIS_BYTE4 mask;
  453.     CIS_BYTE4 addr;
  454.     CIS_BYTE4 length;
  455.     CIS_BYTE4 cAddr;
  456.     CIS_BYTE4 hAddr;
  457.     int lengthSize;
  458.     int addrSize;
  459.     int maskSize;
  460.     int windows;
  461.     int ix;
  462.     u_char *pChar;
  463.     u_char *pEnd;
  464.     u_char *pv;
  465.     u_char featureSelection;
  466.     u_char parameterSelection;
  467.     u_char hostaddr;
  468.     u_char waitScale;
  469.     u_char busyScale;
  470.     u_char reservedScale;
  473.     for (pNode = DLL_FIRST (&pCard->cisTupleList);
  474.  pNode != NULL;
  475.  pNode = DLL_NEXT(pNode))
  476. {
  477. pTuple = (CIS_TUPLE *)((char *)pNode + sizeof (DL_NODE));
  478. pChar = (u_char *)pTuple + sizeof (CIS_TUPLE);
  479. pEnd = pChar + pTuple->link;
  481. switch (pTuple->code)
  482.     {
  483.     case CISTPL_CONFIG:
  484. pCard->regBase = 0;
  485. pCard->regMask = 0;
  486. addrSize = (*pChar & 0x03) + 1;
  487. maskSize = ((*pChar & 0x3c) >> 2) + 1;
  488. pChar += 2;
  489. if (pChar > pEnd)
  490.     break;
  492. base.l = 0;
  493. for (ix = 0; ix < addrSize; ix++)
  494.     base.c[ix] = *pChar++;
  496. mask.l = 0;
  497. for (ix = 0; ix < maskSize; ix++)
  498.     mask.c[ix] = *pChar++;
  500. pCard->regBase = base.l;
  501. pCard->regMask = mask.l;
  502. break;
  503.     
  504.     case CISTPL_CFTABLE_ENTRY:
  505. pConfig = (CIS_CONFIG *)calloc(1, sizeof(CIS_CONFIG));
  506. if (*pChar & 0x40)
  507.     pDefault = pConfig;
  508. else if (pDefault != 0)
  509.     {
  510.     bcopy ((char *)pDefault, (char *)pConfig, 
  511.    sizeof(CIS_CONFIG));
  512.     dllInit ((DL_LIST *)&pConfig->node);
  513.     }
  515. dllAdd (&pCard->cisConfigList, &pConfig->node);
  517. pConfig->index = *pChar & 0x3f;
  518. if (*pChar++ & 0x80)
  519.     pConfig->interfaceType = *pChar++ & 0x0f;
  520. featureSelection = *pChar++;
  522. if (featureSelection & 0x03) /* power description */
  523.     {
  524.     for (ix=1; ix <= (featureSelection & 0x03); ix++)
  525. {
  526. if (ix == 1)
  527.     pv = &pConfig->vcc[0];
  528. else if (ix == 2)
  529.     pv = &pConfig->vpp1[0];
  530. else
  531.     pv = &pConfig->vpp2[0];
  533. parameterSelection = *pChar++;
  534. if (parameterSelection & 0x01)
  535.     {
  536.     *pv++ = powerMantissa[(*pChar & 0x78) >> 3] *
  537.     powerExponent[(*pChar & 0x07)];
  538.     while (*pChar++ & 0x80)
  539. ;
  540.     }
  541. if (parameterSelection & 0x02)
  542.     {
  543.     *pv++ = powerMantissa[(*pChar & 0x78) >> 3] *
  544.     powerExponent[(*pChar & 0x07)];
  545.     while (*pChar++ & 0x80)
  546. ;
  547.     }
  548. if (parameterSelection & 0x04)
  549.     {
  550.     *pv++ = powerMantissa[(*pChar & 0x78) >> 3] *
  551.     powerExponent[(*pChar & 0x07)];
  552.     while (*pChar++ & 0x80)
  553. ;
  554.     }
  555. if (parameterSelection & 0x08)
  556.     {
  557.     while (*pChar++ & 0x80)
  558. ;
  559.     }
  560. if (parameterSelection & 0x10)
  561.     {
  562.     while (*pChar++ & 0x80)
  563. ;
  564.     }
  565. if (parameterSelection & 0x20)
  566.     {
  567.     while (*pChar++ & 0x80)
  568. ;
  569.     }
  570. if (parameterSelection & 0x40)
  571.     {
  572.     while (*pChar++ & 0x80)
  573. ;
  574.     }
  575. }
  576.     }
  577. if (featureSelection & 0x04) /* timing description */
  578.     {
  579.     waitScale   = *pChar & 0x03;
  580.     busyScale   = (*pChar & 0x1c) >> 2;
  581.     reservedScale = (*pChar & 0xe0) >> 5;
  583.     pChar++;
  584.     if (waitScale != 0x03)
  585. while (*pChar++ & 0x80)
  586.     ;
  587.     if (busyScale != 0x03)
  588. while (*pChar++ & 0x80)
  589.     ;
  590.     if (reservedScale != 0x03)
  591. while (*pChar++ & 0x80)
  592.     ;
  593.     }
  594. if (featureSelection & 0x08) /* IO description */
  595.     {
  596.     pConfig->ioAddrlines = *pChar & 0x1f;
  597.     pConfig->ioBuswidth  = (*pChar & 0x60) >> 5;
  598.     pConfig->ioRanges  = 0;
  599.     if (*pChar++ & 0x80)
  600. {
  601. pConfig->ioRanges = (*pChar & 0x07) + 1;
  602. addrSize   = (*pChar & 0x30) >> 4;
  603. lengthSize = (*pChar & 0xc0) >> 6;
  604. pChar++;
  605. for (ix = 0; ix < pConfig->ioRanges; ix++)
  606.     {
  607.     addr.l = 0;
  608.     if (addrSize == 1)
  609. addr.c[0] = *pChar++;
  610.     else if (addrSize == 2)
  611. {
  612. addr.c[0] = *pChar++;
  613. addr.c[1] = *pChar++;
  614. }
  615.     else if (addrSize == 3)
  616. {
  617. addr.c[0] = *pChar++;
  618. addr.c[1] = *pChar++;
  619. addr.c[2] = *pChar++;
  620. addr.c[3] = *pChar++;
  621. }
  622.     length.l = 0;
  623.     if (lengthSize == 1)
  624. length.c[0] = *pChar++;
  625.     else if (lengthSize == 2)
  626. {
  627. length.c[0] = *pChar++;
  628. length.c[1] = *pChar++;
  629. }
  630.     else if (lengthSize == 3)
  631. {
  632. length.c[0] = *pChar++;
  633. length.c[1] = *pChar++;
  634. length.c[2] = *pChar++;
  635. length.c[3] = *pChar++;
  636. }
  637.     pConfig->io[ix].start = addr.l;
  638.     pConfig->io[ix].stop  = addr.l + length.l;
  639.     }
  640. }
  641.     }
  642. if (featureSelection & 0x10) /* IRQ description */
  643.     {
  644.     pConfig->irqMode = (*pChar & 0xe0) >> 5;
  645.     pConfig->irqMask = (*pChar & 0x10) >> 4;
  646.     if (pConfig->irqMask == 1)
  647. {
  648. pConfig->irqSpecial  = *pChar++ & 0x0f;
  649. pConfig->irqBit.c[0] = *pChar++;
  650. pConfig->irqBit.c[1] = *pChar++;
  651. }
  652.     else
  653. {
  654. pConfig->irqSpecial  = 0;
  655. pConfig->irqBit.c[0] = 0;
  656. pConfig->irqBit.c[1] = 0;
  657. pConfig->irqLevel    = *pChar++ & 0x0f;
  658. }
  659.     }
  660. if (featureSelection & 0x60) /* memory description */
  661.     {
  662.     if ((featureSelection & 0x60) == 0x20)
  663. {
  664. length.l = 0;
  665. length.c[0] = *pChar++;
  666. length.c[1] = *pChar++;
  667. pConfig->mem[0].length = length.l;
  668. pConfig->mem[0].cAddr  = 0;
  669. pConfig->mem[0].hAddr  = 0;
  670. }
  671.     else if ((featureSelection & 0x60) == 0x40)
  672. {
  673. length.l    = 0;
  674. cAddr.l     = 0;
  675. length.c[0] = *pChar++;
  676. length.c[1] = *pChar++;
  677. cAddr.c[0]  = *pChar++;
  678. cAddr.c[1]  = *pChar++;
  679. pConfig->mem[0].length = length.l;
  680. pConfig->mem[0].cAddr  = cAddr.l;
  681. pConfig->mem[0].hAddr  = 0;
  682. }
  683.     else if ((featureSelection & 0x60) == 0x60)
  684. {
  685. windows    = (*pChar & 0x07) + 1;
  686. lengthSize = (*pChar & 0x18) >> 3;
  687. addrSize   = (*pChar & 0x60) >> 5;
  688. hostaddr   = *pChar & 0x80;
  689. for (ix = 0; ix < windows; ix++)
  690.     {
  691.     length.l = 0;
  692.     cAddr.l  = 0;
  693.     hAddr.l  = 0;
  694.     if (lengthSize == 1)
  695. length.c[0] = *pChar++;
  696.     else if (lengthSize == 2)
  697. {
  698. length.c[0] = *pChar++;
  699. length.c[1] = *pChar++;
  700. }
  701.     else if (lengthSize == 3)
  702. {
  703. length.c[0] = *pChar++;
  704. length.c[1] = *pChar++;
  705. length.c[2] = *pChar++;
  706. length.c[3] = *pChar++;
  707. }
  709.     if (addrSize == 1)
  710. cAddr.c[0] = *pChar++;
  711.     else if (addrSize == 2)
  712. {
  713. cAddr.c[0] = *pChar++;
  714. cAddr.c[1] = *pChar++;
  715. }
  716.     else if (addrSize == 3)
  717. {
  718. cAddr.c[0] = *pChar++;
  719. cAddr.c[1] = *pChar++;
  720. cAddr.c[2] = *pChar++;
  721. cAddr.c[3] = *pChar++;
  722. }
  723.     
  724.     if (hostaddr == 0x80)
  725. {
  726.         if (addrSize == 1)
  727.     cAddr.c[0] = *pChar++;
  728.         else if (addrSize == 2)
  729.     {
  730.     cAddr.c[0] = *pChar++;
  731.     cAddr.c[1] = *pChar++;
  732.     }
  733.         else if (addrSize == 3)
  734.     {
  735.     cAddr.c[0] = *pChar++;
  736.     cAddr.c[1] = *pChar++;
  737.     cAddr.c[2] = *pChar++;
  738.     cAddr.c[3] = *pChar++;
  739.     }
  740. }
  741.     pConfig->mem[ix].length = length.l;
  742.     pConfig->mem[ix].cAddr  = cAddr.l;
  743.     pConfig->mem[ix].hAddr  = hAddr.l;
  744.     }
  745. }
  746.     }
  747. if (featureSelection & 0x80) /* misc info. description */
  748.     {
  749.     pConfig->twins    = *pChar & 0x07;
  750.     pConfig->audio    = (*pChar & 0x08) >> 3;
  751.     pConfig->readonly = (*pChar & 0x10) >> 4;
  752.     pConfig->pwrdown  = (*pChar & 0x20) >> 5;
  753.     }
  754. break;
  755.     }
  756. }
  758.     return (OK);
  759.     }
  761. /*******************************************************************************
  762. *
  763. * cisResourceGet - config the PC card from the configuration table link list
  764. *
  765. * Config the PC card from the configuration table link list.
  766. *
  767. * RETURNS: OK, or ERROR if the enabler couldn't initialize the PC card.
  768. */
  770. LOCAL STATUS cisResourceGet
  771.     (
  772.     int sock /* socket no. */
  773.     )
  775.     {
  776.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  777.     PCMCIA_CARD *pCard = &pCtrl->card[sock];
  778.     STATUS status = ERROR;
  779.     PCCARD_ENABLER *pEnabler;
  780.     int ix;
  782.     for (ix = 0; ix < pccardEnablerNumEnt; ix++)
  783. {
  784. pEnabler = &pccardEnabler[ix];
  785. if (pEnabler->enableRtn != NULL)
  786.     {
  787.     if ((pCard->initStatus = (* pEnabler->enableRtn) (
  788. sock, 
  789. pEnabler->pResource,
  790. pEnabler->resourceNumEnt,
  791. pEnabler->showRtn)) == ERROR_FIND)
  792. {
  793. continue;
  794. }
  795.     else
  796. {
  797. break;
  798. }
  799.     }
  800. }
  802.     if (pCard->initStatus == OK)
  803. status = OK;
  805.     return (status);
  806.     }
  808. /*******************************************************************************
  809. *
  810. * cisFree - free tuples from the linked list
  811. *
  812. * This routine free tuples from the linked list.
  813. *
  814. * RETURNS: N/A
  815. *
  816. * INTERNAL
  817. * This funcion should not do it by itself, it should called an enabler
  818. * supplied destroy function to delete the device (if possible) in device
  819. * dependent manner.
  820. */
  822. void cisFree
  823.     (
  824.     int sock /* socket no. */
  825.     )
  827.     {
  828.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  829.     PCMCIA_CHIP *pChip = &pCtrl->chip;
  830.     PCMCIA_CARD *pCard = &pCtrl->card[sock];
  831.     PCMCIA_IOWIN iowin;
  832.     PCMCIA_MEMWIN memwin;
  833.     DL_NODE *pNode;
  834.     DL_NODE *pTemp;
  835.     int ix;
  838.     semTake (&cisMuteSem, WAIT_FOREVER); /* mutual exclusion begin */
  839.     (void) (* pChip->cscOff) (sock, pChip->intLevel);
  841.     pCard->type = 0;
  842.     pCard->sock = 0;
  843.     pCard->ctrl = 0;
  844.     pCard->detected = FALSE;
  845.     pCard->installed = FALSE;
  846.     pCard->changed = TRUE;
  847.     pCard->regBase = 0;
  848.     pCard->regMask = 0;
  849.     pCard->initStatus = 0;
  850.     pCard->cscIntr = NULL;
  851.     pCard->showRtn = NULL;
  852.     pCard->pResource = NULL;
  854.     if (pCard->pBlkDev != NULL)
  855.         pCard->pBlkDev->bd_readyChanged = TRUE ;
  857.     if (pCard->pNetIf != NULL)
  858.         free ((char *)pCard->pNetIf);  /* XXX - lrn */
  859.     pCard->pNetIf = NULL;
  861.     if (pCard->pDos != NULL)
  862. {
  863. #if FALSE /* DosFs 2.0 - can not remove dos device */
  864. iosDevDelete (&pCard->pDos->dosvd_devHdr);
  865. free ((char *)pCard->pDos);
  866. #endif /*FALSE*/
  867. }
  868.     pCard->pDos = NULL;
  870.     for (pNode = DLL_FIRST(&pCard->cisTupleList); pNode != NULL; pNode = pTemp)
  871. {
  872. pTemp = DLL_NEXT(pNode);
  873. free (pNode);
  874. }
  875.     dllInit (&pCard->cisTupleList);
  877.     for (pNode = DLL_FIRST(&pCard->cisConfigList); pNode != NULL; pNode = pTemp)
  878. {
  879. pTemp = DLL_NEXT(pNode);
  880. free (pNode);
  881. }
  882.     dllInit (&pCard->cisConfigList);
  884.     (void) (* pChip->irqSet) (sock, 0);
  886.     (void) (* pChip->flagSet) (sock, PC_PWR_AUTO);
  888.     memwin.window = 0;
  889.     memwin.flags = 0;
  890.     memwin.extraws = 0;
  891.     memwin.start = 0;
  892.     memwin.stop = 0;
  893.     memwin.cardstart = 0;
  894.     for (ix = 0; ix < pChip->memWindows; ix++)
  895. {
  896.         memwin.window = ix;
  897.         (void) (* pChip->memwinSet) (sock, &memwin);
  898. }
  900.     iowin.window = 0;
  901.     iowin.flags = 0;
  902.     iowin.extraws = 0;
  903.     iowin.start = 0;
  904.     iowin.stop = 0;
  905.     for (ix = 0; ix < pChip->ioWindows; ix++)
  906. {
  907.         iowin.window = ix;
  908.         (void) (* pChip->iowinSet) (sock, &iowin);
  909. }
  911.     (void) (* pChip->cscPoll) (sock);
  913.     (void) (* pChip->cscOn) (sock, pChip->intLevel);
  914.     semGive (&cisMuteSem); /* mutual exclusion end */
  915.     }
  917. /*******************************************************************************
  918. *
  919. * cisConfigregGet - get the PCMCIA configuration register
  920. *
  921. * This routine gets that PCMCIA configuration register.
  922. *
  923. * RETURNS: OK, or ERROR if it cannot set a value on the PCMCIA chip.
  924. */
  926. STATUS cisConfigregGet
  927.     (
  928.     int sock, /* socket no. */
  929.     int reg, /* configuration register no. */
  930.     int *pValue /* content of the register */
  931.     )
  933.     {
  934.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  935.     PCMCIA_CHIP *pChip = &pCtrl->chip;
  936.     PCMCIA_CARD *pCard = &pCtrl->card[sock];
  937.     PCMCIA_MEMWIN memWin;
  938.     char *pReg;
  940.     if ((pCard->regBase == 0) || ((pCard->regMask & (1 << reg)) == 0) ||
  941.         (pChip->installed != TRUE))
  942. return (ERROR);
  943.     
  944.     memWin.window = PCMCIA_CIS_WINDOW;
  945.     memWin.flags = MAP_ACTIVE | MAP_16BIT | MAP_ATTRIB;
  946.     memWin.extraws = 2;
  947.     memWin.start = pcmciaMemwin[CIS_MEM_CONFIG].start;
  948.     memWin.stop = pcmciaMemwin[CIS_MEM_CONFIG].stop;
  949.     memWin.cardstart = pCard->regBase;
  950.     if ((* pChip->memwinSet)(sock, &memWin) != OK)
  951. return (ERROR);
  953.     pReg = (char *)memWin.start + (pCard->regBase & 0xfff) + (reg * 2) +
  954.    pCtrl->memBase;
  955.     *pValue = *pReg;
  957.     memWin.window = 0;
  958.     memWin.flags = 0;
  959.     memWin.extraws = 0;
  960.     memWin.start = 0;
  961.     memWin.stop = 0;
  962.     memWin.cardstart = 0;
  963.     if ((* pChip->memwinSet)(sock, &memWin) != OK)
  964. return (ERROR);
  965.     
  966.     return (OK);
  967.     }
  969. /*******************************************************************************
  970. *
  971. * cisConfigregSet - set the PCMCIA configuration register
  972. *
  973. * This routine sets the PCMCIA configuration register.
  974. *
  975. * RETURNS: OK, or ERROR if it cannot set a value on the PCMCIA chip.
  976. */
  978. STATUS cisConfigregSet
  979.     (
  980.     int sock, /* socket no. */
  981.     int reg, /* register no. */
  982.     int value /* content of the register */
  983.     )
  985.     {
  986.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  987.     PCMCIA_CHIP *pChip = &pCtrl->chip;
  988.     PCMCIA_CARD *pCard = &pCtrl->card[sock];
  989.     PCMCIA_MEMWIN memWin;
  990.     char *pReg;
  992.     if ((pCard->regBase == 0) || ((pCard->regMask & (1 << reg)) == 0) ||
  993.         (pChip->installed != TRUE))
  994. return (ERROR);
  995.     
  996.     memWin.window = PCMCIA_CIS_WINDOW;
  997.     memWin.flags = MAP_ACTIVE | MAP_16BIT | MAP_ATTRIB;
  998.     memWin.extraws = 2;
  999.     memWin.start = pcmciaMemwin[CIS_MEM_CONFIG].start;
  1000.     memWin.stop = pcmciaMemwin[CIS_MEM_CONFIG].stop;
  1001.     memWin.cardstart = pCard->regBase;
  1002.     if ((* pChip->memwinSet)(sock, &memWin) != OK)
  1003. return (ERROR);
  1005.     pReg = (char *)memWin.start + (pCard->regBase & 0xfff) + (reg * 2) +
  1006.    pCtrl->memBase;
  1007.     *pReg = value;
  1009.     memWin.window = 0;
  1010.     memWin.flags = 0;
  1011.     memWin.extraws = 0;
  1012.     memWin.start = 0;
  1013.     memWin.stop = 0;
  1014.     memWin.cardstart = 0;
  1015.     if ((* pChip->memwinSet)(sock, &memWin) != OK)
  1016. return (ERROR);
  1017.     
  1018.     return (OK);
  1019.     }