pccardlib.c

VXWORKS源代码

    	}

    /* resize cache and RESET device */
    dcacheDevMemResize (sockCbioDevs[ sock ], cacheSize);

    stat = cbioIoctl (sockCbioDevs[ sock ], CBIO_RESET, pBlkDev );

    if( stat != OK )
	{
	printErr("pccardDosDevCreate: error substituting block driver, "
		"errno=%#x\n", errno);
	}

    return stat;
    } /* pccardDosDevCreate() */
#endif /* INCLUDE_DOSFS */

#ifdef	INCLUDE_ATA
/*******************************************************************************
*
* pccardAtaEnabler - enable the PCMCIA-ATA device
*
* This routine enables the PCMCIA-ATA device.
*
* RETURNS:
* OK, ERROR_FIND if there is no ATA card, or ERROR if another error occurs.
*/
STATUS pccardAtaEnabler
    (
    int		 sock,		/* socket no. */
    ATA_RESOURCE *pAtaResource,	/* pointer to ATA resources */
    int		 numEnt,	/* number of ATA resource entries */
    FUNCPTR	 showRtn 	/* ATA show routine */
    )

    {
    PCMCIA_CTRL *pCtrl		= &pcmciaCtrl;
    PCMCIA_CHIP *pChip		= &pCtrl->chip;
    PCMCIA_CARD *pCard		= &pCtrl->card[sock];
    CIS_CONFIG  *pConfig	= (CIS_CONFIG *)&pCard->cisConfigList;
    PCCARD_RESOURCE *pResource	= &pAtaResource->resource;
    int drive			= 0;
    int functionCode		= 0;
    int diskInterface		= 0;
    PCMCIA_IOWIN pcmciaIowin;
    DL_LIST *pList;
    DL_NODE *pNode;
    CIS_TUPLE *pTuple;
    ATA_CTRL *pAtaCtrl;
    int flag;
    int ctrl;
    int sock0;
    char *pChar;

    if (!pChip->installed)
	return (ERROR);

    pList = &pCard->cisTupleList;
    for (pNode = DLL_FIRST (pList); pNode != NULL; pNode = DLL_NEXT(pNode))
	{
	pTuple	= (CIS_TUPLE *)((char *)pNode + sizeof (DL_NODE));
	pChar	= (char *)pTuple + sizeof (CIS_TUPLE);

	switch (pTuple->code)
	    {
	    case CISTPL_FUNCID:
		functionCode = *pChar;
		break;

	    case CISTPL_FUNCE:
		if (*pChar++ == FUNCE_TYPE_DISK)
		    diskInterface = *pChar;
		break;
	    }
	}

    if ((pcmciaDebug) && (_func_logMsg != NULL))
	(* _func_logMsg) ("ATA sock=%d functionCode=%x diskInterface=%x\n",
			      sock, functionCode, diskInterface, 0, 0, 0);
    /* return if we didn't recognize the card */

    if ((functionCode != FUNC_FIXEDDISK) || (diskInterface != FUNCE_DATA_ATA))
	return (ERROR_FIND);

    if ((pcmciaDebug) && (_func_logMsg != NULL))
	(* _func_logMsg) ("ATA sock=%d detected\n",
			      sock, 0, 0, 0, 0, 0);
    /* get un-used resource */

    for (ctrl = 0; ctrl < numEnt; ctrl++)
	{
        pResource = &pAtaResource->resource;

	if (pAtaResource->ctrlType == ATA_PCMCIA)
	    {
	    for (sock0 = 0; sock0 < pChip->socks; sock0++)
		{
    		PCMCIA_CARD *pCard0 = &pCtrl->card[sock0];
		if (pCard0->pResource == pResource)	/* used resource */
		    break;
		}
	    if (sock0 == pChip->socks)			/* un-used resource */
		break;
	    }

	pAtaResource++;
	}

    if (ctrl == numEnt)
	{
	if (_func_logMsg != NULL)
	    (* _func_logMsg) ("pccardAtaEnabler: sock=%d out of resource\n",
			      sock, 0, 0, 0, 0, 0);
	return (ERROR);
	}

    /* configure the card with the resource */

    pList = &pCard->cisConfigList;
    for (pNode = DLL_FIRST(pList); pNode != NULL; pNode = DLL_NEXT(pNode))
	{
	pConfig = (CIS_CONFIG *)pNode;

	if ((pConfig->ioRanges == 2) &&
	    (pConfig->io[0].start == pResource->ioStart[0]) &&
	    (pConfig->io[1].start == pResource->ioStart[1]))
	    {
	    pAtaCtrl		= &ataCtrl[ctrl];
	    pAtaCtrl->ctrlType	= ATA_PCMCIA;

	    pCard->type		= PCCARD_ATA;
	    pCard->sock		= sock;
	    pCard->ctrl		= ctrl;
	    pCard->detected	= TRUE;
	    pCard->pResource	= pResource;
            pCard->cardStatus	= (* pChip->status)(sock);
	    pCard->cscIntr	= (FUNCPTR)pccardAtaCscIntr;
	    pCard->showRtn	= (FUNCPTR)showRtn;

	    flag = PC_PWR_AUTO | PC_IOCARD;
	    if (pResource->vcc == PCCARD_5V)
	        flag |= PC_VCC_5V;
	    else if (pResource->vcc == PCCARD_3V)
	        flag |= PC_VCC_3V;
	    if (pResource->vpp == PCCARD_5V)
	        flag |= PC_VPP_5V;
	    else if (pResource->vpp == PCCARD_12V)
	        flag |= PC_VPP_12V;
	    if ((* pChip->flagSet)(sock, flag) != OK)
	        return (ERROR);

	    cisConfigregSet (sock, CONFIG_STATUS_REG, 0x00);
	    cisConfigregSet (sock, PIN_REPLACEMENT_REG,
			     PRR_RBVD1 | PRR_RBVD2 | PRR_RRDY | PRR_RWPROT);
	    cisConfigregSet (sock, SOCKET_COPY_REG, 0x00 | (sock & 0x0f));
	    cisConfigregSet (sock, CONFIG_OPTION_REG,
			     COR_LEVIREQ | pConfig->index);

	    pcmciaIowin.window	= PCCARD_IOWIN0;
	    pcmciaIowin.flags	= MAP_ACTIVE | MAP_16BIT;
	    pcmciaIowin.extraws	= pResource->ioExtraws;
	    pcmciaIowin.start	= pResource->ioStart[0];
	    pcmciaIowin.stop	= pResource->ioStop[0];
	    if ((* pChip->iowinSet)(sock, &pcmciaIowin) != OK)
	        return (ERROR);

	    pcmciaIowin.window	= PCCARD_IOWIN1;
	    pcmciaIowin.flags	= MAP_ACTIVE | MAP_16BIT;
	    pcmciaIowin.extraws	= pResource->ioExtraws;
	    pcmciaIowin.start	= pResource->ioStart[1];
	    pcmciaIowin.stop	= pResource->ioStop[1];
	    if ((* pChip->iowinSet)(sock, &pcmciaIowin) != OK)
	        return (ERROR);

	    if ((* pChip->irqSet)(sock, pAtaResource->intLevel) != OK)
	        return (ERROR);

	    if ((pCard->initStatus = ataDrv (ctrl,
					     pAtaResource->drives,
					     pAtaResource->intVector,
					     pAtaResource->intLevel,
					     pAtaResource->configType,
					     pAtaResource->semTimeout,
					     pAtaResource->wdgTimeout
					     )) != OK)
		{
    		if (_func_logMsg != NULL)
			(* _func_logMsg) ("ATA sock=%d ataDrv failed %x\n",
			      sock, errno, 0, 0, 0, 0);
	        return (ERROR);
		}

	    pCard->installed = TRUE;
    	    taskDelay (sysClkRateGet());		/* 1 sec */
	    break;
	    }
	}

    /* return if we didn't install the driver */

    if (!pCard->installed)
	return (ERROR);

    if (pCard->pBlkDev != NULL)
	free ((char *)pCard->pBlkDev);

    if ((pCard->pBlkDev = ataDevCreate(ctrl, drive, 0, 0)) ==
	(BLK_DEV *)NULL)
        {
        printErr ("Error during ataDevCreate: %x\n", errno);
	return (ERROR);
        }

#ifdef INCLUDE_DOSFS
    {
    return pccardDosDevCreate( sock, pCard->pBlkDev,
	ATA_CACHE_SIZE, USE_PARTITIONS );
    }
#else
    printErr ("DosFs not included, card in socket %d ignored\n", sock);

    return (OK);
#endif /* INCLUDE_DOSFS */
    }

