bd: Adopted the get_erase_value function in the util block devices

geky · geky · commit 88aad813452e · 2018-01-29T15:33:02.000-06:00
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();
     }
 
@@ -190,6 +199,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
@@ -107,7 +107,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
@@ -135,6 +136,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 will be 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 the value of
+     *                  erased storage can't be relied on
+     */
+    virtual int get_erase_value() const;
+
     /** Get the total size of the underlying device
      *
      *  @return         Size of the underlying device in bytes
@@ -148,6 +160,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
@@ -102,6 +102,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
@@ -92,7 +92,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
@@ -118,6 +119,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 will be 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 the value of
+     *                  erased storage can't be relied on
+     */
+    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
@@ -267,6 +267,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
@@ -161,7 +161,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
@@ -189,6 +190,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 will be 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 the value of
+     *                  erased storage can't be relied on
+     */
+    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
@@ -91,6 +91,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
@@ -78,7 +78,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
@@ -104,6 +105,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 will be 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 the value of
+     *                  erased storage can't be relied on
+     */
+    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
@@ -77,6 +77,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
@@ -93,7 +93,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
@@ -121,6 +122,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 will be 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 the value of
+     *                  erased storage can't be relied on
+     */
+    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
@@ -77,6 +77,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
@@ -71,7 +71,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
@@ -97,6 +98,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 will be 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 the value of
+     *                  erased storage can't be relied on
+     */
+    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
@@ -97,6 +97,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
@@ -99,7 +99,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
@@ -127,6 +128,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 will be 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 the value of
+     *                  erased storage can't be relied on
+     */
+    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`
`@@ -190,6 +199,11 @@ bd_size_t ChainingBlockDevice::get_erase_size() const`
`190`	`199`	`return _erase_size;`
`191`	`200`	`}`
`192`	`201`
	`202`	`+int ChainingBlockDevice::get_erase_value() const`
	`203`	`+{`
	`204`	`+ return _erase_value;`
	`205`	`+}`
	`206`	`+`
`193`	`207`	`bd_size_t ChainingBlockDevice::size() const`
`194`	`208`	`{`
`195`	`209`	`return _size;`
Original file line number	Diff line number	Diff line change
`@@ -102,6 +102,11 @@ bd_size_t ExhaustibleBlockDevice::get_erase_size() const`
`102`	`102`	`return _bd->get_erase_size();`
`103`	`103`	`}`
`104`	`104`
	`105`	`+int ExhaustibleBlockDevice::get_erase_value() const`
	`106`	`+{`
	`107`	`+ return _bd->get_erase_value();`
	`108`	`+}`
	`109`	`+`
`105`	`110`	`bd_size_t ExhaustibleBlockDevice::size() const`
`106`	`111`	`{`
`107`	`112`	`return _bd->size();`
Original file line number	Diff line number	Diff line change
`@@ -267,6 +267,11 @@ bd_size_t MBRBlockDevice::get_erase_size() const`
`267`	`267`	`return _bd->get_erase_size();`
`268`	`268`	`}`
`269`	`269`
	`270`	`+int MBRBlockDevice::get_erase_value() const`
	`271`	`+{`
	`272`	`+ return _bd->get_erase_value();`
	`273`	`+}`
	`274`	`+`
`270`	`275`	`bd_size_t MBRBlockDevice::size() const`
`271`	`276`	`{`
`272`	`277`	`return _size;`
Original file line number	Diff line number	Diff line change
`@@ -91,6 +91,11 @@ bd_size_t ObservingBlockDevice::get_erase_size() const`
`91`	`91`	`return _bd->get_erase_size();`
`92`	`92`	`}`
`93`	`93`
	`94`	`+int ObservingBlockDevice::get_erase_value() const`
	`95`	`+{`
	`96`	`+ return _bd->get_erase_value();`
	`97`	`+}`
	`98`	`+`
`94`	`99`	`bd_size_t ObservingBlockDevice::size() const`
`95`	`100`	`{`
`96`	`101`	`return _bd->size();`
Original file line number	Diff line number	Diff line change
`@@ -77,6 +77,11 @@ bd_size_t ProfilingBlockDevice::get_erase_size() const`
`77`	`77`	`return _bd->get_erase_size();`
`78`	`78`	`}`
`79`	`79`
	`80`	`+int ProfilingBlockDevice::get_erase_value() const`
	`81`	`+{`
	`82`	`+ return _bd->get_erase_value();`
	`83`	`+}`
	`84`	`+`
`80`	`85`	`bd_size_t ProfilingBlockDevice::size() const`
`81`	`86`	`{`
`82`	`87`	`return _bd->size();`
Original file line number	Diff line number	Diff line change
`@@ -77,6 +77,11 @@ bd_size_t ReadOnlyBlockDevice::get_erase_size() const`
`77`	`77`	`return _bd->get_erase_size();`
`78`	`78`	`}`
`79`	`79`
	`80`	`+int ReadOnlyBlockDevice::get_erase_value() const`
	`81`	`+{`
	`82`	`+ return _bd->get_erase_value();`
	`83`	`+}`
	`84`	`+`
`80`	`85`	`bd_size_t ReadOnlyBlockDevice::size() const`
`81`	`86`	`{`
`82`	`87`	`return _bd->size();`
Original file line number	Diff line number	Diff line change
`@@ -97,6 +97,11 @@ bd_size_t SlicingBlockDevice::get_erase_size() const`
`97`	`97`	`return _bd->get_erase_size();`
`98`	`98`	`}`
`99`	`99`
	`100`	`+int SlicingBlockDevice::get_erase_value() const`
	`101`	`+{`
	`102`	`+ return _bd->get_erase_value();`
	`103`	`+}`
	`104`	`+`
`100`	`105`	`bd_size_t SlicingBlockDevice::size() const`
`101`	`106`	`{`
`102`	`107`	`return _stop - _start;`