openwrt/upstream - upstream openwrt

diff options

author	Daniel Dickinson <crazycshore@gmail.com>	2010-11-16 06:46:53 +0000
committer	Daniel Dickinson <crazycshore@gmail.com>	2010-11-16 06:46:53 +0000
commit	eadb5c84fa7b7b4b90320e554634ddd59e445bd8 (patch)
tree	73ac22eb6ad4099837035196c44e7777cf72397d /tools/firmware-utils/Makefile
parent	e8d482ab00b435a262b956e7bc33597376364066 (diff)
download	upstream-eadb5c84fa7b7b4b90320e554634ddd59e445bd8.tar.gz upstream-eadb5c84fa7b7b4b90320e554634ddd59e445bd8.tar.bz2 upstream-eadb5c84fa7b7b4b90320e554634ddd59e445bd8.zip

imagetag: Significantly updated brcm63xx imagetag writing tool. * Rewrote commandline parsing code using gengetopt - We now get long options - We have more options including use of the info section for board information (e.g. to add the same boardid but different GPIOs on different routers) * Added back the ability to write stock images (this is useful, for example, when copying the firmware from the in-memory flash, and then being able to create an image that will let you revert to/test stock firmware * Fixed copying of CRCs to use memcpy instead of strncpy (strncpy stops at 0) * Added ability to use all sections of the imagetag, including custom magic signatures (e.g. for the Telsey router I'm adding soon), info sections, and reserved sections * Added putting the router type (as defined in the image generating Makefile) into the info1 section and the filesystem type in the info2 section. This will be used by mtd (when I add the code) to return the name of image used to flash this router. (As requested by Jo, as well as being useful for same boardid different board scenario described above).

SVN-Revision: 24011

Diffstat (limited to 'tools/firmware-utils/Makefile')

-rw-r--r--

tools/firmware-utils/Makefile

1 files changed, 1 insertions, 2 deletions

/**CFile**************************************************************** FileName [abcSop.c] SystemName [ABC: Logic synthesis and verification system.] PackageName [Network and node package.] Synopsis [Implementation of a simple SOP representation of nodes.] Author [Alan Mishchenko] Affiliation [UC Berkeley] Date [Ver. 1.0. Started - June 20, 2005.] Revision [$Id: abcSop.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] ***********************************************************************/ #include "abc.h" /* The SOPs in this package are represented using char * strings. For example, the SOP of the node: .names c d0 d1 MUX 01- 1 1-1 1 is the string: "01- 1\n1-1 1\n" where '\n' is a single char. */ //////////////////////////////////////////////////////////////////////// /// DECLARATIONS /// //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// //////////////////////////////////////////////////////////////////////// /**Function************************************************************* Synopsis [Registers the cube string with the network.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopRegister( Extra_MmFlex_t * pMan, char * pName ) { char * pRegName; if ( pName == NULL ) return NULL; pRegName = Extra_MmFlexEntryFetch( pMan, strlen(pName) + 1 ); strcpy( pRegName, pName ); return pRegName; } /**Function************************************************************* Synopsis [Creates the constant 1 cover with the given number of variables and cubes.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopStart( Extra_MmFlex_t * pMan, int nCubes, int nVars ) { char * pSopCover, * pCube; int i, Length; Length = nCubes * (nVars + 3); pSopCover = Extra_MmFlexEntryFetch( pMan, Length + 1 ); memset( pSopCover, '-', Length ); pSopCover[Length] = 0; for ( i = 0; i < nCubes; i++ ) { pCube = pSopCover + i * (nVars + 3); pCube[nVars + 0] = ' '; pCube[nVars + 1] = '1'; pCube[nVars + 2] = '\n'; } return pSopCover; } /**Function************************************************************* Synopsis [Creates the constant 1 cover with 0 variables.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopCreateConst1( Extra_MmFlex_t * pMan ) { return Abc_SopRegister( pMan, " 1\n" ); } /**Function************************************************************* Synopsis [Creates the constant 1 cover with 0 variables.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopCreateConst0( Extra_MmFlex_t * pMan ) { return Abc_SopRegister( pMan, " 0\n" ); } /**Function************************************************************* Synopsis [Creates the AND2 cover.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopCreateAnd2( Extra_MmFlex_t * pMan, int fCompl0, int fCompl1 ) { char Buffer[6]; Buffer[0] = '1' - fCompl0; Buffer[1] = '1' - fCompl1; Buffer[2] = ' '; Buffer[3] = '1'; Buffer[4] = '\n'; Buffer[5] = 0; return Abc_SopRegister( pMan, Buffer ); } /**Function************************************************************* Synopsis [Creates the multi-input AND cover.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopCreateAnd( Extra_MmFlex_t * pMan, int nVars, int * pfCompl ) { char * pSop; int i; pSop = Abc_SopStart( pMan, 1, nVars ); for ( i = 0; i < nVars; i++ ) pSop[i] = '1' - (pfCompl? pfCompl[i] : 0); pSop[nVars + 1] = '1'; return pSop; } /**Function************************************************************* Synopsis [Creates the multi-input NAND cover.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopCreateNand( Extra_MmFlex_t * pMan, int nVars ) { char * pSop; int i; pSop = Abc_SopStart( pMan, 1, nVars ); for ( i = 0; i < nVars; i++ ) pSop[i] = '1'; pSop[nVars + 1] = '0'; return pSop; } /**Function************************************************************* Synopsis [Creates the multi-input OR cover.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopCreateOr( Extra_MmFlex_t * pMan, int nVars, int * pfCompl ) { char * pSop; int i; pSop = Abc_SopStart( pMan, 1, nVars ); for ( i = 0; i < nVars; i++ ) pSop[i] = '0' + (pfCompl? pfCompl[i] : 0); pSop[nVars + 1] = '0'; return pSop; } /**Function************************************************************* Synopsis [Creates the multi-input OR cover.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopCreateOrMultiCube( Extra_MmFlex_t * pMan, int nVars, int * pfCompl ) { char * pSop, * pCube; int i; pSop = Abc_SopStart( pMan, nVars, nVars ); i = 0; Abc_SopForEachCube( pSop, nVars, pCube ) { pCube[i] = '1' - (pfCompl? pfCompl[i] : 0); i++; } return pSop; } /**Function************************************************************* Synopsis [Creates the multi-input NOR cover.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopCreateNor( Extra_MmFlex_t * pMan, int nVars ) { char * pSop; int i; pSop = Abc_SopStart( pMan, 1, nVars ); for ( i = 0; i < nVars; i++ ) pSop[i] = '0'; return pSop; } /**Function************************************************************* Synopsis [Creates the multi-input XOR cover.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopCreateXor( Extra_MmFlex_t * pMan, int nVars ) { assert( nVars == 2 ); return Abc_SopRegister(pMan, "01 1\n10 1\n"); } /**Function************************************************************* Synopsis [Creates the multi-input XOR cover (special case).] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopCreateXorSpecial( Extra_MmFlex_t * pMan, int nVars ) { char * pSop; pSop = Abc_SopCreateAnd( pMan, nVars, NULL ); pSop[nVars+1] = 'x'; assert( pSop[nVars+2] == '\n' ); return pSop; } /**Function************************************************************* Synopsis [Creates the multi-input XNOR cover.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopCreateNxor( Extra_MmFlex_t * pMan, int nVars ) { assert( nVars == 2 ); return Abc_SopRegister(pMan, "11 1\n00 1\n"); } /**Function************************************************************* Synopsis [Creates the MUX cover.] Description [The first input of MUX is the control. The second input is DATA1. The third input is DATA0.] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopCreateMux( Extra_MmFlex_t * pMan ) { return Abc_SopRegister(pMan, "11- 1\n0-1 1\n"); } /**Function************************************************************* Synopsis [Creates the inv cover.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopCreateInv( Extra_MmFlex_t * pMan ) { return Abc_SopRegister(pMan, "0 1\n"); } /**Function************************************************************* Synopsis [Creates the buf cover.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopCreateBuf( Extra_MmFlex_t * pMan ) { return Abc_SopRegister(pMan, "1 1\n"); } /**Function************************************************************* Synopsis [Creates the arbitrary cover from the truth table.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopCreateFromTruth( Extra_MmFlex_t * pMan, int nVars, unsigned * pTruth ) { char * pSop, * pCube; int nMints, Counter, i, k; // count the number of true minterms Counter = 0; nMints = (1 << nVars); for ( i = 0; i < nMints; i++ ) Counter += ((pTruth[i>>5] & (1 << (i&31))) > 0); // SOP is not well-defined if the truth table is constant 0 assert( Counter > 0 ); if ( Counter == 0 ) return NULL; // start the cover pSop = Abc_SopStart( pMan, Counter, nVars ); // create true minterms Counter = 0; for ( i = 0; i < nMints; i++ ) if ( (pTruth[i>>5] & (1 << (i&31))) > 0 ) { pCube = pSop + Counter * (nVars + 3); for ( k = 0; k < nVars; k++ ) pCube[k] = '0' + ((i & (1 << k)) > 0); Counter++; } return pSop; } /**Function************************************************************* Synopsis [Creates the cover from the ISOP computed from TT.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ char * Abc_SopCreateFromIsop( Extra_MmFlex_t * pMan, int nVars, Vec_Int_t * vCover ) { char * pSop, * pCube; int i, k, Entry, Literal; assert( Vec_IntSize(vCover) > 0 ); if ( Vec_IntSize(vCover) == 0 ) return NULL; // start the cover pSop = Abc_SopStart( pMan, Vec_IntSize(vCover), nVars ); // create cubes Vec_IntForEachEntry( vCover, Entry, i ) { pCube = pSop + i * (nVars + 3); for ( k = 0; k < nVars; k++ ) { Literal = 3 & (Entry >> (k << 1)); if ( Literal == 1 ) pCube[k] = '0'; else if ( Literal == 2 ) pCube[k] = '1'; else if ( Literal != 0 ) assert( 0 ); } } return pSop; } /**Function************************************************************* Synopsis [Creates the cover from the ISOP computed from TT.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Abc_SopToIsop( char * pSop, Vec_Int_t * vCover ) { char * pCube; int k, nVars, Entry; nVars = Abc_SopGetVarNum( pSop ); assert( nVars > 0 ); // create cubes Vec_IntClear( vCover ); for ( pCube = pSop; *pCube; pCube += nVars + 3 ) { Entry = 0; for ( k = nVars - 1; k >= 0; k-- ) if ( pCube[k] == '0' ) Entry = (Entry << 2) | 1; else if ( pCube[k] == '1' ) Entry = (Entry << 2) | 2; else if ( pCube[k] == '-' ) Entry = (Entry << 2); else assert( 0 ); Vec_IntPush( vCover, Entry ); } } /**Function************************************************************* Synopsis [Reads the number of cubes in the cover.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ int Abc_SopGetCubeNum( char * pSop ) { char * pCur; int nCubes = 0; if ( pSop == NULL ) return 0; for ( pCur = pSop; *pCur; pCur++ ) nCubes += (*pCur == '\n'); return nCubes; } /**Function************************************************************* Synopsis [Reads the number of SOP literals in the cover.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ int Abc_SopGetLitNum( char * pSop ) { char * pCur; int nLits = 0; if ( pSop == NULL ) return 0; for ( pCur = pSop; *pCur; pCur++ ) { nLits -= (*pCur == '\n'); nLits += (*pCur == '0' || *pCur == '1'); } return nLits; } /**Function************************************************************* Synopsis [Reads the number of variables in the cover.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ int Abc_SopGetVarNum( char * pSop ) { char * pCur; for ( pCur = pSop; *pCur != '\n'; pCur++ ); return pCur - pSop - 2; } /**Function************************************************************* Synopsis [Reads the phase of the cover.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ int Abc_SopGetPhase( char * pSop ) { int nVars = Abc_SopGetVarNum( pSop ); if ( pSop[nVars+1] == '0' || pSop[nVars+1] == 'n' ) return 0; if ( pSop[nVars+1] == '1' || pSop[nVars+1] == 'x' ) return 1; assert( 0 ); return -1; } /**Function************************************************************* Synopsis [Returns the i-th literal of the cover.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ int Abc_SopGetIthCareLit( char * pSop, int i ) { char * pCube; int nVars; nVars = Abc_SopGetVarNum( pSop ); Abc_SopForEachCube( pSop, nVars, pCube ) if ( pCube[i] != '-' ) return pCube[i] - '0'; return -1; } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Abc_SopComplement( char * pSop ) { char * pCur; for ( pCur = pSop; *pCur; pCur++ ) if ( *pCur == '\n' ) { if ( *(pCur - 1) == '0' ) *(pCur - 1) = '1'; else if ( *(pCur - 1) == '1' ) *(pCur - 1) = '0'; else if ( *(pCur - 1) == 'x' ) *(pCur - 1) = 'n'; else if ( *(pCur - 1) == 'n' ) *(pCur - 1) = 'x'; else assert( 0 ); } } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ bool Abc_SopIsComplement( char * pSop ) { char * pCur; for ( pCur = pSop; *pCur; pCur++ ) if ( *pCur == '\n' ) return (int)(*(pCur - 1) == '0' || *(pCur - 1) == 'n'); assert( 0 ); return 0; } /**Function*************************************************************


context:
space:
mode: