sramdrv.c

VXWORKS源代码

    PCMCIA_MEMWIN memwin;


    /* sanity check */

    if ((!pCard->installed) ||
        ((block_t)(startBlk + numBlks) > pSramDev->blkDev.bd_nBlocks) ||
	(offset >= (u_int)pResource->memLength))
	return (ERROR);

#ifdef	SRAM_DEBUG
    printf ("sramRead: startBlk=%d numBlks=%d p=0x%x\n",
	    startBlk, numBlks, pChar);	
#endif

    if (pCard->cardStatus & PC_BATDEAD)
	{
	(void) errnoSet (S_pcmciaLib_BATTERY_DEAD);
	return (ERROR);
	}

    if (pCard->cardStatus & PC_BATWARN)
	{
	(void) errnoSet (S_pcmciaLib_BATTERY_WARNING);
	return (ERROR);
	}

    if (pCard->cardStatus & PC_WRPROT)
        pSramDev->blkDev.bd_mode = O_RDONLY;

    /* Read the block(s) */

    if (semTake (muteSemID, WAIT_FOREVER) == ERROR)
	return (ERROR);

    while (copiedBytes < nbytes)
	{
	memwin.window	= SRAM_WINDOW;
	memwin.flags	= MAP_ACTIVE | MAP_16BIT;
	memwin.extraws	= pResource->memExtraws;
	memwin.start	= pResource->memStart;
	memwin.stop	= pResource->memStop;
	memwin.cardstart= offset & 0xfffff000;
	if ((* pChip->memwinSet)(pSramDev->sock, &memwin) != OK)
	    {
	    semGive (muteSemID);
	    return (ERROR);
	    }

	if (((* pChip->status)(pSramDev->sock) & PC_READY) == 0)
	    if (semTake(syncSemID, sysClkRateGet()) != OK)
		{
		semGive (muteSemID);
		return (ERROR);
		}

	length = min (nbytes - copiedBytes, (windowSize - (offset & 0xfff)));
	bcopy ((char *)memwin.start + (offset & 0xfff) + pCtrl->memBase,
	       pChar, length);

	offset		+= length;
	copiedBytes 	+= length;
	pChar 		+= length;
	}

    if ((* pChip->memwinSet)(pSramDev->sock, &sramMemwin) != OK)
	{
	semGive (muteSemID);
	return (ERROR);
	}

    semGive (muteSemID);
    return (OK);
    }

/*******************************************************************************
*
* sramWrite - write one or more blocks to a PCMCIA memory disk volume
*
* This routine writes one or more blocks to the specified volume,
* starting with the specified block number.  The byte offset is
* calculated and the buffer data is copied to the PCMCIA memory disk.
*
* If any block offset was specified during sramDevCreate(), it is added
* to <startBlk> before the transfer takes place.
*
* RETURNS: OK, or ERROR if mapping or write fails.
*/

LOCAL STATUS sramWrite
    (
    SRAM_DEV *pSramDev,		/* pointer to device desriptor */
    int	     startBlk,		/* starting block number to write */
    int	     numBlks,		/* number of blocks to write */
    char     *pChar 		/* pointer to buffer of data to write */
    )
    {
    PCMCIA_CTRL *pCtrl		= &pcmciaCtrl;
    PCMCIA_CHIP *pChip		= &pCtrl->chip;
    PCMCIA_CARD *pCard		= &pCtrl->card[pSramDev->sock];
    SRAM_RESOURCE *pSram	= &sramResources[pSramDev->sock];
    PCCARD_RESOURCE *pResource	= &pSram->resource;
    SEM_ID muteSemID		= &sramCtrl.muteSem[pSramDev->sock];
    SEM_ID syncSemID		= &sramCtrl.syncSem[pSramDev->sock];
    u_int bytesPerBlk		= pSramDev->blkDev.bd_bytesPerBlk;
    u_int windowSize		= pResource->memStop - pResource->memStart + 1;
    u_int nbytes		= bytesPerBlk * numBlks;
    u_int offset		= (u_int)pResource->memOffset + 
				  ((startBlk + pSramDev->blkOffset) *
				  bytesPerBlk);
    u_int copiedBytes		= 0;
    u_int length;
    PCMCIA_MEMWIN memwin;


    /* sanity check */

    if ((!pCard->installed) ||
        ((block_t)(startBlk + numBlks) > pSramDev->blkDev.bd_nBlocks) ||
	(offset >= (u_int)pResource->memLength))
	return (ERROR);

#ifdef	SRAM_DEBUG
    printf ("sramWrite: startBlk=%d numBlks=%d p=0x%x\n",
	    startBlk, numBlks, pChar);	
#endif

    if (pCard->cardStatus & PC_BATDEAD)
	{
	(void) errnoSet (S_pcmciaLib_BATTERY_DEAD);
	return (ERROR);
	}

    if (pCard->cardStatus & PC_BATWARN)
	{
	(void) errnoSet (S_pcmciaLib_BATTERY_WARNING);
	return (ERROR);
	}

    if (pCard->cardStatus & PC_WRPROT)
	{
	(void) errnoSet (S_ioLib_WRITE_PROTECTED);
        pSramDev->blkDev.bd_mode = O_RDONLY;
	return (ERROR);
	}

    /* Write the block(s) */

    if (semTake (muteSemID, WAIT_FOREVER) == ERROR)
	return (ERROR);

    while (copiedBytes < nbytes)
	{
	memwin.window	= SRAM_WINDOW;
	memwin.flags	= MAP_ACTIVE | MAP_16BIT;
	memwin.extraws	= pResource->memExtraws;
	memwin.start	= pResource->memStart;
	memwin.stop	= pResource->memStop;
	memwin.cardstart= offset & 0xfffff000;
	if ((* pChip->memwinSet)(pSramDev->sock, &memwin) != OK)
	    {
	    semGive (muteSemID);
	    return (ERROR);
	    }

	if (((* pChip->status)(pSramDev->sock) & PC_READY) == 0)
	    if (semTake(syncSemID, sysClkRateGet()) != OK)
		{
		semGive (muteSemID);
		return (ERROR);
		}

	length = min (nbytes - copiedBytes, (windowSize - (offset & 0xfff)));
	bcopy (pChar, (char *)memwin.start + (offset & 0xfff) + pCtrl->memBase,
	       length);

	offset		+= length;
	copiedBytes 	+= length;
	pChar 		+= length;
	}

    if ((* pChip->memwinSet)(pSramDev->sock, &sramMemwin) != OK)
	{
	semGive (muteSemID);
	return (ERROR);
	}

    semGive (muteSemID);
    return (OK);
    }

