ioman.c

基于STM32F107的UDP服务器程序

/*****************************************************************************/
/*                     libfat - General purpose FAT library                    *
*                      ----------------------------------                     *
*                                                                             *
* Filename : ioman.c                                                          *
* Description : The IO Manager receives all requests for sectors in a central *
*               allowing it to make smart decision regarding caching.         *
*               The IOMAN_NUMBUFFER parameter determines how many sectors     *
*               ioman can cache. ioman also supports overallocating and       *
*               backtracking sectors.                                         *
*                                                                             *
* This program is free software; you can redistribute it and/or               *
* modify it under the terms of the GNU General Public License                 *
* as published by the Free Software Foundation; version 2                     *
* of the License.                                                             *
                                                                              *
* This program is distributed in the hope that it will be useful,             *
* but WITHOUT ANY WARRANTY; without even the implied warranty of              *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               *
* GNU General Public License for more details.                                *
*                                                                             *
* As a special exception, if other files instantiate templates or             *
* use macros or inline functions from this file, or you compile this          *
* file and link it with other works to produce a work based on this file,     *
* this file does not by itself cause the resulting work to be covered         *
* by the GNU General Public License. However the source code for this         *
* file must still be made available in accordance with section (3) of         *
* the GNU General Public License.                                             *
*                                                                             *
* This exception does not invalidate any other reasons why a work based       *
* on this file might be covered by the GNU General Public License.            *
*                                                                             *
*                                                    (c)2006 Lennart Yseboodt *
*                                                    (c)2006 Michael De Nil   */
/*****************************************************************************/

/*****************************************************************************/
#include "ioman.h"
/*****************************************************************************/

esint8 ioman_init(IOManager *ioman, hwInterface *iface, euint8* bufferarea)
{
	ioman->iface=iface;
	
	ioman->bufptr = ioman_getBuffer(ioman,bufferarea);
	ioman->numbuf = IOMAN_NUMBUFFER;
	ioman->numit  = IOMAN_NUMITERATIONS;
	
	ioman_reset(ioman);
	return(0);
}
/*****************************************************************************/

void ioman_reset(IOManager *ioman)
{
	euint16 nb,ni;
	
	memClr(ioman->sector,sizeof(euint32)*ioman->numbuf);
	memClr(ioman->status,sizeof(euint8) *ioman->numbuf);
	memClr(ioman->usage ,sizeof(euint8) *ioman->numbuf);
	memClr(ioman->itptr ,sizeof(euint8) *ioman->numbuf);
	ioman_setError(ioman,IOMAN_NOERROR);
		
	for(nb=0;nb<ioman->numbuf;nb++){
		for(ni=0;ni<ioman->numit;ni++){
			ioman->stack[nb][ni].sector=0;
			ioman->stack[nb][ni].status=0;
			ioman->stack[nb][ni].usage =0;
		}
	}
}
/*****************************************************************************/

euint8* ioman_getBuffer(IOManager *ioman,euint8* bufferarea)
{
#ifdef IOMAN_DO_MEMALLOC
	return(ioman->cache_mem);
#else
	return(bufferarea);
#endif
}
/*****************************************************************************/

void ioman_setAttr(IOManager *ioman,euint16 bufplace,euint8 attribute,euint8 val)
{
	if(bufplace>=ioman->numbuf){
		ioman_setError(ioman,IOMAN_ERR_SETATTROUTOFBOUNDS);
		return; /* Out of bounds */
	}
	
	if(val){
		ioman->status[bufplace]|=1<<attribute;
	}else{
		ioman->status[bufplace]&=~(1<<attribute);
	}
}
/*****************************************************************************/

euint8 ioman_getAttr(IOManager *ioman,euint16 bufplace,euint8 attribute)
{
	if(bufplace>=ioman->numbuf){
		ioman_setError(ioman,IOMAN_ERR_GETATTROUTOFBOUNDS);
		return(0xFF); /* Out of bounds */
	}

	return(ioman->status[bufplace]&(1<<attribute));
}
/*****************************************************************************/

euint8 ioman_getUseCnt(IOManager *ioman,euint16 bufplace)
{
	if(bufplace>=ioman->numbuf){
		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
		return(0x00);
	}
	return(ioman->usage[bufplace]);
}
/*****************************************************************************/


void ioman_incUseCnt(IOManager *ioman,euint16 bufplace)
{
	if(bufplace>=ioman->numbuf){
		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
		return;
	}
	if(ioman->usage[bufplace]==0xFF)return;
	else ioman->usage[bufplace]++;
}
/*****************************************************************************/

void ioman_decUseCnt(IOManager *ioman,euint16 bufplace)
{
	if(bufplace>=ioman->numbuf){
		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
		return;
	}
	if(ioman->usage[bufplace]==0x0)return;
	else ioman->usage[bufplace]--;
}
/*****************************************************************************/

