Merge pull request #5925 from geky/bd-erase-value

cmonr · web-flow · commit 5cd30b965cf5 · 2018-01-31T12:13:54.000-06:00
bd: Add get_erase_value function to the block device API
diff --git a/features/filesystem/bd/BlockDevice.h b/features/filesystem/bd/BlockDevice.h
@@ -94,7 +94,8 @@ class BlockDevice
 
     /** Erase blocks on a block device
      *
-     *  The state of an erased block is undefined until it has been programmed
+     *  The state of an erased block is undefined until it has been programmed,
+     *  unless get_erase_value returns a non-negative byte value
      *
      *  @param addr     Address of block to begin erasing
      *  @param size     Size to erase in bytes, must be a multiple of erase block size
@@ -144,6 +145,20 @@ class BlockDevice
         return get_program_size();
     }
 
+    /** Get the value of storage when erased
+     *
+     *  If get_erase_value returns a non-negative byte value, the underlying
+     *  storage is set to that value when erased, and storage containing
+     *  that value can be programmed without another erase.
+     *
+     *  @return         The value of storage when erased, or -1 if you can't
+     *                  rely on the value of erased storage
+     */
+    virtual int get_erase_value() const
+    {
+        return -1;
+    }
+
     /** Get the total size of the underlying device
      *
      *  @return         Size of the underlying device in bytes
diff --git a/features/filesystem/bd/ChainingBlockDevice.cpp b/features/filesystem/bd/ChainingBlockDevice.cpp
@@ -20,6 +20,7 @@
 ChainingBlockDevice::ChainingBlockDevice(BlockDevice **bds, size_t bd_count)
     : _bds(bds), _bd_count(bd_count)
     , _read_size(0), _program_size(0), _erase_size(0), _size(0)
+    , _erase_value(-1)
 {
 }
 
@@ -33,6 +34,7 @@ int ChainingBlockDevice::init()
     _read_size = 0;
     _program_size = 0;
     _erase_size = 0;
+    _erase_value = -1;
     _size = 0;
 
     // Initialize children block devices, find all sizes and
@@ -66,6 +68,13 @@ int ChainingBlockDevice::init()
             MBED_ASSERT(_erase_size > erase && is_aligned(_erase_size, erase));
         }
 
+        int value = _bds[i]->get_erase_value();
+        if (i == 0 || value == _erase_value) {
+            _erase_value = value;
+        } else {
+            _erase_value = -1;
+        }
+
         _size += _bds[i]->size();
     }
 
@@ -202,6 +211,11 @@ bd_size_t ChainingBlockDevice::get_erase_size() const
     return _erase_size;
 }
 
+int ChainingBlockDevice::get_erase_value() const
+{
+    return _erase_value;
+}
+
 bd_size_t ChainingBlockDevice::size() const
 {
     return _size;
diff --git a/features/filesystem/bd/ChainingBlockDevice.h b/features/filesystem/bd/ChainingBlockDevice.h
@@ -113,7 +113,8 @@ class ChainingBlockDevice : public BlockDevice
 
     /** Erase blocks on a block device
      *
-     *  The state of an erased block is undefined until it has been programmed
+     *  The state of an erased block is undefined until it has been programmed,
+     *  unless get_erase_value returns a non-negative byte value
      *
      *  @param addr     Address of block to begin erasing
      *  @param size     Size to erase in bytes, must be a multiple of erase block size
@@ -141,6 +142,17 @@ class ChainingBlockDevice : public BlockDevice
      */
     virtual bd_size_t get_erase_size() const;
 
+    /** Get the value of storage when erased
+     *
+     *  If get_erase_value returns a non-negative byte value, the underlying
+     *  storage is set to that value when erased, and storage containing
+     *  that value can be programmed without another erase.
+     *
+     *  @return         The value of storage when erased, or -1 if you can't
+     *                  rely on the value of erased storage
+     */
+    virtual int get_erase_value() const;
+
     /** Get the total size of the underlying device
      *
      *  @return         Size of the underlying device in bytes
@@ -154,6 +166,7 @@ class ChainingBlockDevice : public BlockDevice
     bd_size_t _program_size;
     bd_size_t _erase_size;
     bd_size_t _size;
+    int _erase_value;
 };
 
 
diff --git a/features/filesystem/bd/ExhaustibleBlockDevice.cpp b/features/filesystem/bd/ExhaustibleBlockDevice.cpp
@@ -107,6 +107,11 @@ bd_size_t ExhaustibleBlockDevice::get_erase_size() const
     return _bd->get_erase_size();
 }
 
+int ExhaustibleBlockDevice::get_erase_value() const
+{
+    return _bd->get_erase_value();
+}
+
 bd_size_t ExhaustibleBlockDevice::size() const
 {
     return _bd->size();
diff --git a/features/filesystem/bd/ExhaustibleBlockDevice.h b/features/filesystem/bd/ExhaustibleBlockDevice.h
@@ -98,7 +98,8 @@ class ExhaustibleBlockDevice : public BlockDevice
 
     /** Erase blocks on a block device
      *
-     *  The state of an erased block is undefined until it has been programmed
+     *  The state of an erased block is undefined until it has been programmed,
+     *  unless get_erase_value returns a non-negative byte value
      *
      *  @param addr     Address of block to begin erasing
      *  @param size     Size to erase in bytes, must be a multiple of erase block size
@@ -124,6 +125,17 @@ class ExhaustibleBlockDevice : public BlockDevice
      */
     virtual bd_size_t get_erase_size() const;
 
