SFDP: Sector Map Parameter Table naming improvements

Author: Veijo Pesonen

components/storage/blockdevice/COMPONENT_QSPIF/QSPIFBlockDevice.cpp

@@ -152,9 +152,9 @@ QSPIFBlockDevice::QSPIFBlockDevice(PinName io0, PinName io1, PinName io2, PinNam
     }
 
     // Initialize parameters
-    _sfdp_info.smtbl.regions_min_common_erase_size = 0;
-    _sfdp_info.smtbl.region_cnt = 1;
-    _sfdp_info.smtbl.region_erase_types_bitfld[0] = SFDP_ERASE_BITMASK_NONE;
+    _sfdp_info.smptbl.regions_min_common_erase_size = 0;
+    _sfdp_info.smptbl.region_cnt = 1;
+    _sfdp_info.smptbl.region_erase_types_bitfld[0] = SFDP_ERASE_BITMASK_NONE;
 
     // Until proven otherwise, assume no quad enable
     _quad_enable_register_idx = QSPIF_NO_QUAD_ENABLE;
@@ -200,8 +200,8 @@ int QSPIFBlockDevice::init()
     int status = QSPIF_BD_ERROR_OK;
     _sfdp_info.bptbl.addr = 0x0;
     _sfdp_info.bptbl.size = 0;
-    _sfdp_info.smtbl.addr = 0x0;
-    _sfdp_info.smtbl.size = 0;
+    _sfdp_info.smptbl.addr = 0x0;
+    _sfdp_info.smptbl.size = 0;
 
     _mutex.lock();
 
@@ -259,15 +259,15 @@ int QSPIFBlockDevice::init()
     }
 
     /**************************** Parse Sector Map Table ***********************************/
-    _sfdp_info.smtbl.region_size[0] =
+    _sfdp_info.smptbl.region_size[0] =
         _device_size_bytes; // If there's no region map, we have a single region sized the entire device size
-    _sfdp_info.smtbl.region_high_boundary[0] = _device_size_bytes - 1;
+    _sfdp_info.smptbl.region_high_boundary[0] = _device_size_bytes - 1;
 
