Sat Dec 9 13:05:52 PST 2006

Update of /cvsroot/tinyos/tinyos-1.x/contrib/umass/tos/interfaces
In directory sc8-pr-cvs10.sourceforge.net:/tmp/cvs-serv17795/tos/interfaces

Added Files:
	Array.nc Checkpoint.nc ChunkStorage.nc Compaction.nc 
	Console.nc Crc8.nc File.nc FileSystem.nc GenericFlash.nc 
	Index.nc PageNAND.nc Queue.nc RootDirectory.nc 
	RootPtrAccess.nc Serialize.nc SingleCompaction.nc 
	SingleStream.nc Stack.nc Stream.nc StreamExport.nc 
	StreamIndex.nc 
Log Message:
Added contrib/umass containing Capsule -- a storage system for sensors

--- NEW FILE: Array.nc ---
/*
 * The array storage object
 * Note: this storage object is used internally by the index
 */
includes app_header;

/* 
 * Note this array structure does not span multiple blocks - this assumes that the
 * entire array fits in one chunk.
 */
interface Array 
{
    command result_t load(flashptr_t *head_, bool first_write, bool ecc);
    event void loadDone(result_t res);

    command result_t save(flashptr_t *save_ptr);
    event void saveDone(result_t res);

    /* Set an array index */
    /* Note that save_ptr returns a pointer to the object only (no app level headers) */
    command result_t set(unsigned int arr_index, void *data, datalen_t len, 
                         flashptr_t *save_ptr);
    event void setDone(result_t res);

    /* Get an object from the flash */
    command result_t get(unsigned int arr_index, void *data, datalen_t *len);
    event void getDone(result_t res);

    command result_t delete(unsigned int arr_index);
}

--- NEW FILE: Checkpoint.nc ---
/*
 * The checkpointing component
 */
includes app_header;

interface Checkpoint 
{
    command result_t init(uint8_t id);

    command result_t checkpoint();

    command result_t rollback();

    event void checkpointDone(result_t result);

    event void rollbackDone(result_t result);
}

--- NEW FILE: ChunkStorage.nc ---

/*
 * file:        ChunkStorage.nc
 *
 */
includes chunk_header;
includes PageNAND;

interface ChunkStorage {
    /* Initialize NAND flash memory */
    
    /* 
     * Writes a record into Flash
     */
    command result_t write(void *data1, datalen_t len1,
                           void *data2, datalen_t len2, 
                           bool computeEcc, flashptr_t *save_ptr);
    event void writeDone(result_t res);

    /* 
     * Reads a page from flash
     */
    command result_t read(flashptr_t *ptr, 
                          void *data1, datalen_t len1, 
                          void *data2, datalen_t *len2, 
                          bool checkEcc, bool *ecc);
    event void readDone(result_t res);
    
    /* 
     * Flush current write buffer to flash
     */
    command result_t flush();
    event void flushDone(result_t res);

    command uint8_t percentagefull();

    /* NOTE : There is no erase supported on this interface */
}

--- NEW FILE: Compaction.nc ---
includes app_header;

interface Compaction
{
    command result_t compact(uint8_t agingHint);

    event void compactionDone(result_t res);
}

--- NEW FILE: Console.nc ---
interface Console {
    command result_t init();
    command void printf0(char *fmt);
    command void printf1(char *fmt, int16_t n);
    command void printf2(char *fmt, int16_t n1, int16_t n2);
    command void newline();
    command void string(char *fmt);
    command void decimal(int32_t n);
    event void input(char *str);
}

--- NEW FILE: Crc8.nc ---
/* 
 * 8 bit CRC
 */
interface Crc8
{
    command uint8_t crc8(uint8_t *ptr, uint16_t len, uint8_t crc_);
}

--- NEW FILE: File.nc ---

includes app_header;

interface File
{
    command result_t create(char *fileName);
    event void createDone(result_t res);

    command result_t delete(char *fileName);
    event void deleteDone(result_t res);

    command result_t move(char *fileName1, char *fileName2);

    command result_t open(char *fileName);
    event void openDone(result_t res);

    command result_t close();
    event void closeDone(result_t res);

    command result_t append(void *data, uint16_t length);
    event void appendDone(result_t res);