/*******************************************************************************
*
* pccardAtaCscIntr - ATA controller PCMCIA card status change interrupt handler.
*
* RETURNS: OK (always).
*/

LOCAL STATUS pccardAtaCscIntr
    (
    int sock,			/* socket no. */
    int csc			/* CSC bits */
    )

    {
    PCMCIA_CTRL *pCtrl		= &pcmciaCtrl;
    PCMCIA_CARD *pCard		= &pCtrl->card[sock];
    ATA_RESOURCE *pAtaResource	= (ATA_RESOURCE *)pCard->pResource;
    ATA_CTRL *pAtaCtrl		= &ataCtrl[pCard->ctrl];


    /* hot insertion */


    /* hot removal */

    if ((csc & PC_DETECT) && ((pCard->cardStatus & PC_DETECT) == 0x0))
	{
        if (pAtaResource != NULL)
            sysIntDisablePIC (pAtaResource->intLevel);

	pAtaCtrl->installed	= FALSE;
	pAtaCtrl->changed	= FALSE;

	semFlush (&pAtaCtrl->syncSem);
	pcmciaJobAdd ((VOIDFUNCPTR)semTerminate, (int)&pAtaCtrl->muteSem,
		      0,0,0,0,0);
	}

    return (OK);
    }
#endif	/* INCLUDE_ATA */

#ifdef	INCLUDE_SRAM
/*******************************************************************************
*
* pccardSramEnabler - enable the PCMCIA-SRAM driver
*
* This routine enables the PCMCIA-SRAM driver.
*
* RETURNS:
* OK, ERROR_FIND if there is no SRAM card, or ERROR if another error occurs.
*/

STATUS pccardSramEnabler
    (
    int		  sock,		  /* socket no. */
    SRAM_RESOURCE *pSramResource, /* pointer to SRAM resources */
    int		  numEnt,	  /* number of SRAM resource entries */
    FUNCPTR	  showRtn 	  /* SRAM show routine */
    )

    {
    PCMCIA_CTRL *pCtrl		= &pcmciaCtrl;
    PCMCIA_CHIP *pChip		= &pCtrl->chip;
    PCMCIA_CARD *pCard		= &pCtrl->card[sock];
    BOOL typeExtended		= FALSE;
    BOOL speedExtended		= FALSE;
    int formatOffset		= 0;
    int formatNbytes		= 0;
    int deviceType		= 0;
    int deviceSize		= 0;
    int functionCode		= NONE;
    PCCARD_RESOURCE *pResource;
    DL_NODE *pNode;
    CIS_TUPLE *pTuple;
    CIS_BYTE4 offset;
    CIS_BYTE4 nbytes;
    int unit;
    int size;
    int flag;
    char *pChar;

    if ((!pChip->installed) || (sock >= numEnt))
	return (ERROR);

    for (pNode = DLL_FIRST (&pCard->cisTupleList);
	 pNode != NULL;
	 pNode = DLL_NEXT(pNode))
	{
	pTuple	= (CIS_TUPLE *)((char *)pNode + sizeof (DL_NODE));
	pChar	= (char *)pTuple + sizeof (CIS_TUPLE);

	switch (pTuple->code)
	    {
	    case CISTPL_FUNCID:
		functionCode = *pChar;
		break;

	    case CISTPL_DEVICE:
		deviceType = *pChar & 0xf0;
		if (deviceType == DTYPE_EXTEND)
		    typeExtended = TRUE;
		if ((*pChar & 0x0f) == DSPEED_EXT)
		    speedExtended = TRUE;
		pChar++;
		while (speedExtended)
		    if ((*pChar++ & 0x80) == 0)
			speedExtended = FALSE;
		while (typeExtended)
		    if ((*pChar++ & 0x80) == 0)
			typeExtended = FALSE;
		unit = ((*pChar & 0xf8) >> 3) + 1;
		size = sramSizeTable [*pChar & 0x07];
		deviceSize = unit * size;
		break;

	    case CISTPL_FORMAT:
		pChar += 2;
		offset.c[0] = *pChar++;
		offset.c[1] = *pChar++;
		offset.c[2] = *pChar++;
		offset.c[3] = *pChar++;
		nbytes.c[0] = *pChar++;
		nbytes.c[1] = *pChar++;
		nbytes.c[2] = *pChar++;
		nbytes.c[3] = *pChar++;
		formatOffset = offset.l;
		formatNbytes = nbytes.l;
		break;
	    }
	}

    /* configure the card with a resource which is assigned for the socket */

    if (((functionCode == NONE) || (functionCode == FUNC_MEMORY)) &&
        ((deviceType == DTYPE_SRAM) || (formatNbytes != 0)))
	{
        sramResourceNumEnt	= numEnt;
        pSramResource		+= sock;
        pResource		= &pSramResource->resource;
        pCard->type		= PCCARD_SRAM;
        pCard->sock		= sock;
        pCard->detected		= TRUE;
        pCard->pResource	= pResource;
        pCard->cardStatus	= (* pChip->status)(sock);
        pCard->cscIntr		= (FUNCPTR)pccardSramCscIntr;
        pCard->showRtn		= (FUNCPTR)showRtn;
        pResource->memStart	&= 0xfffff000;
        pResource->memStop	|= 0x00000fff;
        pResource->memOffset	= formatOffset;
        if (deviceSize != 0)
	    pResource->memLength = deviceSize;
        else if (formatNbytes != 0)
	    pResource->memLength = formatNbytes;
	else
	    return (ERROR);

        flag = PC_PWR_AUTO;
        if (pResource->vcc == PCCARD_5V)
	    flag |= PC_VCC_5V;
        else if (pResource->vcc == PCCARD_3V)
	    flag |= PC_VCC_3V;
        if (pResource->vpp == PCCARD_5V)
	    flag |= PC_VPP_5V;
        else if (pResource->vpp == PCCARD_12V)
	    flag |= PC_VPP_12V;
        if ((* pChip->flagSet)(sock, flag) != OK)
	    return (ERROR);

        if ((pCard->initStatus = sramDrv (sock)) != OK)
	    return (ERROR);

        pCard->installed = TRUE;
	}
    else
	return (ERROR_FIND);

    /* return if we didn't recognize the card or didn't install the driver */

    if (!pCard->installed)
	return (ERROR);

    if (pCard->pBlkDev != NULL)
	free ((char *)pCard->pBlkDev);

    size = pResource->memLength / DEFAULT_SEC_SIZE - 1;	/* number of blocks */
    pCard->pBlkDev = sramDevCreate (sock, DEFAULT_SEC_SIZE, size, size, 0);
    if (pCard->pBlkDev == (BLK_DEV *)NULL)
	{
	printErr ("Error during sramDevCreate: %x\n", errno);
	return (ERROR);
	}

#ifdef INCLUDE_DOSFS
    /*
     * init DOS device with new block device driver and
     * valid disk cache size