[Tinyos-beta-commits] CVS: tinyos-1.x/beta/Deluge/Deluge DelugeStorageC.nc, 1.3, 1.4 DelugeStorageM.nc, 1.3, 1.4

Jonathan Hui jwhui at users.sourceforge.net
Mon Jan 3 09:31:17 PST 2005 

Update of /cvsroot/tinyos/tinyos-1.x/beta/Deluge/Deluge
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv4416

Modified Files:
	DelugeStorageC.nc DelugeStorageM.nc 
Log Message:
- Make better use of parameterized interfaces. Reduces code size by
about 300 bytes.



Index: DelugeStorageC.nc
===================================================================
RCS file: /cvsroot/tinyos/tinyos-1.x/beta/Deluge/Deluge/DelugeStorageC.nc,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** DelugeStorageC.nc	26 Nov 2004 18:59:10 -0000	1.3
--- DelugeStorageC.nc	3 Jan 2005 17:31:14 -0000	1.4
***************
*** 57,69 ****
  
    Storage.SubControl -> BlockStorageC;
!   Storage.Image0Volume -> FlashVolumeC.FlashVolume[DELUGE_IMAGE0_VOLUME];
!   Storage.Image1Volume -> FlashVolumeC.FlashVolume[DELUGE_IMAGE1_VOLUME]; 
!   Storage.Image2Volume -> FlashVolumeC.FlashVolume[DELUGE_IMAGE2_VOLUME]; 
!   Storage.Image0Read -> BlockStorageC.BlockRead[DELUGE_IMAGE0_VOLUME];
!   Storage.Image1Read -> BlockStorageC.BlockRead[DELUGE_IMAGE1_VOLUME];
!   Storage.Image2Read -> BlockStorageC.BlockRead[DELUGE_IMAGE2_VOLUME];
!   Storage.Image0Write -> BlockStorageC.BlockWrite[DELUGE_IMAGE0_VOLUME];
!   Storage.Image1Write -> BlockStorageC.BlockWrite[DELUGE_IMAGE1_VOLUME];
!   Storage.Image2Write -> BlockStorageC.BlockWrite[DELUGE_IMAGE2_VOLUME];
  
  }
--- 57,63 ----
  
    Storage.SubControl -> BlockStorageC;
!   Storage.ImageVolume -> FlashVolumeC;
!   Storage.ImageRead -> BlockStorageC;
!   Storage.ImageWrite -> BlockStorageC;
  
  }

Index: DelugeStorageM.nc
===================================================================
RCS file: /cvsroot/tinyos/tinyos-1.x/beta/Deluge/Deluge/DelugeStorageM.nc,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** DelugeStorageM.nc	26 Nov 2004 18:59:10 -0000	1.3
--- DelugeStorageM.nc	3 Jan 2005 17:31:14 -0000	1.4
***************
*** 39,51 ****
    }
    uses {
!     interface BlockRead as Image0Read;
!     interface BlockRead as Image1Read;
!     interface BlockRead as Image2Read;
!     interface BlockWrite as Image0Write;
!     interface BlockWrite as Image1Write;
!     interface BlockWrite as Image2Write;
!     interface FlashVolume as Image0Volume;
!     interface FlashVolume as Image1Volume;
!     interface FlashVolume as Image2Volume;
      interface StdControl as SubControl;
    }
--- 39,45 ----
    }
    uses {
!     interface BlockRead as ImageRead[uint8_t id];
!     interface BlockWrite as ImageWrite[uint8_t id];
!     interface FlashVolume as ImageVolume[uint8_t id];
      interface StdControl as SubControl;
    }
***************
*** 70,74 ****
    uint16_t crc;
  