    command result_t readStart();
    command result_t readNext(void *data, uint16_t length, 
                              uint16_t *read_length);
    event void readDone(result_t res);

    command uint16_t length();

    command result_t flush();
    event void flushDone(result_t res);
}

--- NEW FILE: FileSystem.nc ---

includes app_header;

interface FileSystem
{
    //command result_t init();
    event void initDone(result_t res);

    command result_t lookup(char *fileName, fileptr_t *id);

    command result_t create(char *fileName);
    event void createDone(result_t res);

    command result_t delete(fileptr_t id);
    event void deleteDone(result_t res);

    command result_t move(fileptr_t id, char *fileName2);

    command uint16_t getLength(fileptr_t id);
    command result_t updateLength(fileptr_t id, uint16_t length);

    command result_t getFileData(fileptr_t id, file_header *ptr);
    command result_t updateFileData(fileptr_t id, file_header *ptr);
    event void updateFileDataDone(result_t res);

    command result_t flush();
    event void flushDone(result_t res);
}

--- NEW FILE: GenericFlash.nc ---

includes common_header;

interface GenericFlash 
{
    command result_t init();
    event result_t initDone(result_t r);

    command pageptr_t numPages();
    
    command result_t write(pageptr_t page, offsetptr_t offset,
                           void *data, datalen_t len);
    event result_t writeDone(result_t r);

    command result_t falRead(pageptr_t page, offsetptr_t offset,
                             void *header, 
                             void *app_buff, datalen_t app_len, 
                             void *data_buff);
    event result_t falReadDone(result_t r);

    command result_t read(pageptr_t page, offsetptr_t offset,
                          void *app_buff, datalen_t app_len);
    event result_t readDone(result_t r);

    command result_t erase(pageptr_t page);
    event result_t eraseDone(result_t result);
}

--- NEW FILE: Index.nc ---
/*
 * The array storage object
 */
includes app_header;

/* 
 * Note this array structure does not span multiple blocks - this assumes that the
 * entire array fits in one chunk.
 */
interface Index 
{
    command result_t load(bool ecc);
    event void loadDone(result_t res);

    command result_t save(flashptr_t *save_ptr);
    event void saveDone(result_t res);

    /* Set an array index */
    command result_t set(unsigned int arr_index, void *data, 
                         datalen_t len, flashptr_t *save_ptr);
    event void setDone(result_t res);

    /* Get an object from the flash */
    command result_t get(unsigned int arr_index, void *data, datalen_t *len);
    event void getDone(result_t res);

    command result_t delete(unsigned int arr_index);
	event void deleteDone(result_t res);
}

--- NEW FILE: PageNAND.nc ---

includes PageNAND;
interface PageNAND {
    command nandpage_t numPages();

    command result_t init();
    event result_t initDone(result_t r);
    
    command result_t write(nandpage_t page, nandoffset_t offset,
                           void *data, nandoffset_t len);
    event result_t writeDone(result_t r);

    command result_t read(nandpage_t page, nandoffset_t offset,
                          void *buffer, nandoffset_t len);
    event result_t readDone(result_t r);

    command result_t falRead(nandpage_t page, nandoffset_t offset,
                          void *header, void *app_buff, nandoffset_t len, void *data_buff);
    event result_t falReadDone(result_t r);


    command result_t erase(nandpage_t page);
    event result_t eraseDone(result_t result);

    command result_t generateECC(void *data, nandoffset_t len, uint8_t *ecc);
    command result_t checkECC(void *data, nandoffset_t len, uint8_t *ecc);
    command result_t id(uint8_t *id);
}

--- NEW FILE: Queue.nc ---
/*
 * The queue storage object
 */
includes app_header;

interface Queue 
{
    command result_t init(bool ecc);

    /* Push an object at the end */
    command result_t enqueue(void *data, datalen_t len, flashptr_t *save_ptr);

    event void enqueueDone(result_t res);

    /* Remove first object */
    command result_t dequeue(void *data, datalen_t *len);

    event void dequeueDone(result_t res);

    /* Retrieve front-most object, but do not remove it from the queue */
    command result_t front(void *data, datalen_t *len);

    event void frontDone(result_t res);
}

--- NEW FILE: RootDirectory.nc ---

/*
 * The RootDirectory object
 */
includes app_header;