+    /** Get the value of storage when erased
+     *
+     *  If get_erase_value returns a non-negative byte value, the underlying
+     *  storage is set to that value when erased, and storage containing
+     *  that value can be programmed without another erase.
+     *
+     *  @return         The value of storage when erased, or -1 if you can't
+     *                  rely on the value of erased storage
+     */
+    virtual int get_erase_value() const;
+
     /** Get the total size of the underlying device
      *
      *  @return         Size of the underlying device in bytes
diff --git a/features/filesystem/bd/MBRBlockDevice.cpp b/features/filesystem/bd/MBRBlockDevice.cpp
@@ -272,6 +272,11 @@ bd_size_t MBRBlockDevice::get_erase_size() const
     return _bd->get_erase_size();
 }
 
+int MBRBlockDevice::get_erase_value() const
+{
+    return _bd->get_erase_value();
+}
+
 bd_size_t MBRBlockDevice::size() const
 {
     return _size;
diff --git a/features/filesystem/bd/MBRBlockDevice.h b/features/filesystem/bd/MBRBlockDevice.h
@@ -167,7 +167,8 @@ class MBRBlockDevice : public BlockDevice
 
     /** Erase blocks on a block device
      *
-     *  The state of an erased block is undefined until it has been programmed
+     *  The state of an erased block is undefined until it has been programmed,
+     *  unless get_erase_value returns a non-negative byte value
      *
      *  @param addr     Address of block to begin erasing
      *  @param size     Size to erase in bytes, must be a multiple of erase block size
@@ -195,6 +196,17 @@ class MBRBlockDevice : public BlockDevice
      */
     virtual bd_size_t get_erase_size() const;
 
+    /** Get the value of storage when erased
+     *
+     *  If get_erase_value returns a non-negative byte value, the underlying
+     *  storage is set to that value when erased, and storage containing
+     *  that value can be programmed without another erase.
+     *
+     *  @return         The value of storage when erased, or -1 if you can't
+     *                  rely on the value of erased storage
+     */
+    virtual int get_erase_value() const;
+
     /** Get the total size of the underlying device
      *
      *  @return         Size of the underlying device in bytes
diff --git a/features/filesystem/bd/ObservingBlockDevice.cpp b/features/filesystem/bd/ObservingBlockDevice.cpp
@@ -96,6 +96,11 @@ bd_size_t ObservingBlockDevice::get_erase_size() const
     return _bd->get_erase_size();
 }
 
+int ObservingBlockDevice::get_erase_value() const
+{
+    return _bd->get_erase_value();
+}
+
 bd_size_t ObservingBlockDevice::size() const
 {
     return _bd->size();
diff --git a/features/filesystem/bd/ObservingBlockDevice.h b/features/filesystem/bd/ObservingBlockDevice.h
@@ -84,7 +84,8 @@ class ObservingBlockDevice : public BlockDevice
 
     /** Erase blocks on a block device
      *
-     *  The state of an erased block is undefined until it has been programmed
+     *  The state of an erased block is undefined until it has been programmed,
+     *  unless get_erase_value returns a non-negative byte value
      *
      *  @param addr     Address of block to begin erasing
      *  @param size     Size to erase in bytes, must be a multiple of erase block size
@@ -110,6 +111,17 @@ class ObservingBlockDevice : public BlockDevice
      */
     virtual bd_size_t get_erase_size() const;
 