!   void actualSignal(result_t result) {
      uint8_t tmpState = state;
      state = S_IDLE;
--- 64,68 ----
    uint16_t crc;
  
!   void signalDone(result_t result) {
      uint8_t tmpState = state;
      state = S_IDLE;
***************
*** 84,98 ****
    }
  
-   task void signalSuccess() { actualSignal(SUCCESS); }
-   task void signalFail() { actualSignal(FAIL); }
- 
-   result_t signalDone(result_t result) {
-     if (result == SUCCESS)
-       post signalSuccess();
-     else
-       post signalFail();
-     return SUCCESS;
-   }
- 
    command result_t StdControl.init() { 
      return call SubControl.init();
--- 78,81 ----
***************
*** 100,106 ****
  
    command result_t StdControl.start() { 
!     call Image0Volume.mount(FV_FACTORY_IMAGE);
!     call Image1Volume.mount(0);
!     call Image2Volume.mount(1);
      return call SubControl.start();
    }
--- 83,89 ----
  
    command result_t StdControl.start() { 
!     call ImageVolume.mount[DELUGE_VOLUMES[0]](FV_FACTORY_IMAGE);
!     call ImageVolume.mount[DELUGE_VOLUMES[1]](0);
!     call ImageVolume.mount[DELUGE_VOLUMES[2]](1);
      return call SubControl.start();
    }
***************
*** 109,124 ****
  
    command uint32_t DelugeStorage.imgNum2Addr(imgnum_t imgNum) {
!     uint32_t addr;
!     switch(imgNum) {
!     case 0: addr = call Image0Volume.physicalAddr(0); break;
!     case 1: addr = call Image1Volume.physicalAddr(0); break;
!     case 2: addr = call Image2Volume.physicalAddr(0); break;
!     default: return DELUGE_INVALID_ADDR;
!     }
      return addr + (uint32_t)DELUGE_DATA_OFFSET + (uint32_t)DELUGE_CRC_BLOCK_SIZE;
    }
  
    command imgnum_t DelugeStorage.addr2ImgNum(uint32_t addr) {
!     uint8_t volume = call Image0Volume.physicalAddrToVolume(addr);
      if (volume == FV_FACTORY_IMAGE)
        return DELUGE_FACTORY_IMAGE_NUM;
--- 92,101 ----
  
    command uint32_t DelugeStorage.imgNum2Addr(imgnum_t imgNum) {
!     uint32_t addr = call ImageVolume.physicalAddr[DELUGE_VOLUMES[imgNum]](0);
      return addr + (uint32_t)DELUGE_DATA_OFFSET + (uint32_t)DELUGE_CRC_BLOCK_SIZE;
    }
  
    command imgnum_t DelugeStorage.addr2ImgNum(uint32_t addr) {
!     uint8_t volume = call ImageVolume.physicalAddrToVolume[DELUGE_VOLUMES[0]](addr);
      if (volume == FV_FACTORY_IMAGE)
        return DELUGE_FACTORY_IMAGE_NUM;
***************
*** 127,157 ****
    }
  
-   result_t read(imgnum_t imgNum, block_addr_t addr, void* buf, block_addr_t len) {
-     switch(imgNum) {
-     case 0: return call Image0Read.read(addr, buf, len);
-     case 1: return call Image1Read.read(addr, buf, len);
-     case 2: return call Image2Read.read(addr, buf, len);
-     }
-     return FAIL;
-   }
- 
-   result_t write(imgnum_t imgNum, block_addr_t addr, void* buf, block_addr_t len) {
-     switch(imgNum) {
-     case 0: return call Image0Write.write(addr, buf, len);
-     case 1: return call Image1Write.write(addr, buf, len);
-     case 2: return call Image2Write.write(addr, buf, len);
-     }
-     return FAIL;
-   }
- 
-   result_t erase(imgnum_t imgNum) {
-     switch(imgNum) {
-     case 0: return call Image0Write.erase();
-     case 1: return call Image1Write.erase();
-     case 2: return call Image2Write.erase();
-     }
-     return FAIL;
-   }
- 
    result_t computeCrc(imgnum_t imgNum) {
      
--- 104,107 ----
***************
*** 168,178 ****
      }
  
!     switch(imgNum) {
!     case 0: return call Image0Read.computeCrc(blockAddr, len);
!     case 1: return call Image1Read.computeCrc(blockAddr, len);
!     case 2: return call Image2Read.computeCrc(blockAddr, len);
!     }
! 
!     return FAIL;
  
    }
--- 118,122 ----
      }
  
!     return call ImageRead.computeCrc[DELUGE_VOLUMES[imgNum]](blockAddr, len);
  
    }
