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

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

VxWorks

开发平台：

C/C++

pccardLib.c：源码内容
  1. /* pccardLib.c - PC CARD enabler library */
  3. /* Copyright 1984-1996 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01k,21jun00,rsh  upgrade to dosFs 2.0
  10. 01o,31aug99,jkf  changed from cbio.h to cbioLib.h
  11. 01n,03nov98,lrn  cleanup warnings
  12. 01m,06oct98,lrn  merge DosFs 2.0 changes into T2.0, DosFs 2.0 API for TFFS
  13. 01l,17sep98,lrn  reworked DosFs 2.0 support and memory leak issues
  14. 01k,13jul98,lrn  DosFs 2.0 - can not delete a DOS device
  15. 01j,19jan98,hdn  added a check to see if the socket is registered.
  16. 01i,11dec97,hdn  added TFFS support for flash PC card.
  17. 01h,19mar97,hdn  deleted a line that writes 0 to the ELT's address config reg.
  18. 01g,16jan97,hdn  initialized pcmciaCtrl.
  19. 01f,17nov96,jdi  doc: tweaks.
  20. 01e,08nov96,dgp  doc: final formatting
  21. 01d,28mar96,jdi  doc: cleaned up language and format.
  22. 01c,08mar96,hdn  added more descriptions.
  23. 01b,22feb96,hdn  cleaned up
  24. 01a,19oct95,hdn  written.
  25. */
  27. /*
  28. DESCRIPTION
  29. This library provides generic facilities for enabling PC CARD.
  30. Each PC card device driver needs to provide an enabler routine and
  31. a CSC interrupt handler.  The enabler routine must be in the
  32. `pccardEnabler' structure.
  33. Each PC card driver has its own resource structure, `xxResources'.  The
  34. ATA PC card driver resource structure is `ataResources' in
  35. sysLib, which also supports a local IDE disk.
  36. The resource structure has a PC card common resource structure in
  37. the first member.  Other members are device-driver dependent resources.
  39. The PCMCIA chip initialization routines tcicInit() and pcicInit() are
  40. included in the PCMCIA chip table `pcmciaAdapter'.
  41. This table is scanned when the PCMCIA library is initialized.  If the
  42. initialization routine finds the PCMCIA chip, it registers all function
  43. pointers of the PCMCIA_CHIP structure.
  45. A memory window defined in `pcmciaMemwin' is used to access
  46. the CIS of a PC card through the routines in cisLib.
  48. SEE ALSO
  49. pcmciaLib, cisLib, tcic, pcic
  51. */
  53. /* LINTLIBRARY */
  55. #include "private/funcBindP.h"
  56. #include "drv/pcmcia/pcmciaLib.h"
  57. #include "drv/pcmcia/cisLib.h"
  58. #include "drv/pcmcia/pcic.h"
  59. #include "drv/pcmcia/tcic.h"
  60. #include "drv/pcmcia/sramDrv.h"
  61. #include "drv/hdisk/ataDrv.h"
  62. #include "cbioLib.h"
  63. #include "dcacheCbio.h"
  64. #include "dpartCbio.h"
  66. #ifdef INCLUDE_ELT
  67. #include "net/if.h"
  68. #include "netinet/if_ether.h"
  69. #include "drv/netif/if_elt.h"
  70. #endif /* INCLUDE_ELT */
  72. #ifdef INCLUDE_TFFS
  73. #include "tffs/tffsDrv.h"
  74. #endif /* INCLUDE_TFFS */
  77. /* defines */
  79. #define ELT_PCMCIA_ID0 0x0101 /* manufacturer code */
  80. #define ELT_PCMCIA_ID1_562 0x0562 /* manufacturer info for 3C562 */
  81. #define ELT_PCMCIA_ID1_589 0x0589 /* manufacturer info for 3C589B */
  83. /* XXX it should go in pc386/pc.h */
  84. #define TFFS0_MEM_START 0xd8000 /* mem start addr for TFFS in sock 0 */
  85. #define TFFS0_MEM_STOP 0xd9fff /* mem stop addr for TFFS in sock 0 */
  86. #define TFFS1_MEM_START 0xda000 /* mem start addr for TFFS in sock 1 */
  87. #define TFFS1_MEM_STOP 0xdbfff /* mem stop addr for TFFS in sock 1 */
  90. /* externs */
  91. IMPORT BOOL pcmciaDebug;
  92. /* dont use partition table decoder unless ATA is included */
  93. #define USE_PARTITIONS FALSE
  95. #ifdef INCLUDE_ELT
  96. IMPORT ELT_CTRL *pEltCtrl [];
  97. LOCAL STATUS pccardEltCscIntr  (int sock, int csc);
  98. #endif /* INCLUDE_ELT */
  100. #ifdef INCLUDE_ATA
  101. IMPORT ATA_CTRL ataCtrl [ATA_MAX_CTRLS];
  102. LOCAL STATUS pccardAtaCscIntr  (int sock, int csc);
  103. #undef USE_PARTITIONS
  104. #define USE_PARTITIONS TRUE
  105. #endif /* INCLUDE_ATA */
  107. #ifdef INCLUDE_SRAM
  108. IMPORT SRAM_CTRL sramCtrl;
  109. IMPORT int sramResourceNumEnt;
  110. LOCAL STATUS pccardSramCscIntr (int sock, int csc);
  111. #endif /* INCLUDE_SRAM */
  113. #ifdef INCLUDE_TFFS
  114. IMPORT char pcDriveNo [];
  115. LOCAL STATUS pccardTffsCscIntr (int sock, int csc);
  116. #endif /* INCLUDE_TFFS */
  119. /* globals */
  121. PCMCIA_CTRL pcmciaCtrl = {PCMCIA_SOCKS, PCMCIA_MEMBASE} ;
  123. PCMCIA_MEMWIN pcmciaMemwin [] =
  124.     {
  125.     {0, 0, 0, CIS_MEM_START, CIS_MEM_STOP, 0}, /* CIS extraction */
  126.     {0, 0, 0, CIS_REG_START, CIS_REG_STOP, 0}, /* config registers */
  127.     };
  129. PCMCIA_ADAPTER pcmciaAdapter [] =
  130.     {
  131.     {PCMCIA_PCIC, PCIC_BASE_ADR, PCIC_INT_VEC, PCIC_INT_LVL, pcicInit, NULL},
  132.     {PCMCIA_TCIC, TCIC_BASE_ADR, TCIC_INT_VEC, TCIC_INT_LVL, tcicInit, NULL}
  133.     };
  135. #ifdef INCLUDE_ELT
  136. ELT_RESOURCE eltResources[] =
  137.     {
  138.     {
  139.      {
  140.      5, 0,
  141.      {ELT0_IO_START, 0}, {ELT0_IO_STOP, 0}, 0,
  142.      0, 0, 0, 0, 0
  143.      },
  144.      ELT0_INT_VEC, ELT0_INT_LVL, ELT0_NRF, ELT0_CONFIG
  145.     },
  146.     {
  147.      {
  148.      5, 0,
  149.      {ELT1_IO_START, 0}, {ELT1_IO_STOP, 0}, 0,
  150.      0, 0, 0, 0, 0
  151.      },
  152.      ELT1_INT_VEC, ELT1_INT_LVL, ELT1_NRF, ELT1_CONFIG
  153.     }
  154.     };
  155. #endif /* INCLUDE_ELT */
  157. #ifdef INCLUDE_SRAM
  158. SRAM_RESOURCE sramResources[] =
  159.     {
  160.     {
  161.      {
  162.      5, 0,
  163.      {0, 0}, {0, 0}, 0,
  164.      SRAM0_MEM_START, SRAM0_MEM_STOP, 1, 0x0, SRAM0_MEM_LENGTH
  165.      }
  166.     },
  167.     {
  168.      {
  169.      5, 0,
  170.      {0, 0}, {0, 0}, 0,
  171.      SRAM1_MEM_START, SRAM1_MEM_STOP, 1, 0x0, SRAM1_MEM_LENGTH
  172.      }
  173.     },
  174.     {
  175.      {
  176.      5, 0,
  177.      {0, 0}, {0, 0}, 0,
  178.      SRAM2_MEM_START, SRAM2_MEM_STOP, 1, 0x0, SRAM2_MEM_LENGTH
  179.      }
  180.     },
  181.     {
  182.      {
  183.      5, 0,
  184.      {0, 0}, {0, 0}, 0,
  185.      SRAM3_MEM_START, SRAM3_MEM_STOP, 1, 0x0, SRAM3_MEM_LENGTH
  186.      }
  187.     }
  188.     };
  189. #endif /* INCLUDE_SRAM */
  191. #ifdef INCLUDE_TFFS
  192. TFFS_RESOURCE tffsResources[] =
  193.     {
  194.     {
  195.      {
  196.      5 /* vcc */, 0 /* vpp */,
  197.      {0, 0}, {0, 0}, 0,
  198.      TFFS0_MEM_START, TFFS0_MEM_STOP, 2 /* extra wait state */,
  199.      0x0 /* offset card address */, 0x0 /* size of the memory */
  200.      }
  201.     },
  202.     {
  203.      {
  204.      5 /* vcc */, 0 /* vpp */,
  205.      {0, 0}, {0, 0}, 0,
  206.      TFFS1_MEM_START, TFFS1_MEM_STOP, 2 /* extra wait state */,
  207.      0x0 /* offset card address */, 0x0 /* size of the memory */
  208.      }
  209.     }
  210.     };
  211. #endif /* INCLUDE_TFFS */
  213. PCCARD_ENABLER pccardEnabler [] =
  214.     {
  215. #ifdef INCLUDE_ELT
  216.     {
  217.      PCCARD_LAN_ELT, (void *)eltResources, NELEMENTS(eltResources),
  218.      (FUNCPTR)pccardEltEnabler, NULL
  219.     },
  220. #endif /* INCLUDE_ELT */
  222. #ifdef INCLUDE_ATA
  223.     {
  224.      PCCARD_ATA, (void *)ataResources, NELEMENTS(ataResources),
  225.      (FUNCPTR)pccardAtaEnabler, NULL
  226.     },
  227. #endif /* INCLUDE_ATA */
  229. #ifdef INCLUDE_TFFS
  230.     {
  231.      PCCARD_FLASH, (void *)tffsResources, NELEMENTS(tffsResources),
  232.      (FUNCPTR)pccardTffsEnabler, NULL
  233.     },
  234. #endif /* INCLUDE_TFFS */
  236. #ifdef INCLUDE_SRAM
  237.     {
  238.      PCCARD_SRAM, (void *)sramResources, NELEMENTS(sramResources),
  239.      (FUNCPTR)pccardSramEnabler, NULL
  240.     }
  241. #endif /* INCLUDE_SRAM */
  242.     };
  244. int pcmciaAdapterNumEnt = NELEMENTS (pcmciaAdapter);
  245. int pccardEnablerNumEnt = NELEMENTS (pccardEnabler);
  248. /* locals */
  250. #ifdef INCLUDE_SRAM
  251. LOCAL int sramSizeTable [] = {512, 2000, 8000, 32000,
  252.       128000, 512000, 2000000, 0};
  253. #endif /* INCLUDE_SRAM */
  255. #ifdef INCLUDE_DOSFS
  256. #define ATA_CACHE_SIZE (128*1024)
  257. #define SRAM_CACHE_SIZE (2*1024)
  258. #define TFFS_CACHE_SIZE (32*1024)
  260. CBIO_DEV_ID sockCbioDevs[ PCIC_MAX_SOCKS * NELEMENTS (pcmciaAdapter) ];
  261. char * sockDevNames[ PCIC_MAX_SOCKS * NELEMENTS (pcmciaAdapter) ] =
  262.  { "/card0", "/card1", "/card2", "/card3",
  263.               "/card4", "/card5", "/card6", "/card7", NULL };
  264. #endif /* INCLUDE_DOSFS */
  265. #ifdef INCLUDE_ATA
  266. #endif
  268. #ifdef INCLUDE_SRAM
  269. #endif
  271. #ifdef INCLUDE_ELT
  272. #endif
  274. #ifdef INCLUDE_TFFS
  275. #endif
  277. /*******************************************************************************
  278. *
  279. * pccardMount - mount a DOS file system
  280. *
  281. * This routine mounts a DOS file system.
  282. *
  283. * RETURNS: OK or ERROR.
  284. */
  285. STATUS pccardMount
  286.     (
  287.     int  sock, /* socket number */
  288.     char *pName /* name of a device */
  289.     )
  291.     {
  293.     printErr( "This function is discontinuedn" );
  294.     return ERROR;
  296. #if FALSE
  297.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  298.     PCMCIA_CHIP *pChip = &pCtrl->chip;
  299.     PCMCIA_CARD *pCard = &pCtrl->card[sock];
  300.     DOS_VOL_DESC *pDos = pCard->pDos;
  302.     if ((!pChip->installed) || (!pCard->installed) || (sock >= pChip->socks))
  303.         return (ERROR);
  305.     if (pDos != NULL)
  306. {
  307. iosDevDelete (&pDos->dosvd_devHdr);
  308. free ((char *)pDos);
  309. return (ERROR);
  310. }
  312.     pCard->pDos = dosFsDevInit (pName, pCard->pBlkDev, NULL);
  313.     if (pCard->pDos == NULL)
  314. return (ERROR);
  316.     return (OK);
  317. #endif /* FALSE */
  318.     }
  320. /*******************************************************************************
  321. *
  322. * pccardMkfs - initialize a device and mount a DOS file system
  323. *
  324. * This routine initializes a device and mounts a DOS file system.
  325. *
  326. * RETURNS: OK or ERROR.
  327. */
  328. STATUS pccardMkfs
  329.     (
  330.     int  sock, /* socket number */
  331.     char *pName /* name of a device */
  332.     )
  334.     {
  336.     printErr( "This function is discontinued. Use dosFsVolFormat()n" );
  337.     return ERROR;
  339. #if FALSE
  340.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  341.     PCMCIA_CHIP *pChip = &pCtrl->chip;
  342.     PCMCIA_CARD *pCard = &pCtrl->card[sock];
  343.     DOS_VOL_DESC *pDos = pCard->pDos;
  345.     if ((!pChip->installed) || (!pCard->installed) || (sock >= pChip->socks))
  346.         return (ERROR);
  348.     if (pDos != NULL)
  349. {
  350. iosDevDelete (&pDos->dosvd_devHdr);
  351. free ((char *)pDos);
  352. return (ERROR);
  353. }
  355.     pCard->pDos = dosFsMkfs (pName, pCard->pBlkDev);
  356.     if (pCard->pDos == NULL)
  357. return (ERROR);
  359.     return (OK);
  360. #endif /* FALSE */
  361.     }
  363. #ifdef INCLUDE_DOSFS
  364. /*******************************************************************************
  365. *
  366. * pccardDosDevCreate - create DOSFS device for on PCMCIA socket.
  367. *
  368. * This routine creates a DOS FS device for PCMCIA socket # <sock>
  369. * with predefined name based on socket number.  The device will use
  370. * device driver pointed by <pBlkDev> to access device on the low level.
  371. *
  372. * If DOS device already exists, only low level driver is changed to
  373. * reflect the new devices physical parameters.
  374. *
  375. * RETURNS: STATUS.
  376. */
  377. LOCAL STATUS pccardDosDevCreate
  378.     (
  379.     int sock,
  380.     void * pBlkDev,
  381.     int cacheSize,
  382.     BOOL partitions
  383.     )
  384.     {
  385.     void * subDev = NULL ;
  386.     void * masterCbio ;
  387.     IMPORT STATUS usrFdiskPartRead();
  388.     STATUS stat;
  390.     /* create cache of appropriate size and DOS device on top of it */
  392.     if ( sockCbioDevs[ sock ] == NULL )
  393.      {
  395.      sockCbioDevs[ sock ] =
  396.           dcacheDevCreate(pBlkDev, 0, cacheSize,
  397.                      sockDevNames[ sock ] );
  398.      if( sockCbioDevs[ sock ] == NULL )
  399.          {
  400.          printErr ("Error during dcacheDevCreate: %pn",
  401.                 (void *)errno );
  402.          return (ERROR);
  403.          }
  404.     if ( partitions )
  405.     {
  406.          masterCbio = dpartDevCreate(sockCbioDevs[ sock ] ,
  407.  1, (FUNCPTR) usrFdiskPartRead );
  409.          if( masterCbio == NULL)
  410.              {
  411.      printErr ("Error creating partition manager: %xn", errno);
  412.              return (ERROR);
  413.              }
  415.     subDev = (void *) dpartPartGet(masterCbio,0);
  416.     }
  417. else
  418.     {
  419.     subDev = sockCbioDevs[ sock ];
  420.     }
  421.      return dosFsDevCreate( sockDevNames[ sock ],
  422.                       subDev, 0,0 );
  423.      }
  425.     /* resize cache and RESET device */
  426.     dcacheDevMemResize (sockCbioDevs[ sock ], cacheSize);
  428.     stat = cbioIoctl (sockCbioDevs[ sock ], CBIO_RESET, pBlkDev );
  430.     if( stat != OK )
  431. {
  432. printErr("pccardDosDevCreate: error substituting block driver, "
  433. "errno=%#xn", errno);
  434. }
  436.     return stat;
  437.     } /* pccardDosDevCreate() */
  438. #endif /* INCLUDE_DOSFS */
  440. #ifdef INCLUDE_ATA
  441. /*******************************************************************************
  442. *
  443. * pccardAtaEnabler - enable the PCMCIA-ATA device
  444. *
  445. * This routine enables the PCMCIA-ATA device.
  446. *
  447. * RETURNS:
  448. * OK, ERROR_FIND if there is no ATA card, or ERROR if another error occurs.
  449. */
  450. STATUS pccardAtaEnabler
  451.     (
  452.     int  sock, /* socket no. */
  453.     ATA_RESOURCE *pAtaResource, /* pointer to ATA resources */
  454.     int  numEnt, /* number of ATA resource entries */
  455.     FUNCPTR  showRtn  /* ATA show routine */
  456.     )
  458.     {
  459.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  460.     PCMCIA_CHIP *pChip = &pCtrl->chip;
  461.     PCMCIA_CARD *pCard = &pCtrl->card[sock];
  462.     CIS_CONFIG  *pConfig = (CIS_CONFIG *)&pCard->cisConfigList;
  463.     PCCARD_RESOURCE *pResource = &pAtaResource->resource;
  464.     int drive = 0;
  465.     int functionCode = 0;
  466.     int diskInterface = 0;
  467.     PCMCIA_IOWIN pcmciaIowin;
  468.     DL_LIST *pList;
  469.     DL_NODE *pNode;
  470.     CIS_TUPLE *pTuple;
  471.     ATA_CTRL *pAtaCtrl;
  472.     int flag;
  473.     int ctrl;
  474.     int sock0;
  475.     char *pChar;
  477.     if (!pChip->installed)
  478. return (ERROR);
  480.     pList = &pCard->cisTupleList;
  481.     for (pNode = DLL_FIRST (pList); pNode != NULL; pNode = DLL_NEXT(pNode))
  482. {
  483. pTuple = (CIS_TUPLE *)((char *)pNode + sizeof (DL_NODE));
  484. pChar = (char *)pTuple + sizeof (CIS_TUPLE);
  486. switch (pTuple->code)
  487.     {
  488.     case CISTPL_FUNCID:
  489. functionCode = *pChar;
  490. break;
  492.     case CISTPL_FUNCE:
  493. if (*pChar++ == FUNCE_TYPE_DISK)
  494.     diskInterface = *pChar;
  495. break;
  496.     }
  497. }
  499.     if ((pcmciaDebug) && (_func_logMsg != NULL))
  500. (* _func_logMsg) ("ATA sock=%d functionCode=%x diskInterface=%xn",
  501.       sock, functionCode, diskInterface, 0, 0, 0);
  502.     /* return if we didn't recognize the card */
  504.     if ((functionCode != FUNC_FIXEDDISK) || (diskInterface != FUNCE_DATA_ATA))
  505. return (ERROR_FIND);
  507.     if ((pcmciaDebug) && (_func_logMsg != NULL))
  508. (* _func_logMsg) ("ATA sock=%d detectedn",
  509.       sock, 0, 0, 0, 0, 0);
  510.     /* get un-used resource */
  512.     for (ctrl = 0; ctrl < numEnt; ctrl++)
  513. {
  514.         pResource = &pAtaResource->resource;
  516. if (pAtaResource->ctrlType == ATA_PCMCIA)
  517.     {
  518.     for (sock0 = 0; sock0 < pChip->socks; sock0++)
  519. {
  520.      PCMCIA_CARD *pCard0 = &pCtrl->card[sock0];
  521. if (pCard0->pResource == pResource) /* used resource */
  522.     break;
  523. }
  524.     if (sock0 == pChip->socks) /* un-used resource */
  525. break;
  526.     }
  528. pAtaResource++;
  529. }
  531.     if (ctrl == numEnt)
  532. {
  533. if (_func_logMsg != NULL)
  534.     (* _func_logMsg) ("pccardAtaEnabler: sock=%d out of resourcen",
  535.       sock, 0, 0, 0, 0, 0);
  536. return (ERROR);
  537. }
  539.     /* configure the card with the resource */
  541.     pList = &pCard->cisConfigList;
  542.     for (pNode = DLL_FIRST(pList); pNode != NULL; pNode = DLL_NEXT(pNode))
  543. {
  544. pConfig = (CIS_CONFIG *)pNode;
  546. if ((pConfig->ioRanges == 2) &&
  547.     (pConfig->io[0].start == pResource->ioStart[0]) &&
  548.     (pConfig->io[1].start == pResource->ioStart[1]))
  549.     {
  550.     pAtaCtrl = &ataCtrl[ctrl];
  551.     pAtaCtrl->ctrlType = ATA_PCMCIA;
  553.     pCard->type = PCCARD_ATA;
  554.     pCard->sock = sock;
  555.     pCard->ctrl = ctrl;
  556.     pCard->detected = TRUE;
  557.     pCard->pResource = pResource;
  558.             pCard->cardStatus = (* pChip->status)(sock);
  559.     pCard->cscIntr = (FUNCPTR)pccardAtaCscIntr;
  560.     pCard->showRtn = (FUNCPTR)showRtn;
  562.     flag = PC_PWR_AUTO | PC_IOCARD;
  563.     if (pResource->vcc == PCCARD_5V)
  564.         flag |= PC_VCC_5V;
  565.     else if (pResource->vcc == PCCARD_3V)
  566.         flag |= PC_VCC_3V;
  567.     if (pResource->vpp == PCCARD_5V)
  568.         flag |= PC_VPP_5V;
  569.     else if (pResource->vpp == PCCARD_12V)
  570.         flag |= PC_VPP_12V;
  571.     if ((* pChip->flagSet)(sock, flag) != OK)
  572.         return (ERROR);
  574.     cisConfigregSet (sock, CONFIG_STATUS_REG, 0x00);
  575.     cisConfigregSet (sock, PIN_REPLACEMENT_REG,
  576.      PRR_RBVD1 | PRR_RBVD2 | PRR_RRDY | PRR_RWPROT);
  577.     cisConfigregSet (sock, SOCKET_COPY_REG, 0x00 | (sock & 0x0f));
  578.     cisConfigregSet (sock, CONFIG_OPTION_REG,
  579.      COR_LEVIREQ | pConfig->index);
  581.     pcmciaIowin.window = PCCARD_IOWIN0;
  582.     pcmciaIowin.flags = MAP_ACTIVE | MAP_16BIT;
  583.     pcmciaIowin.extraws = pResource->ioExtraws;
  584.     pcmciaIowin.start = pResource->ioStart[0];
  585.     pcmciaIowin.stop = pResource->ioStop[0];
  586.     if ((* pChip->iowinSet)(sock, &pcmciaIowin) != OK)
  587.         return (ERROR);
  589.     pcmciaIowin.window = PCCARD_IOWIN1;
  590.     pcmciaIowin.flags = MAP_ACTIVE | MAP_16BIT;
  591.     pcmciaIowin.extraws = pResource->ioExtraws;
  592.     pcmciaIowin.start = pResource->ioStart[1];
  593.     pcmciaIowin.stop = pResource->ioStop[1];
  594.     if ((* pChip->iowinSet)(sock, &pcmciaIowin) != OK)
  595.         return (ERROR);
  597.     if ((* pChip->irqSet)(sock, pAtaResource->intLevel) != OK)
  598.         return (ERROR);
  600.     if ((pCard->initStatus = ataDrv (ctrl,
  601.      pAtaResource->drives,
  602.      pAtaResource->intVector,
  603.      pAtaResource->intLevel,
  604.      pAtaResource->configType,
  605.      pAtaResource->semTimeout,
  606.      pAtaResource->wdgTimeout
  607.      )) != OK)
  608. {
  609.      if (_func_logMsg != NULL)
  610. (* _func_logMsg) ("ATA sock=%d ataDrv failed %xn",
  611.       sock, errno, 0, 0, 0, 0);
  612.         return (ERROR);
  613. }
  615.     pCard->installed = TRUE;
  616.          taskDelay (sysClkRateGet()); /* 1 sec */
  617.     break;
  618.     }
  619. }
  621.     /* return if we didn't install the driver */
  623.     if (!pCard->installed)
  624. return (ERROR);
  626.     if (pCard->pBlkDev != NULL)
  627. free ((char *)pCard->pBlkDev);
  629.     if ((pCard->pBlkDev = ataDevCreate(ctrl, drive, 0, 0)) ==
  630. (BLK_DEV *)NULL)
  631.         {
  632.         printErr ("Error during ataDevCreate: %xn", errno);
  633. return (ERROR);
  634.         }
  636. #ifdef INCLUDE_DOSFS
  637.     {
  638.     return pccardDosDevCreate( sock, pCard->pBlkDev,
  639. ATA_CACHE_SIZE, USE_PARTITIONS );
  640.     }
  641. #else
  642.     printErr ("DosFs not included, card in socket %d ignoredn", sock);
  644.     return (OK);
  645. #endif /* INCLUDE_DOSFS */
  646.     }
  648. /*******************************************************************************
  649. *
  650. * pccardAtaCscIntr - ATA controller PCMCIA card status change interrupt handler.
  651. *
  652. * RETURNS: OK (always).
  653. */
  655. LOCAL STATUS pccardAtaCscIntr
  656.     (
  657.     int sock, /* socket no. */
  658.     int csc /* CSC bits */
  659.     )
  661.     {
  662.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  663.     PCMCIA_CARD *pCard = &pCtrl->card[sock];
  664.     ATA_RESOURCE *pAtaResource = (ATA_RESOURCE *)pCard->pResource;
  665.     ATA_CTRL *pAtaCtrl = &ataCtrl[pCard->ctrl];
  668.     /* hot insertion */
  671.     /* hot removal */
  673.     if ((csc & PC_DETECT) && ((pCard->cardStatus & PC_DETECT) == 0x0))
  674. {
  675.         if (pAtaResource != NULL)
  676.             sysIntDisablePIC (pAtaResource->intLevel);
  678. pAtaCtrl->installed = FALSE;
  679. pAtaCtrl->changed = FALSE;
  681. semFlush (&pAtaCtrl->syncSem);
  682. pcmciaJobAdd ((VOIDFUNCPTR)semTerminate, (int)&pAtaCtrl->muteSem,
  683.       0,0,0,0,0);
  684. }
  686.     return (OK);
  687.     }
  688. #endif /* INCLUDE_ATA */
  690. #ifdef INCLUDE_SRAM
  691. /*******************************************************************************
  692. *
  693. * pccardSramEnabler - enable the PCMCIA-SRAM driver
  694. *
  695. * This routine enables the PCMCIA-SRAM driver.
  696. *
  697. * RETURNS:
  698. * OK, ERROR_FIND if there is no SRAM card, or ERROR if another error occurs.
  699. */
  701. STATUS pccardSramEnabler
  702.     (
  703.     int   sock,   /* socket no. */
  704.     SRAM_RESOURCE *pSramResource, /* pointer to SRAM resources */
  705.     int   numEnt,   /* number of SRAM resource entries */
  706.     FUNCPTR   showRtn    /* SRAM show routine */
  707.     )
  709.     {
  710.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  711.     PCMCIA_CHIP *pChip = &pCtrl->chip;
  712.     PCMCIA_CARD *pCard = &pCtrl->card[sock];
  713.     BOOL typeExtended = FALSE;
  714.     BOOL speedExtended = FALSE;
  715.     int formatOffset = 0;
  716.     int formatNbytes = 0;
  717.     int deviceType = 0;
  718.     int deviceSize = 0;
  719.     int functionCode = NONE;
  720.     PCCARD_RESOURCE *pResource;
  721.     DL_NODE *pNode;
  722.     CIS_TUPLE *pTuple;
  723.     CIS_BYTE4 offset;
  724.     CIS_BYTE4 nbytes;
  725.     int unit;
  726.     int size;
  727.     int flag;
  728.     char *pChar;
  730.     if ((!pChip->installed) || (sock >= numEnt))
  731. return (ERROR);
  733.     for (pNode = DLL_FIRST (&pCard->cisTupleList);
  734.  pNode != NULL;
  735.  pNode = DLL_NEXT(pNode))
  736. {
  737. pTuple = (CIS_TUPLE *)((char *)pNode + sizeof (DL_NODE));
  738. pChar = (char *)pTuple + sizeof (CIS_TUPLE);
  740. switch (pTuple->code)
  741.     {
  742.     case CISTPL_FUNCID:
  743. functionCode = *pChar;
  744. break;
  746.     case CISTPL_DEVICE:
  747. deviceType = *pChar & 0xf0;
  748. if (deviceType == DTYPE_EXTEND)
  749.     typeExtended = TRUE;
  750. if ((*pChar & 0x0f) == DSPEED_EXT)
  751.     speedExtended = TRUE;
  752. pChar++;
  753. while (speedExtended)
  754.     if ((*pChar++ & 0x80) == 0)
  755. speedExtended = FALSE;
  756. while (typeExtended)
  757.     if ((*pChar++ & 0x80) == 0)
  758. typeExtended = FALSE;
  759. unit = ((*pChar & 0xf8) >> 3) + 1;
  760. size = sramSizeTable [*pChar & 0x07];
  761. deviceSize = unit * size;
  762. break;
  764.     case CISTPL_FORMAT:
  765. pChar += 2;
  766. offset.c[0] = *pChar++;
  767. offset.c[1] = *pChar++;
  768. offset.c[2] = *pChar++;
  769. offset.c[3] = *pChar++;
  770. nbytes.c[0] = *pChar++;
  771. nbytes.c[1] = *pChar++;
  772. nbytes.c[2] = *pChar++;
  773. nbytes.c[3] = *pChar++;
  774. formatOffset = offset.l;
  775. formatNbytes = nbytes.l;
  776. break;
  777.     }
  778. }
  780.     /* configure the card with a resource which is assigned for the socket */
  782.     if (((functionCode == NONE) || (functionCode == FUNC_MEMORY)) &&
  783.         ((deviceType == DTYPE_SRAM) || (formatNbytes != 0)))
  784. {
  785.         sramResourceNumEnt = numEnt;
  786.         pSramResource += sock;
  787.         pResource = &pSramResource->resource;
  788.         pCard->type = PCCARD_SRAM;
  789.         pCard->sock = sock;
  790.         pCard->detected = TRUE;
  791.         pCard->pResource = pResource;
  792.         pCard->cardStatus = (* pChip->status)(sock);
  793.         pCard->cscIntr = (FUNCPTR)pccardSramCscIntr;
  794.         pCard->showRtn = (FUNCPTR)showRtn;
  795.         pResource->memStart &= 0xfffff000;
  796.         pResource->memStop |= 0x00000fff;
  797.         pResource->memOffset = formatOffset;
  798.         if (deviceSize != 0)
  799.     pResource->memLength = deviceSize;
  800.         else if (formatNbytes != 0)
  801.     pResource->memLength = formatNbytes;
  802. else
  803.     return (ERROR);
  805.         flag = PC_PWR_AUTO;
  806.         if (pResource->vcc == PCCARD_5V)
  807.     flag |= PC_VCC_5V;
  808.         else if (pResource->vcc == PCCARD_3V)
  809.     flag |= PC_VCC_3V;
  810.         if (pResource->vpp == PCCARD_5V)
  811.     flag |= PC_VPP_5V;
  812.         else if (pResource->vpp == PCCARD_12V)
  813.     flag |= PC_VPP_12V;
  814.         if ((* pChip->flagSet)(sock, flag) != OK)
  815.     return (ERROR);
  817.         if ((pCard->initStatus = sramDrv (sock)) != OK)
  818.     return (ERROR);
  820.         pCard->installed = TRUE;
  821. }
  822.     else
  823. return (ERROR_FIND);
  825.     /* return if we didn't recognize the card or didn't install the driver */
  827.     if (!pCard->installed)
  828. return (ERROR);
  830.     if (pCard->pBlkDev != NULL)
  831. free ((char *)pCard->pBlkDev);
  833.     size = pResource->memLength / DEFAULT_SEC_SIZE - 1; /* number of blocks */
  834.     pCard->pBlkDev = sramDevCreate (sock, DEFAULT_SEC_SIZE, size, size, 0);
  835.     if (pCard->pBlkDev == (BLK_DEV *)NULL)
  836. {
  837. printErr ("Error during sramDevCreate: %xn", errno);
  838. return (ERROR);
  839. }
  841. #ifdef INCLUDE_DOSFS
  842.     /*
  843.      * init DOS device with new block device driver and
  844.      * valid disk cache size
  845.      */
  846.     return pccardDosDevCreate( sock, pCard->pBlkDev,
  847. SRAM_CACHE_SIZE, USE_PARTITIONS );
  848. #else
  849.     return (OK);
  850. #endif /* INCLUDE_DOSFS */
  851.     }
  853. /*******************************************************************************
  854. *
  855. * pccardSramCscIntr - PCMCIA memory card status change interrupt handler
  856. *
  857. * RETURNS: OK, or ERROR if the CSC event is Ready.
  858. */
  860. LOCAL STATUS pccardSramCscIntr
  861.     (
  862.     int sock, /* socket no. */
  863.     int csc /* CSC bits */
  864.     )
  866.     {
  867.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  868.     PCMCIA_CARD *pCard = &pCtrl->card[sock];
  869.     SEM_ID muteSemID = &sramCtrl.muteSem[sock];
  870.     SEM_ID syncSemID = &sramCtrl.syncSem[sock];
  873.     /* hot insertion */
  876.     /* hot removal */
  878.     if ((csc & PC_DETECT) && ((pCard->cardStatus & PC_DETECT) == 0x0))
  879. {
  880. semFlush (syncSemID);
  881. pcmciaJobAdd ((VOIDFUNCPTR)semTerminate, (int)muteSemID, 0, 0, 0, 0, 0);
  882. }
  884.     /* card is ready */
  886.     if (csc & PC_READY)
  887. {
  888. semGive (syncSemID);
  889. return (ERROR);
  890. }
  892.     /* other card status changes */
  894.     if ((csc & PC_BATDEAD) && (_func_logMsg != NULL))
  895. (* _func_logMsg) ("sramDrv: socket=%d Battery deadn",
  896.   sock, 0, 0, 0, 0, 0);
  898.     if ((csc & PC_BATWARN) && (_func_logMsg != NULL))
  899. (* _func_logMsg) ("sramDrv: socket=%d Battery warnn",
  900.   sock, 0, 0, 0, 0, 0);
  902.     if ((csc & PC_WRPROT) && (_func_logMsg != NULL))
  903. (* _func_logMsg) ("sramDrv: socket=%d Write protectn",
  904.   sock, 0, 0, 0, 0, 0);
  906.     return (OK);
  907.     }
  908. #endif /* INCLUDE_SRAM */
  910. #ifdef INCLUDE_ELT
  911. /*******************************************************************************
  912. *
  913. * pccardEltEnabler - enable the PCMCIA Etherlink III card
  914. *
  915. * This routine enables the PCMCIA Etherlink III (ELT) card.
  916. *
  917. * RETURNS:
  918. *
  919. * OK, ERROR_FIND if there is no ELT card, or ERROR if another error occurs.
  920. */
  921. STATUS pccardEltEnabler
  922.     (
  923.     int  sock, /* socket no. */
  924.     ELT_RESOURCE *pEltResource, /* pointer to ELT resources */
  925.     int  numEnt, /* number of ELT resource entries */
  926.     FUNCPTR  showRtn  /* show routine */
  927.     )
  929.     {
  930.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  931.     PCMCIA_CHIP *pChip = &pCtrl->chip;
  932.     PCMCIA_CARD *pCard = &pCtrl->card[sock];
  933.     DL_LIST *pList = &pCard->cisTupleList;
  934.     PCCARD_RESOURCE *pResource = &pEltResource->resource;
  935.     short manufacturerID0 = 0;
  936.     short manufacturerID1 = 0;
  937.     int functionCode = 0;
  938.     DL_NODE *pNode;
  939.     PCMCIA_IOWIN pcmciaIowin;
  940.     CIS_TUPLE *pTuple;
  941.     char *pChar;
  942.     int flag;
  943.     int ctrl;
  944.     int sock0;
  946.     if (!pChip->installed)
  947. return (ERROR);
  949.     for (pNode = DLL_FIRST (pList); pNode != NULL; pNode = DLL_NEXT(pNode))
  950. {
  951. pTuple = (CIS_TUPLE *)((char *)pNode + sizeof (DL_NODE));
  952. pChar = (char *)pTuple + sizeof (CIS_TUPLE);
  954. switch (pTuple->code)
  955.     {
  956.     case CISTPL_FUNCID:
  957. functionCode = *pChar;
  958. break;
  960.     case CISTPL_MANFID:
  961. manufacturerID0 = *(short *)pChar;
  962. manufacturerID1 = *(short *)(pChar+2);
  963. break;
  964.     }
  965. }
  967.     /* return if we didn't recognize the card */
  969.     if ((functionCode != FUNC_LAN) ||
  970.         (manufacturerID0 != ELT_PCMCIA_ID0) ||
  971.         ((manufacturerID1 != ELT_PCMCIA_ID1_589) &&
  972.  (manufacturerID1 != ELT_PCMCIA_ID1_562)))
  973. return (ERROR_FIND);
  975.     /* get un-used resource */
  977.     for (ctrl = 0; ctrl < numEnt; ctrl++)
  978. {
  979.         pResource = &pEltResource->resource;
  981. for (sock0 = 0; sock0 < pChip->socks; sock0++)
  982.     {
  983.          PCMCIA_CARD *pCard0 = &pCtrl->card[sock0];
  984.     if (pCard0->pResource == pResource)
  985. break;
  986.     }
  987. if (sock0 == pChip->socks)
  988.     break;
  990. pEltResource++;
  991. }
  993.     if (ctrl == numEnt)
  994. {
  995. if (_func_logMsg != NULL)
  996.     (* _func_logMsg) ("pccardEltEnabler: sock=%d out of resourcen",
  997.       sock, 0, 0, 0, 0, 0);
  998. return (ERROR);
  999. }
  1001.     /* configure the card with the resource */
  1003.     pCard->type = PCCARD_LAN_ELT;
  1004.     pCard->sock = sock;
  1005.     pCard->ctrl = ctrl;
  1006.     pCard->detected = TRUE;
  1007.     pCard->pResource = pResource;
  1008.     pCard->cardStatus = (* pChip->status)(sock);
  1009.     pCard->cscIntr = (FUNCPTR)pccardEltCscIntr;
  1010.     pCard->showRtn = (FUNCPTR)showRtn;
  1012.     flag = PC_PWR_AUTO | PC_IOCARD;
  1013.     if (pResource->vcc == PCCARD_5V)
  1014.         flag |= PC_VCC_5V;
  1015.     else if (pResource->vcc == PCCARD_3V)
  1016.         flag |= PC_VCC_3V;
  1017.     if (pResource->vpp == PCCARD_5V)
  1018.         flag |= PC_VPP_5V;
  1019.     else if (pResource->vpp == PCCARD_12V)
  1020.         flag |= PC_VPP_12V;
  1021.     if ((* pChip->flagSet)(sock, flag) != OK)
  1022.         return (ERROR);
  1024.     cisConfigregSet (sock, CONFIG_STATUS_REG, 0x00);
  1025.     cisConfigregSet (sock, CONFIG_OPTION_REG, COR_LEVIREQ | 0x03);
  1027.     pcmciaIowin.window = PCCARD_IOWIN0;
  1028.     pcmciaIowin.flags = MAP_ACTIVE | MAP_16BIT;
  1029.     pcmciaIowin.extraws = pResource->ioExtraws;
  1030.     pcmciaIowin.start = pResource->ioStart[0];
  1031.     pcmciaIowin.stop = pResource->ioStop[0];
  1032.     if ((* pChip->iowinSet)(sock, &pcmciaIowin) != OK)
  1033.         return (ERROR);
  1035.     if ((* pChip->irqSet)(sock, pEltResource->intLevel) != OK)
  1036.         return (ERROR);
  1038.     sysOutWord (pResource->ioStart[0] + ELT_COMMAND, SELECT_WINDOW|WIN_CONFIG);
  1039.     sysOutWord (pResource->ioStart[0] + RESOURCE_CONFIG, 0x3f00);
  1042.     if (pCard->pNetIf != NULL)
  1043. free (pCard->pNetIf);
  1045.     if ((pCard->pNetIf = malloc (sizeof(NETIF))) == NULL)
  1046. return (ERROR);
  1048.     pCard->pNetIf->ifName = "pcmcia";
  1049.     pCard->pNetIf->attachRtn = eltattach;
  1050.     pCard->pNetIf->arg1 = (char *)pResource->ioStart[0];
  1051.     pCard->pNetIf->arg2 = pEltResource->intVector;
  1052.     pCard->pNetIf->arg3 = pEltResource->intLevel;
  1053.     pCard->pNetIf->arg4 = pEltResource->rxFrames;
  1054.     pCard->pNetIf->arg5 = pEltResource->connector;
  1055.     pCard->pNetIf->arg6 = (int)pCard->pNetIf->ifName;
  1056.     pCard->pNetIf->arg7 = 0;
  1057.     pCard->pNetIf->arg8 = 0;
  1059.     pCard->installed = TRUE;
  1061.     return (OK);
  1062.     }
  1064. /*******************************************************************************
  1065. *
  1066. * pccardEltCscIntr - ELT controller PCMCIA card status change interrupt handler.
  1067. *
  1068. * RETURNS: OK (always).
  1069. */
  1071. LOCAL STATUS pccardEltCscIntr
  1072.     (
  1073.     int sock, /* socket no. */
  1074.     int csc /* CSC bits */
  1075.     )
  1077.     {
  1078.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  1079.     PCMCIA_CARD *pCard = &pCtrl->card[sock];
  1080.     ELT_RESOURCE *pEltResource = (ELT_RESOURCE *)pCard->pResource;
  1081.     ELT_CTRL *pDrvCtrl = pEltCtrl [pCard->ctrl];
  1084.     /* card is inserted */
  1087.     /* card is removed */
  1089.     if ((csc & PC_DETECT) && ((pCard->cardStatus & PC_DETECT) == 0x0))
  1090. {
  1091.         if (pCard->pResource != 0)
  1092.             sysIntDisablePIC (pEltResource->intLevel);
  1094.         pDrvCtrl->idr.ac_if.if_flags = 0;
  1095.         pDrvCtrl->attached = FALSE;
  1096. }
  1098.     return (OK);
  1099.     }
  1100. #endif /* INCLUDE_ELT */
  1102. #ifdef INCLUDE_TFFS
  1103. /*******************************************************************************
  1104. *
  1105. * pccardTffsEnabler - enable the PCMCIA-TFFS driver
  1106. *
  1107. * This routine enables the PCMCIA-TFFS driver.
  1108. *
  1109. * RETURNS:
  1110. * OK, ERROR_FIND if there is no TFFS(Flash) card, or ERROR if another error occurs.
  1111. */
  1113. STATUS pccardTffsEnabler
  1114.     (
  1115.     int   sock,   /* socket no. */
  1116.     TFFS_RESOURCE *pTffsResource, /* pointer to TFFS resources */
  1117.     int   numEnt,   /* number of SRAM resource entries */
  1118.     FUNCPTR   showRtn    /* TFFS show routine */
  1119.     )
  1121.     {
  1122.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  1123.     PCMCIA_CHIP *pChip = &pCtrl->chip;
  1124.     PCMCIA_CARD *pCard = &pCtrl->card[sock];
  1125.     int deviceType = 0;
  1126.     PCCARD_RESOURCE *pResource;
  1127.     DL_NODE *pNode;
  1128.     CIS_TUPLE *pTuple;
  1129.     int flag;
  1130.     char *pChar;
  1132.     if ((!pChip->installed) || (sock >= numEnt))
  1133. return (ERROR);
  1135.     for (pNode = DLL_FIRST (&pCard->cisTupleList);
  1136.  pNode != NULL;
  1137.  pNode = DLL_NEXT(pNode))
  1138. {
  1139. pTuple = (CIS_TUPLE *)((char *)pNode + sizeof (DL_NODE));
  1140. pChar = (char *)pTuple + sizeof (CIS_TUPLE);
  1142. switch (pTuple->code)
  1143.     {
  1144.     case CISTPL_DEVICE:
  1145. deviceType = *pChar & 0xf0;
  1146. break;
  1147.     }
  1148. }
  1150.     /* configure the card with a resource which is assigned for the socket */
  1152.     if (deviceType == DTYPE_FLASH)
  1153. {
  1154.         pTffsResource += sock;
  1155.         pResource = &pTffsResource->resource;
  1156.         pCard->type = PCCARD_FLASH;
  1157.         pCard->sock = sock;
  1158.         pCard->detected = TRUE;
  1159.         pCard->pResource = pResource;
  1160.         pCard->cardStatus = (* pChip->status)(sock);
  1161.         pCard->cscIntr = (FUNCPTR)pccardTffsCscIntr;
  1162.         pCard->showRtn = (FUNCPTR)showRtn;
  1163.         pResource->memStart &= 0xfffff000;
  1164.         pResource->memStop |= 0x00000fff;
  1166.         flag = PC_PWR_AUTO;
  1167.         if (pResource->vcc == PCCARD_5V)
  1168.     flag |= PC_VCC_5V;
  1169.         else if (pResource->vcc == PCCARD_3V)
  1170.     flag |= PC_VCC_3V;
  1171.         if ((* pChip->flagSet)(sock, flag) != OK)
  1172.     return (ERROR);
  1174.         if ((pCard->initStatus = tffsDrv ()) != OK) /* just in case */
  1175.     return (ERROR);
  1177.         pCard->installed = TRUE;
  1178. }
  1179.     else
  1180. return (ERROR_FIND);
  1182.     /* return if we didn't recognize the card or didn't install the driver */
  1184.     if (!pCard->installed)
  1185. return (ERROR);
  1187.     /* we assume that a media on the socket is formated by tffsDevFormat() */
  1189.     if (pcDriveNo[sock] == NONE)
  1190. {
  1191. printErr ("pccardTffs:pcDriveNo[%d] == NONEn", sock);
  1192. return ERROR ;
  1193. }
  1195.     if (pCard->pBlkDev != NULL)
  1196. free ((char *)pCard->pBlkDev);
  1198.     pCard->pBlkDev = tffsDevCreate (pcDriveNo[sock], TRUE);
  1199.     if (pCard->pBlkDev == (BLK_DEV *)NULL)
  1200.     {
  1201.     printErr ("Error during tffsDevCreate: %xn", errno);
  1202.     return (ERROR);
  1203.     }
  1204.     if ((pcmciaDebug) && (_func_logMsg != NULL))
  1205. (* _func_logMsg) ("TFFS sock=%d blkDev=%xn",
  1206.       sock,pCard->pBlkDev , 0, 0, 0, 0);
  1208. #ifdef INCLUDE_DOSFS
  1209.     /*
  1210.      * init DOS device with new block device driver and
  1211.      * valid disk cache size
  1212.      */
  1213.     return pccardDosDevCreate( sock, pCard->pBlkDev,
  1214. TFFS_CACHE_SIZE, USE_PARTITIONS );
  1215. #else
  1216.     printErr ("DosFs not included, card in socket %d ignoredn", sock);
  1217. #endif /* INCLUDE_DOSFS */
  1218.     return (OK);
  1219.     }
  1221. /*******************************************************************************
  1222. *
  1223. * pccardTffsCscIntr - PCMCIA flash card status change interrupt handler
  1224. *
  1225. * RETURNS: OK, or ERROR if the CSC event is Ready.
  1226. */
  1228. LOCAL STATUS pccardTffsCscIntr
  1229.     (
  1230.     int sock, /* socket no. */
  1231.     int csc /* CSC bits */
  1232.     )
  1234.     {
  1235.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  1236.     PCMCIA_CARD *pCard = &pCtrl->card[sock];
  1239.     /* hot insertion */
  1242.     /* hot removal */
  1244.     if ((csc & PC_DETECT) && ((pCard->cardStatus & PC_DETECT) == 0x0))
  1245. {
  1246. }
  1248.     /* card is ready */
  1250.     if (csc & PC_READY)
  1251. {
  1252. return (ERROR);
  1253. }
  1255.     /* other card status changes */
  1257.     if ((csc & PC_WRPROT) && (_func_logMsg != NULL))
  1258. (* _func_logMsg) ("TFFS: socket=%d Write protectn",
  1259.   sock, 0, 0, 0, 0, 0);
  1261.     return (OK);
  1262.     }
  1263. #endif /* INCLUDE_TFFS */