+    /** Get the value of storage when erased
+     *
+     *  If get_erase_value returns a non-negative byte value, the underlying
+     *  storage is set to that value when erased, and storage containing
+     *  that value can be programmed without another erase.
+     *
+     *  @return         The value of storage when erased, or -1 if you can't
+     *                  rely on the value of erased storage
+     */
+    virtual int get_erase_value() const;
+
     /** Get the total size of the underlying device
      *
      *  @return         Size of the underlying device in bytes
diff --git a/features/filesystem/bd/ProfilingBlockDevice.cpp b/features/filesystem/bd/ProfilingBlockDevice.cpp
@@ -82,6 +82,11 @@ bd_size_t ProfilingBlockDevice::get_erase_size() const
     return _bd->get_erase_size();
 }
 
+int ProfilingBlockDevice::get_erase_value() const
+{
+    return _bd->get_erase_value();
+}
+
 bd_size_t ProfilingBlockDevice::size() const
 {
     return _bd->size();
diff --git a/features/filesystem/bd/ProfilingBlockDevice.h b/features/filesystem/bd/ProfilingBlockDevice.h
@@ -99,7 +99,8 @@ class ProfilingBlockDevice : public BlockDevice
 
     /** Erase blocks on a block device
      *
-     *  The state of an erased block is undefined until it has been programmed
+     *  The state of an erased block is undefined until it has been programmed,
+     *  unless get_erase_value returns a non-negative byte value
      *
      *  @param addr     Address of block to begin erasing
      *  @param size     Size to erase in bytes, must be a multiple of erase block size
@@ -127,6 +128,17 @@ class ProfilingBlockDevice : public BlockDevice
      */
     virtual bd_size_t get_erase_size() const;
 
+    /** Get the value of storage when erased
+     *
+     *  If get_erase_value returns a non-negative byte value, the underlying
+     *  storage is set to that value when erased, and you can program storage
+     *  containing that value without another erase.
+     *
+     *  @return         The value of storage when erased, or -1 if you can't
+     *                  rely on the value of erased storage
+     */
+    virtual int get_erase_value() const;
+
     /** Get the total size of the underlying device
      *
      *  @return         Size of the underlying device in bytes
diff --git a/features/filesystem/bd/ReadOnlyBlockDevice.cpp b/features/filesystem/bd/ReadOnlyBlockDevice.cpp
@@ -82,6 +82,11 @@ bd_size_t ReadOnlyBlockDevice::get_erase_size() const
     return _bd->get_erase_size();
 }
 
+int ReadOnlyBlockDevice::get_erase_value() const
+{
+    return _bd->get_erase_value();
+}
+
 bd_size_t ReadOnlyBlockDevice::size() const
 {
     return _bd->size();
diff --git a/features/filesystem/bd/ReadOnlyBlockDevice.h b/features/filesystem/bd/ReadOnlyBlockDevice.h
@@ -77,7 +77,8 @@ class ReadOnlyBlockDevice : public BlockDevice
 
     /** Erase blocks on a block device
      *
-     *  The state of an erased block is undefined until it has been programmed
+     *  The state of an erased block is undefined until it has been programmed,
+     *  unless get_erase_value returns a non-negative byte value
      *
      *  @param addr     Address of block to begin erasing
      *  @param size     Size to erase in bytes, must be a multiple of erase block size
@@ -103,6 +104,17 @@ class ReadOnlyBlockDevice : public BlockDevice
      */
     virtual bd_size_t get_erase_size() const;
 
+    /** Get the value of storage when erased
+     *
+     *  If get_erase_value returns a non-negative byte value, the underlying
+     *  storage is set to that value when erased, and storage containing
+     *  that value can be programmed without another erase.
+     *
+     *  @return         The value of storage when erased, or -1 if you can't
+     *                  rely on the value of erased storage
+     */
+    virtual int get_erase_value() const;
+
     /** Get the total size of the underlying device
      *
      *  @return         Size of the underlying device in bytes
diff --git a/features/filesystem/bd/SlicingBlockDevice.cpp b/features/filesystem/bd/SlicingBlockDevice.cpp
@@ -102,6 +102,11 @@ bd_size_t SlicingBlockDevice::get_erase_size() const
     return _bd->get_erase_size();
 }
 
+int SlicingBlockDevice::get_erase_value() const
+{
+    return _bd->get_erase_value();
+}
+
 bd_size_t SlicingBlockDevice::size() const
 {
     return _stop - _start;
diff --git a/features/filesystem/bd/SlicingBlockDevice.h b/features/filesystem/bd/SlicingBlockDevice.h
@@ -105,7 +105,8 @@ class SlicingBlockDevice : public BlockDevice
 
     /** Erase blocks on a block device
      *
-     *  The state of an erased block is undefined until it has been programmed
+     *  The state of an erased block is undefined until it has been programmed,
+     *  unless get_erase_value returns a non-negative byte value
      *
      *  @param addr     Address of block to begin erasing
      *  @param size     Size to erase in bytes, must be a multiple of erase block size
@@ -133,6 +134,17 @@ class SlicingBlockDevice : public BlockDevice
      */
     virtual bd_size_t get_erase_size() const;
 