void ioman_resetUseCnt(IOManager *ioman,euint16 bufplace)
{
	if(bufplace>=ioman->numbuf){
		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
		return;
	}
	ioman->usage[bufplace]=0x00;
}
/*****************************************************************************/

euint8 ioman_getRefCnt(IOManager *ioman,euint16 bufplace)
{
	if(bufplace>=ioman->numbuf){
		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
		return(0x00);
	}
	return(ioman->reference[bufplace]);
}
/*****************************************************************************/

void ioman_incRefCnt(IOManager *ioman,euint16 bufplace)
{
	if(bufplace>=ioman->numbuf){
		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
		return;
	}
	if(ioman->reference[bufplace]==0xFF)return;
	else ioman->reference[bufplace]++;
}
/*****************************************************************************/

void ioman_decRefCnt(IOManager *ioman,euint16 bufplace)
{
	if(bufplace>=ioman->numbuf){
		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
		return;
	}
	if(ioman->reference[bufplace]==0x00)return;
	else ioman->reference[bufplace]--;
}
/*****************************************************************************/

void ioman_resetRefCnt(IOManager *ioman,euint16 bufplace)
{
	if(bufplace>=ioman->numbuf){
		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
		return;
	}
	ioman->reference[bufplace]=0x00;
}
/*****************************************************************************/

esint8 ioman_pop(IOManager *ioman,euint16 bufplace)
{
	if(bufplace>=ioman->numbuf){
		ioman_setError(ioman,IOMAN_ERR_POPEMPTYSTACK);
		return(-1);
	}
	if(ioman->itptr[bufplace]==0 || ioman->itptr[bufplace]>IOMAN_NUMITERATIONS)return(-1);
	ioman->sector[bufplace] = ioman->stack[bufplace][ioman->itptr[bufplace]].sector;
	ioman->status[bufplace] = ioman->stack[bufplace][ioman->itptr[bufplace]].status;
	ioman->usage[bufplace]  = ioman->stack[bufplace][ioman->itptr[bufplace]].usage; 
	ioman->itptr[bufplace]--;
	return(0);
}
/*****************************************************************************/

esint8 ioman_push(IOManager *ioman,euint16 bufplace)
{
	if(bufplace>=ioman->numbuf){
		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
		return(-1);
	}
	if(ioman->itptr[bufplace]>=IOMAN_NUMITERATIONS){
		ioman_setError(ioman,IOMAN_ERR_PUSHBEYONDSTACK);	
		return(-1);
	}
	ioman->itptr[bufplace]++;
	ioman->stack[bufplace][ioman->itptr[bufplace]].sector = ioman->sector[bufplace];
	ioman->stack[bufplace][ioman->itptr[bufplace]].status = ioman->status[bufplace];
	ioman->stack[bufplace][ioman->itptr[bufplace]].usage  = ioman->usage[bufplace];
	return(0);
}
/*****************************************************************************/

euint8* ioman_getPtr(IOManager *ioman,euint16 bufplace)
{
	if(bufplace>=ioman->numbuf){
		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
		return(0);
	}
	return(ioman->bufptr+bufplace*512);
}
/*****************************************************************************/

esint16 ioman_getBp(IOManager *ioman,euint8* buf)
{
	if(buf<(ioman->bufptr) || buf>=( ioman->bufptr+(ioman->numbuf*512) )){
		ioman_setError(ioman,IOMAN_ERR_CACHEPTROUTOFRANGE);
		return(-1);
	}
	return((buf-(ioman->bufptr))/512);
}
/*****************************************************************************/

esint8 ioman_readSector(IOManager *ioman,euint32 address,euint8* buf)
{
	esint8 r;

	if(buf==0){
		return(-1);
	}
	
	r=if_readBuf(ioman->iface,address,buf);
	
	if(r!=0){
		ioman_setError(ioman,IOMAN_ERR_READFAIL);
		return(-1);
	}
	return(0);
}
/*****************************************************************************/

esint8 ioman_writeSector(IOManager *ioman, euint32 address, euint8* buf)
{
	esint8 r;

	if(buf==0)return(-1);
	
	r=if_writeBuf(ioman->iface,address,buf);

	if(r<=0){
		ioman_setError(ioman,IOMAN_ERR_WRITEFAIL);
		return(-1);
	}
	return(0);
}
/*****************************************************************************/

void ioman_resetCacheItem(IOManager *ioman,euint16 bufplace)
{
	if(bufplace>=ioman->numbuf){
		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
		return;
	}
	ioman->sector[bufplace]    = 0;
	ioman->status[bufplace]    = 0;
	ioman->usage[bufplace]     = 0;
	ioman->reference[bufplace] = 0;
}
/*****************************************************************************/

esint32 ioman_findSectorInCache(IOManager *ioman, euint32 address)
{
	euint16 c;