interface RootDirectory
{
    event void initDone(result_t result);

    command result_t setRoot(uint8_t id, flashptr_t *save);

    event void setRootDone(result_t result);

    command result_t getRoot(uint8_t id, flashptr_t *ptr);

    event void getRootDone(result_t res);

    /* 
       This event is triggered when the root dir discovers a crash has
       occurred -> it restores the state of the checkpoint component. 
       (The checkpoint component in turn is supposed to restore the state
        of the storage objects linked to it...)
     */
    event void restore(flashptr_t *restore_ptr);
}

--- NEW FILE: RootPtrAccess.nc ---

/*
 * This provides access to the root ptr of an object
 */
includes common_header;

interface RootPtrAccess
{
    command void setPtr(flashptr_t *setPtr);

    command void getPtr(flashptr_t *getPtr);
}

--- NEW FILE: Serialize.nc ---

/*
 * The serialization interface used to save / recover objects
 */
includes app_header;

interface Serialize 
{
	command result_t checkpoint(uint8_t *buffer, datalen_t *len);

	command result_t restore(uint8_t *buffer, datalen_t *len);
}

--- NEW FILE: SingleCompaction.nc ---

includes app_header;
includes SingleStream;

interface SingleCompaction
{
    command result_t compact(stream_t *stream_ptr, uint8_t agingHint);

    event void compactionDone(stream_t *stream_ptr, result_t res);
}

--- NEW FILE: SingleStream.nc ---

/*
 * The stream storage object
 */
includes app_header;
includes SingleStream;

interface SingleStream
{
    command result_t init(stream_t *stream_ptr, bool ecc);

    /* Write more data to the stream */
    command result_t append(stream_t *stream_ptr, void *data, datalen_t len, flashptr_t *save_ptr);

    event void appendDone(stream_t *stream_ptr, result_t res);

    /* Start traversal at most recently written chunk */
    command result_t start_traversal(stream_t *stream_ptr, flashptr_t *start_ptr);

    /* Get previous stream chunk */
    command result_t next(stream_t *stream_ptr, void *data, datalen_t *len);

    event void nextDone(stream_t *stream_ptr, result_t res);
}

--- NEW FILE: Stack.nc ---

/*
 * The stack storage object
 */
includes app_header;

interface Stack 
{
    command result_t init(bool ecc);

    /* Push an object onto the flash */
    command result_t push(void *data, datalen_t len, flashptr_t *save_ptr);

    event void pushDone(result_t res);

    /* Pop and object from the flash */
    command result_t pop(void *data, datalen_t *len);

    event void popDone(result_t res);

    /* Retrieve top-most object from the flash, but dont pop it*/
    command result_t top(void *data, datalen_t *len);

    event void topDone(result_t res);
}

--- NEW FILE: Stream.nc ---

/*
 * The stream storage object
 */
includes app_header;

interface Stream
{
    command result_t init(bool ecc);

    /* Write more data to the stream */
    command result_t append(void *data, datalen_t len, flashptr_t *save_ptr);

    event void appendDone(result_t res);

    /* Start traversal at most recently written chunk */
    command result_t start_traversal(flashptr_t *start_ptr);

    /* Get previous stream chunk */
    command result_t next(void *data, datalen_t *len);

    event void nextDone(result_t res);
}

--- NEW FILE: StreamExport.nc ---

includes app_header;
includes SingleStream;

interface StreamExport
{
    command result_t export(stream_t *stream_ptr);

}

--- NEW FILE: StreamIndex.nc ---

/*
 * The stream storage object
 */
includes app_header;
includes sizes;

interface StreamIndex
{
    command result_t init(bool ecc);

    event void initDone(result_t res);

    /* Write more data to the stream */
    command result_t add(void *data, datalen_t len);

    event void addDone(result_t res);

    /* Tag the chunk just stored */
    command result_t setTag();

    event void setTagDone(result_t res, uint16_t tag);

    /* Start traversal at most recently written chunk */
    command result_t start_traversal(flashptr_t *start_ptr);

    /* Get previous stream chunk */
    command result_t next(void *data, datalen_t *len);

    event void nextDone(result_t res);

    /* Get data associated with the tag */
    command result_t getTag(uint16_t tag, void *data, datalen_t *len);

    event void getTagDone(result_t res);
}