+    /** Get the value of storage when erased
+     *
+     *  If get_erase_value returns a non-negative byte value, the underlying
+     *  storage is set to that value when erased, and storage containing
+     *  that value can be programmed without another erase.
+     *
+     *  @return         The value of storage when erased, or -1 if you can't
+     *                  rely on the value of erased storage
+     */
+    virtual int get_erase_value() const;
+
     /** Get the total size of the underlying device
      *
      *  @return         Size of the underlying device in bytes

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@`
`20`	`20`	`ChainingBlockDevice::ChainingBlockDevice(BlockDevice **bds, size_t bd_count)`
`21`	`21`	`: _bds(bds), _bd_count(bd_count)`
`22`	`22`	`, _read_size(0), _program_size(0), _erase_size(0), _size(0)`
	`23`	`+ , _erase_value(-1)`
`23`	`24`	`{`
`24`	`25`	`}`
`25`	`26`
`@@ -33,6 +34,7 @@ int ChainingBlockDevice::init()`
`33`	`34`	`_read_size = 0;`
`34`	`35`	`_program_size = 0;`
`35`	`36`	`_erase_size = 0;`
	`37`	`+ _erase_value = -1;`
`36`	`38`	`_size = 0;`
`37`	`39`
`38`	`40`	`// Initialize children block devices, find all sizes and`
`@@ -66,6 +68,13 @@ int ChainingBlockDevice::init()`
`66`	`68`	`MBED_ASSERT(_erase_size > erase && is_aligned(_erase_size, erase));`
`67`	`69`	`}`
`68`	`70`
	`71`	`+ int value = _bds[i]->get_erase_value();`
	`72`	`+ if (i == 0 \|\| value == _erase_value) {`
	`73`	`+ _erase_value = value;`
	`74`	`+ } else {`
	`75`	`+ _erase_value = -1;`
	`76`	`+ }`
	`77`	`+`
`69`	`78`	`_size += _bds[i]->size();`
`70`	`79`	`}`
`71`	`80`
`@@ -202,6 +211,11 @@ bd_size_t ChainingBlockDevice::get_erase_size() const`
`202`	`211`	`return _erase_size;`
`203`	`212`	`}`
`204`	`213`
	`214`	`+int ChainingBlockDevice::get_erase_value() const`
	`215`	`+{`
	`216`	`+ return _erase_value;`
	`217`	`+}`
	`218`	`+`
`205`	`219`	`bd_size_t ChainingBlockDevice::size() const`
`206`	`220`	`{`
`207`	`221`	`return _size;`
Original file line number	Diff line number	Diff line change
`@@ -107,6 +107,11 @@ bd_size_t ExhaustibleBlockDevice::get_erase_size() const`
`107`	`107`	`return _bd->get_erase_size();`
`108`	`108`	`}`
`109`	`109`
	`110`	`+int ExhaustibleBlockDevice::get_erase_value() const`
	`111`	`+{`
	`112`	`+ return _bd->get_erase_value();`
	`113`	`+}`
	`114`	`+`
`110`	`115`	`bd_size_t ExhaustibleBlockDevice::size() const`
`111`	`116`	`{`
`112`	`117`	`return _bd->size();`
Original file line number	Diff line number	Diff line change
`@@ -272,6 +272,11 @@ bd_size_t MBRBlockDevice::get_erase_size() const`
`272`	`272`	`return _bd->get_erase_size();`
`273`	`273`	`}`
`274`	`274`
	`275`	`+int MBRBlockDevice::get_erase_value() const`
	`276`	`+{`
	`277`	`+ return _bd->get_erase_value();`
	`278`	`+}`
	`279`	`+`
`275`	`280`	`bd_size_t MBRBlockDevice::size() const`
`276`	`281`	`{`
`277`	`282`	`return _size;`
Original file line number	Diff line number	Diff line change
`@@ -96,6 +96,11 @@ bd_size_t ObservingBlockDevice::get_erase_size() const`
`96`	`96`	`return _bd->get_erase_size();`
`97`	`97`	`}`
`98`	`98`
	`99`	`+int ObservingBlockDevice::get_erase_value() const`
	`100`	`+{`
	`101`	`+ return _bd->get_erase_value();`
	`102`	`+}`
	`103`	`+`
`99`	`104`	`bd_size_t ObservingBlockDevice::size() const`
`100`	`105`	`{`
`101`	`106`	`return _bd->size();`
Original file line number	Diff line number	Diff line change
`@@ -82,6 +82,11 @@ bd_size_t ProfilingBlockDevice::get_erase_size() const`
`82`	`82`	`return _bd->get_erase_size();`
`83`	`83`	`}`
`84`	`84`
	`85`	`+int ProfilingBlockDevice::get_erase_value() const`
	`86`	`+{`
	`87`	`+ return _bd->get_erase_value();`
	`88`	`+}`
	`89`	`+`
`85`	`90`	`bd_size_t ProfilingBlockDevice::size() const`
`86`	`91`	`{`
`87`	`92`	`return _bd->size();`