***************
*** 195,210 ****
      switch(newState) {
      case S_READ_METADATA: case S_READ_DATA:
!       result = read(imgNum, addr, buf, len);
        break;
      case S_WRITE_METADATA: case S_WRITE_DATA:
!       result = write(imgNum, addr, buf, len);
        break;
      case S_ERASE_DATA:
!       result = erase(imgNum);
        break;
      case S_READ_CRC:
        page = addr;
        crcAddr = DELUGE_DATA_OFFSET + sizeof(crc)*page;
!       result = read(imgNum, crcAddr, &crc, sizeof(crc));
        break;
      default:
--- 139,154 ----
      switch(newState) {
      case S_READ_METADATA: case S_READ_DATA:
!       result = call ImageRead.read[DELUGE_VOLUMES[imgNum]](addr, buf, len);
        break;
      case S_WRITE_METADATA: case S_WRITE_DATA:
!       result = call ImageWrite.write[DELUGE_VOLUMES[imgNum]](addr, buf, len);
        break;
      case S_ERASE_DATA:
!       result = call ImageWrite.erase[DELUGE_VOLUMES[imgNum]]();
        break;
      case S_READ_CRC:
        page = addr;
        crcAddr = DELUGE_DATA_OFFSET + sizeof(crc)*page;
!       result = call ImageRead.read[DELUGE_VOLUMES[imgNum]](crcAddr, (uint8_t*)&crc, sizeof(crc));
        break;
      default:
***************
*** 248,256 ****
    }
  
!   void flashReqDone(imgnum_t imgNum, result_t result) {
      switch(state) {
      case S_READ_CRC:
        state = S_COMPUTE_CRC;
!       if (computeCrc(imgNum) == FAIL)
  	signalDone(FAIL);
        break;
--- 192,211 ----
    }
  
!   void flashReqDone(uint8_t volume, result_t result) {
! 
!     uint8_t i;
! 
!     for ( i = 0; i < DELUGE_NUM_IMAGES; i++ ) {
!       if (volume == DELUGE_VOLUMES[i])
! 	break;
!     }
! 
!     if (i == DELUGE_NUM_IMAGES)
!       return;
!       
      switch(state) {
      case S_READ_CRC:
        state = S_COMPUTE_CRC;
!       if (computeCrc(i) == FAIL)
  	signalDone(FAIL);
        break;
***************
*** 261,330 ****
    }
  
!   event result_t Image0Read.readDone(result_t result) {
!     flashReqDone(0, result);
!     return SUCCESS;
!   }
! 
!   event result_t Image0Read.computeCrcDone(result_t result, uint16_t crcResult) {
!     flashReqDone(0, (crc == crcResult) ? SUCCESS : FAIL);
!     return SUCCESS;
!   }
! 
!   event result_t Image0Write.writeDone(result_t result) {
!     flashReqDone(0, result);
!     return SUCCESS;
!   }
! 
!   event result_t Image0Write.eraseDone(result_t result) { 
!     flashReqDone(0, result);
!     return SUCCESS; 
!   } 
! 
!   event result_t Image1Read.readDone(result_t result) {
!     flashReqDone(1, result);
!     return SUCCESS;
!   }
! 
!   event result_t Image1Read.computeCrcDone(result_t result, uint16_t crcResult) {
!     flashReqDone(1, (crc == crcResult) ? SUCCESS : FAIL);
!     return SUCCESS;
!   }
! 
!   event result_t Image1Write.writeDone(result_t result) {
!     flashReqDone(1, result);
!     return SUCCESS;
!   }
! 
!   event result_t Image1Write.eraseDone(result_t result) { 
!     flashReqDone(1, result);
!     return SUCCESS; 
!   } 
! 
!   event result_t Image2Read.readDone(result_t result) {
!     flashReqDone(2, result);
      return SUCCESS;
    }
  
!   event result_t Image2Read.computeCrcDone(result_t result, uint16_t crcResult) {
!     flashReqDone(2, (crc == crcResult) ? SUCCESS : FAIL);
      return SUCCESS;
    }
  
!   event result_t Image2Write.writeDone(result_t result) {
!     flashReqDone(2, result);
      return SUCCESS;
    }
  
!   event result_t Image2Write.eraseDone(result_t result) { 
!     flashReqDone(2, result);
      return SUCCESS; 
    } 
  
!   event result_t Image0Read.verifyDone(result_t result) { return SUCCESS; }
!   event result_t Image0Write.commitDone(result_t result) { return SUCCESS; }
!   event result_t Image1Read.verifyDone(result_t result) { return SUCCESS; }
!   event result_t Image1Write.commitDone(result_t result) { return SUCCESS; }
!   event result_t Image2Read.verifyDone(result_t result) { return SUCCESS; }
!   event result_t Image2Write.commitDone(result_t result) { return SUCCESS; }
  
    default event result_t DataRead.readDone[uint8_t id](result_t result) { return SUCCESS; }
--- 216,241 ----
    }
  
!   event result_t ImageRead.readDone[uint8_t volume](result_t result) {
!     flashReqDone(volume, result);
      return SUCCESS;
    }
  
!   event result_t ImageRead.computeCrcDone[uint8_t volume](result_t result, uint16_t crcResult) {
!     flashReqDone(volume, (crc == crcResult) ? SUCCESS : FAIL);
      return SUCCESS;
    }
  
!   event result_t ImageWrite.writeDone[uint8_t volume](result_t result) {
!     flashReqDone(volume, result);
      return SUCCESS;
    }
  
!   event result_t ImageWrite.eraseDone[uint8_t volume](result_t result) { 
!     flashReqDone(volume, result);
      return SUCCESS; 
    } 
  
!   event result_t ImageRead.verifyDone[uint8_t volume](result_t result) { return SUCCESS; }
!   event result_t ImageWrite.commitDone[uint8_t volume](result_t result) { return SUCCESS; }
  
    default event result_t DataRead.readDone[uint8_t id](result_t result) { return SUCCESS; }
***************
*** 335,338 ****
    default event result_t MetadataWrite.writeDone[uint8_t id](result_t result) { return SUCCESS; }
  
- 
  }
--- 246,248 ----

More information about the Tinyos-beta-commits mailing list