/*******************************************************************************
*
* sramIoctl - do device specific control function
*
* This routine is called when the file system cannot handle an ioctl()
* function.
*
* The FIODISKFORMAT function always returns OK, since a PCMCIA memory disk does
* not require formatting.  All other requests return ERROR.
*
* RETURNS:  OK, or ERROR if there is an error.
*
* ARGSUSED1
*/

LOCAL STATUS sramIoctl
    (
    SRAM_DEV *pSramDev,		/* device structure pointer */
    int	     function,		/* function code */
    int	     arg 		/* some argument */
    )

    {
    PCMCIA_CTRL *pCtrl		= &pcmciaCtrl;
    PCMCIA_CARD *pCard		= &pCtrl->card[pSramDev->sock];
    int	status;			/* returned status value */


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

#ifdef	SRAM_DEBUG
    printf ("sramIoctl: function=0x%x arg=0x%x\n", function, arg);	
#endif

    switch (function)
	{
	case FIODISKFORMAT:
	    status = OK;
	    break;

	default:
	    errnoSet (S_ioLib_UNKNOWN_REQUEST);
	    status = ERROR;
	}

    return (status);
    }

/*******************************************************************************
*
* sramStatusChk - check the status
*
* This routine is called by the file system to check the status.
*
* RETURNS:  OK, or ERROR if there is an error.
*
*/

LOCAL STATUS sramStatusChk
    (
    SRAM_DEV *pSramDev		/* device structure pointer */
    )

    {
    PCMCIA_CTRL *pCtrl		= &pcmciaCtrl;
    PCMCIA_CHIP *pChip		= &pCtrl->chip;
    PCMCIA_CARD *pCard		= &pCtrl->card[pSramDev->sock];
    SEM_ID muteSemID		= &sramCtrl.muteSem[pSramDev->sock];
    BLK_DEV *pBlkDev		= &pSramDev->blkDev;


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

#ifdef	SRAM_DEBUG
    printf ("sramStatusChk: \n");	
#endif

    if (pCard->changed)
	{
	pBlkDev->bd_readyChanged = TRUE;
	pCard->changed		 = FALSE;
	}

    if (semTake (muteSemID, WAIT_FOREVER) == ERROR)
	return (ERROR);

    pCard->cardStatus = (* pChip->status) (pSramDev->sock);

    semGive (muteSemID);

    if (pCard->cardStatus & PC_BATDEAD)
	{
	(void) errnoSet (S_pcmciaLib_BATTERY_DEAD);
	return (ERROR);
	}

    if (pCard->cardStatus & PC_BATWARN)
	{
	(void) errnoSet (S_pcmciaLib_BATTERY_WARNING);
	return (ERROR);
	}

    if (pCard->cardStatus & PC_WRPROT)
        pBlkDev->bd_mode     = O_RDONLY;
    else
        pBlkDev->bd_mode     = O_RDWR;

    return (OK);
    }