-    if ((_sfdp_info.smtbl.addr != 0) && (0 != _sfdp_info.smtbl.size)) {
-        tr_debug("Init - Parsing Sector Map Table - addr: 0x%lxh, Size: %d", _sfdp_info.smtbl.addr,
-                 _sfdp_info.smtbl.size);
+    if ((_sfdp_info.smptbl.addr != 0) && (0 != _sfdp_info.smptbl.size)) {
+        tr_debug("Init - Parsing Sector Map Table - addr: 0x%lxh, Size: %d", _sfdp_info.smptbl.addr,
+                 _sfdp_info.smptbl.size);
         if (sfdp_parse_sector_map_table(callback(this, &QSPIFBlockDevice::_qspi_send_read_sfdp_command),
-                                        _sfdp_info.smtbl) < 0) {
+                                        _sfdp_info.smptbl) < 0) {
             tr_error("Init - Parse Sector Map Table Failed");
             status = QSPIF_BD_ERROR_PARSING_FAILED;
             goto exit_point;
@@ -409,9 +409,9 @@ int QSPIFBlockDevice::erase(bd_addr_t addr, bd_size_t in_size)
     bool erase_failed = false;
     int status = QSPIF_BD_ERROR_OK;
     // Find region of erased address
-    int region = _utils_find_addr_region(addr, _sfdp_info.smtbl);
+    int region = _utils_find_addr_region(addr, _sfdp_info.smptbl);
     // Erase Types of selected region
-    uint8_t bitfield = _sfdp_info.smtbl.region_erase_types_bitfld[region];
+    uint8_t bitfield = _sfdp_info.smptbl.region_erase_types_bitfld[region];
 
     tr_debug("Erase - addr: %llu, in_size: %llu", addr, in_size);
 
@@ -433,9 +433,9 @@ int QSPIFBlockDevice::erase(bd_addr_t addr, bd_size_t in_size)
             // Find the matching instruction and erase size chunk for that type.
             type = _utils_iterate_next_largest_erase_type(bitfield, size, (int)addr,
                                                           region,
-                                                          _sfdp_info.smtbl);
-            cur_erase_inst = _sfdp_info.smtbl.erase_type_inst_arr[type];
-            eu_size = _sfdp_info.smtbl.erase_type_size_arr[type];
+                                                          _sfdp_info.smptbl);
+            cur_erase_inst = _sfdp_info.smptbl.erase_type_inst_arr[type];
+            eu_size = _sfdp_info.smptbl.erase_type_size_arr[type];
         } else {
             // Must use legacy 4k erase instruction
             cur_erase_inst = _legacy_erase_instruction;
@@ -468,10 +468,10 @@ int QSPIFBlockDevice::erase(bd_addr_t addr, bd_size_t in_size)
         addr += chunk;
         size -= chunk;
 
-        if ((size > 0) && (addr > _sfdp_info.smtbl.region_high_boundary[region])) {
+        if ((size > 0) && (addr > _sfdp_info.smptbl.region_high_boundary[region])) {
             // erase crossed to next region
             region++;
-            bitfield = _sfdp_info.smtbl.region_erase_types_bitfld[region];
+            bitfield = _sfdp_info.smptbl.region_erase_types_bitfld[region];
         }
 
         if (false == _is_mem_ready()) {
@@ -507,7 +507,7 @@ bd_size_t QSPIFBlockDevice::get_program_size() const
 bd_size_t QSPIFBlockDevice::get_erase_size() const
 {
     // return minimal erase size supported by all regions (0 if none exists)
-    return _sfdp_info.smtbl.regions_min_common_erase_size;
+    return _sfdp_info.smptbl.regions_min_common_erase_size;
 }
 
 const char *QSPIFBlockDevice::get_type() const
@@ -524,9 +524,9 @@ bd_size_t QSPIFBlockDevice::get_erase_size(bd_addr_t addr)
     }
 
     // Find region of current address
-    int region = _utils_find_addr_region(addr, _sfdp_info.smtbl);
+    int region = _utils_find_addr_region(addr, _sfdp_info.smptbl);
 
-    int min_region_erase_size = _sfdp_info.smtbl.regions_min_common_erase_size;
+    int min_region_erase_size = _sfdp_info.smptbl.regions_min_common_erase_size;
     int8_t type_mask = SFDP_ERASE_BITMASK_TYPE1;
     int i_ind = 0;
 
@@ -535,9 +535,9 @@ bd_size_t QSPIFBlockDevice::get_erase_size(bd_addr_t addr)
 
         for (i_ind = 0; i_ind < 4; i_ind++) {
             // loop through erase types bitfield supported by region
-            if (_sfdp_info.smtbl.region_erase_types_bitfld[region] & type_mask) {
+            if (_sfdp_info.smptbl.region_erase_types_bitfld[region] & type_mask) {
 
-                min_region_erase_size = _sfdp_info.smtbl.erase_type_size_arr[i_ind];
+                min_region_erase_size = _sfdp_info.smptbl.erase_type_size_arr[i_ind];
                 break;
             }
             type_mask = type_mask << 1;
@@ -661,7 +661,7 @@ int QSPIFBlockDevice::_sfdp_parse_basic_param_table(uint32_t basic_table_addr, s
     bool shouldSetQuadEnable = false;
     bool is_qpi_mode = false;
 
-    if (_sfdp_detect_erase_types_inst_and_size(param_table, basic_table_size, _sfdp_info.smtbl) != 0) {
+    if (_sfdp_detect_erase_types_inst_and_size(param_table, basic_table_size, _sfdp_info.smptbl) != 0) {
         tr_error("Init - Detecting erase types instructions/sizes failed");
         return -1;
     }
@@ -847,34 +847,34 @@ int QSPIFBlockDevice::_sfdp_detect_page_size(uint8_t *basic_param_table_ptr, int
 
 int QSPIFBlockDevice::_sfdp_detect_erase_types_inst_and_size(uint8_t *basic_param_table_ptr,
                                                              int basic_param_table_size,
-                                                             sfdp_smtbl_info &smtbl)
+                                                             sfdp_smptbl_info &smptbl)
 {
     uint8_t bitfield = 0x01;
 
     // Erase 4K Inst is taken either from param table legacy 4K erase or superseded by erase Instruction for type of size 4K
     if (basic_param_table_size > QSPIF_BASIC_PARAM_TABLE_ERASE_TYPE_1_SIZE_BYTE) {
         // Loop Erase Types 1-4
         for (int i_ind = 0; i_ind < 4; i_ind++) {
-            smtbl.erase_type_inst_arr[i_ind] = QSPI_NO_INST; // Default for unsupported type
-            smtbl.erase_type_size_arr[i_ind] = 1
+            smptbl.erase_type_inst_arr[i_ind] = QSPI_NO_INST; // Default for unsupported type
+            smptbl.erase_type_size_arr[i_ind] = 1
                                                << basic_param_table_ptr[QSPIF_BASIC_PARAM_TABLE_ERASE_TYPE_1_SIZE_BYTE + 2 * i_ind]; // Size is 2^N where N is the table value
-            tr_debug("Erase Type(A) %d - Inst: 0x%xh, Size: %d", (i_ind + 1), smtbl.erase_type_inst_arr[i_ind],
-                     smtbl.erase_type_size_arr[i_ind]);
-            if (smtbl.erase_type_size_arr[i_ind] > 1) {
+            tr_debug("Erase Type(A) %d - Inst: 0x%xh, Size: %d", (i_ind + 1), smptbl.erase_type_inst_arr[i_ind],
+                     smptbl.erase_type_size_arr[i_ind]);
+            if (smptbl.erase_type_size_arr[i_ind] > 1) {
                 // if size==1 type is not supported
-                smtbl.erase_type_inst_arr[i_ind] = basic_param_table_ptr[QSPIF_BASIC_PARAM_TABLE_ERASE_TYPE_1_BYTE
+                smptbl.erase_type_inst_arr[i_ind] = basic_param_table_ptr[QSPIF_BASIC_PARAM_TABLE_ERASE_TYPE_1_BYTE
                                                                          + 2 * i_ind];
 
-                if ((smtbl.erase_type_size_arr[i_ind] < smtbl.regions_min_common_erase_size)
-                        || (smtbl.regions_min_common_erase_size == 0)) {
+                if ((smptbl.erase_type_size_arr[i_ind] < smptbl.regions_min_common_erase_size)
+                        || (smptbl.regions_min_common_erase_size == 0)) {
                     //Set default minimal common erase for signal region
-                    smtbl.regions_min_common_erase_size = smtbl.erase_type_size_arr[i_ind];
+                    smptbl.regions_min_common_erase_size = smptbl.erase_type_size_arr[i_ind];
                 }
-                smtbl.region_erase_types_bitfld[0] |= bitfield; // If there's no region map, set region "0" types bitfield as default
+                smptbl.region_erase_types_bitfld[0] |= bitfield; // If there's no region map, set region "0" types bitfield as default
             }
 
-            tr_debug("Erase Type %d - Inst: 0x%xh, Size: %d", (i_ind + 1), smtbl.erase_type_inst_arr[i_ind],
-                     smtbl.erase_type_size_arr[i_ind]);
+            tr_debug("Erase Type %d - Inst: 0x%xh, Size: %d", (i_ind + 1), smptbl.erase_type_inst_arr[i_ind],
+                     smptbl.erase_type_size_arr[i_ind]);
             bitfield = bitfield << 1;
         }
     } else {
@@ -1320,20 +1320,20 @@ bool QSPIFBlockDevice::_is_mem_ready()
 /*********************************************/
 /************* Utility Functions *************/
 /*********************************************/
-int QSPIFBlockDevice::_utils_find_addr_region(bd_size_t offset, sfdp_smtbl_info &smtbl)
+int QSPIFBlockDevice::_utils_find_addr_region(bd_size_t offset, sfdp_smptbl_info &smptbl)
 {
     //Find the region to which the given offset belong to
-    if ((offset > _device_size_bytes) || (smtbl.region_cnt == 0)) {
+    if ((offset > _device_size_bytes) || (smptbl.region_cnt == 0)) {
         return -1;
     }
 
-    if (smtbl.region_cnt == 1) {
+    if (smptbl.region_cnt == 1) {
         return 0;
     }
 
-    for (int i_ind = smtbl.region_cnt - 2; i_ind >= 0; i_ind--) {
+    for (int i_ind = smptbl.region_cnt - 2; i_ind >= 0; i_ind--) {
 
-        if (offset > smtbl.region_high_boundary[i_ind]) {
+        if (offset > smptbl.region_high_boundary[i_ind]) {
             return (i_ind + 1);
         }
     }
@@ -1345,7 +1345,7 @@ int QSPIFBlockDevice::_utils_iterate_next_largest_erase_type(uint8_t &bitfield,
                                                              int size,
                                                              int offset,
                                                              int region,
-                                                             sfdp_smtbl_info &smtbl)
+                                                             sfdp_smptbl_info &smptbl)
 {
     // Iterate on all supported Erase Types of the Region to which the offset belong to.
     // Iterates from highest type to lowest
@@ -1355,9 +1355,9 @@ int QSPIFBlockDevice::_utils_iterate_next_largest_erase_type(uint8_t &bitfield,
     for (i_ind = 3; i_ind >= 0; i_ind--) {
         if (bitfield & type_mask) {
             largest_erase_type = i_ind;
-            if ((size > (int)(smtbl.erase_type_size_arr[largest_erase_type])) &&
-                    ((_sfdp_info.smtbl.region_high_boundary[region] - offset)
-                     > (int)(smtbl.erase_type_size_arr[largest_erase_type]))) {
+            if ((size > (int)(smptbl.erase_type_size_arr[largest_erase_type])) &&
+                    ((_sfdp_info.smptbl.region_high_boundary[region] - offset)
+                     > (int)(smptbl.erase_type_size_arr[largest_erase_type]))) {
                 break;
             } else {
                 bitfield &= ~type_mask;

components/storage/blockdevice/COMPONENT_QSPIF/QSPIFBlockDevice.h

@@ -338,7 +338,7 @@ class QSPIFBlockDevice : public mbed::BlockDevice {
     // Detect all supported erase types
     int _sfdp_detect_erase_types_inst_and_size(uint8_t *basic_param_table_ptr,
                                                int basic_param_table_size,
-                                               mbed::sfdp_smtbl_info &smtbl);
+                                               mbed::sfdp_smptbl_info &smptbl);
 
     // Detect 4-byte addressing mode and enable it if supported
     int _sfdp_detect_and_enable_4byte_addressing(uint8_t *basic_param_table_ptr, int basic_param_table_size);
@@ -350,15 +350,15 @@ class QSPIFBlockDevice : public mbed::BlockDevice {
     /* Utilities Functions */
     /***********************/
     // Find the region to which the given offset belong to
-    int _utils_find_addr_region(mbed::bd_size_t offset, mbed::sfdp_smtbl_info &smtbl);
+    int _utils_find_addr_region(mbed::bd_size_t offset, mbed::sfdp_smptbl_info &smptbl);
 
     // Iterate on all supported Erase Types of the Region to which the offset belong to.
     // Iterates from highest type to lowest
     int _utils_iterate_next_largest_erase_type(uint8_t &bitfield,
                                                int size,
                                                int offset,
                                                int region,
-                                               mbed::sfdp_smtbl_info &smtbl);
+                                               mbed::sfdp_smptbl_info &smptbl);
 
 private:
     enum qspif_clear_protection_method_t {