Diff: SOF_block.cpp

Revision:

2:e79a9cb05801

Parent:

0:7f4bc855cb46

--- a/SOF_block.cpp	Mon Jan 19 14:45:39 2015 +0000
+++ b/SOF_block.cpp	Wed Mar 25 05:27:59 2015 +0000
@@ -34,522 +34,489 @@
 
 #define RESERVED_BLOCK_INFO_SIZE sizeof(BlockInfo_t)
 
-typedef struct
-{
-	uint16_t for_storage;
-	uint16_t for_info;
+typedef struct {
+    uint16_t for_storage;
+    uint16_t for_info;
 } BlockChecksum_t;
 
-typedef struct
-{
-	BlockChecksum_t		csum; 
-	uint32_t			storage_len; 
+typedef struct {
+    BlockChecksum_t		csum;
+    uint32_t			storage_len;
 } BlockInfo_t;
 
-typedef struct
-{
-	uint32_t	begin_offset;
-	uint32_t	len;
-	uint16_t	storage_csum;
+typedef struct {
+    uint32_t	begin_offset;
+    uint32_t	len;
+    uint16_t	storage_csum;
 } StorageInfo_t;
 
 class SOF_BlockHandle
 {
 public:
-	SOF_BlockHandle()
-		: write_mode_(false)
-		, cur_pos_(0)
-		, hdev_(SOF_INVALID_HANDLE)
-		, storage_max_offset_(0)
-		, storage_begin_offset_(0)
-		, storage_end_offset_(0)
-	{
-	}
+    SOF_BlockHandle()
+        : write_mode_(false)
+        , cur_pos_(0)
+        , hdev_(SOF_INVALID_HANDLE)
+        , storage_max_offset_(0)
+        , storage_begin_offset_(0)
+        , storage_end_offset_(0) {
+    }
 
-	bool is_writable() const
-	{
-		return write_mode_;
-	}
+    bool is_writable() const {
+        return write_mode_;
+    }
 
-	uint32_t total_physical_block_size() const
-	{
-		return SOF_dev_info(hdev_)->sec_size;
-	}
+    uint32_t total_physical_block_size() const {
+        return SOF_dev_info(hdev_)->sec_size;
+    }
 
 public:
-	bool				write_mode_;
-	size_t				cur_pos_;
-	SOF_DevHandle_t		hdev_;
-	uint32_t			storage_max_offset_;
-	uint32_t			storage_begin_offset_;
-	uint32_t			storage_end_offset_;
+    bool				write_mode_;
+    size_t				cur_pos_;
+    SOF_DevHandle_t		hdev_;
+    uint32_t			storage_max_offset_;
+    uint32_t			storage_begin_offset_;
+    uint32_t			storage_end_offset_;
 };
 
 
 static bool get_block_info(const SOF_BlockHandle_t handle, size_t seq, BlockInfo_t *info, uint32_t *loc_offset)
 {
-	uint32_t check_pos = ((seq+1) * sizeof(BlockInfo_t));
-	uint32_t info_pos;
+    uint32_t check_pos = ((seq+1) * sizeof(BlockInfo_t));
+    uint32_t info_pos;
 
-	DASSERT(check_pos < handle->total_physical_block_size());
-	if (check_pos >= handle->total_physical_block_size())
-		return false;
+    DASSERT(check_pos < handle->total_physical_block_size());
+    if (check_pos >= handle->total_physical_block_size())
+        return false;
 
-	*loc_offset = info_pos = handle->total_physical_block_size() - check_pos;
+    *loc_offset = info_pos = handle->total_physical_block_size() - check_pos;
 
-	// checksum in the first word
-	*((uint32_t*)&info->csum) = SOF_dev_read_word(handle->hdev_, info_pos);
-	// storage len in the next word
-	info->storage_len = SOF_dev_read_word(handle->hdev_, info_pos + 4);
+    // checksum in the first word
+    *((uint32_t*)&info->csum) = SOF_dev_read_word(handle->hdev_, info_pos);
+    // storage len in the next word
+    info->storage_len = SOF_dev_read_word(handle->hdev_, info_pos + 4);
 
-	return true;
+    return true;
 }
 
 static bool is_empty_block_info(BlockInfo_t *info)
 {
-	uint8_t *p = (uint8_t*)info;
+    uint8_t *p = (uint8_t*)info;
 
-	for (size_t i = 0; i < sizeof(BlockInfo_t); ++i)
-		if (p[i] != SOF_ERASED_BYTE_VALUE)
-			return false;
+    for (size_t i = 0; i < sizeof(BlockInfo_t); ++i)
+        if (p[i] != SOF_ERASED_BYTE_VALUE)
+            return false;
 
-	return true;
+    return true;
 }
 
 static bool is_valid_block_info(BlockInfo_t *info)
 {
-	uint16_t csum = checksum((uint8_t*)&info->storage_len, 4);
+    uint16_t csum = checksum((uint8_t*)&info->storage_len, 4);
 
-	if (SYNC_MARK_BYTE_IN_LEN != (info->storage_len >> 24))
-	{
-		EPRINTF("no sync mark in storage_len=%#x"DCRLF,info->storage_len);
-		return false;
-	}
+    if (SYNC_MARK_BYTE_IN_LEN != (info->storage_len >> 24)) {
+        EPRINTF("no sync mark in storage_len=%#x"DCRLF,info->storage_len);
+        return false;
+    }
 
-	if (csum != info->csum.for_info)
-	{
-		EPRINTF("CSUM mismatch %#x %#x"DCRLF,csum, info->csum.for_info);
-		return false;
-	}
+    if (csum != info->csum.for_info) {
+        EPRINTF("CSUM mismatch %#x %#x"DCRLF,csum, info->csum.for_info);
+        return false;
+    }
 
-	return true;
+    return true;
 }
 
 static bool get_empty_info_location(const SOF_BlockHandle_t handle, uint32_t *loc_offset)
 {
-	BlockInfo_t info;
-	uint32_t pos;
+    BlockInfo_t info;
+    uint32_t pos;
 
-	for (size_t seq = 0; get_block_info(handle, seq, &info, &pos); ++seq)
-	{
-		//DPRINTF("[%u] len=%#x pos=%u"DCRLF,seq, info.storage_len, pos);
-		if (is_empty_block_info(&info))
-		{
-			*loc_offset = pos;
-			return true;
-		}
-	}
+    for (size_t seq = 0; get_block_info(handle, seq, &info, &pos); ++seq) {
+        //DPRINTF("[%u] len=%#x pos=%u"DCRLF,seq, info.storage_len, pos);
+        if (is_empty_block_info(&info)) {
+            *loc_offset = pos;
+            return true;
+        }
+    }
 
-	return false;
+    return false;
 }
 
 static SOF_Error_t probe_active_storage_info(const SOF_BlockHandle_t handle, StorageInfo_t *storage_info)
 {
-	BlockInfo_t info, last_info;
-	uint32_t pos;
-	uint32_t storage_len_sum = 0;
+    BlockInfo_t info, last_info;
+    uint32_t pos;
+    uint32_t storage_len_sum = 0;
+
+    for (size_t seq = 0; get_block_info(handle, seq, &info, &pos); ++seq) {
+        if (is_empty_block_info(&info)) {
+            if (seq == 0)
+                return kSOF_ErrNoInfo;
+            break;
+        }
+        if (!is_valid_block_info(&info)) {
+            if (storage_info->begin_offset + storage_info->len == pos) {
+                DPRINTF("data is full: %u"DCRLF,storage_info->begin_offset + storage_info->len);
+                break;
+            }
 
-	for (size_t seq = 0; get_block_info(handle, seq, &info, &pos); ++seq)
-	{
-		if (is_empty_block_info(&info))
-		{
-			if (seq == 0)
-				return kSOF_ErrNoInfo;
-			break;
-		}
-		if (!is_valid_block_info(&info))
-		{
-			if (storage_info->begin_offset + storage_info->len == pos)
-			{
-				DPRINTF("data is full: %u"DCRLF,storage_info->begin_offset + storage_info->len);
-				break;
-			}
+            EPRINTF("invalid block at %u"DCRLF,pos);
+            return kSOF_ErrBadBlock;
+        }
+
+        storage_len_sum += info.storage_len & 0x00FFFFFF;
+        last_info = info;
+    }
 
-			EPRINTF("invalid block at %u"DCRLF,pos);
-			return kSOF_ErrBadBlock;
-		}
-
-		storage_len_sum += info.storage_len & 0x00FFFFFF;
-		last_info = info;
-	}
+    uint32_t storage_len = last_info.storage_len & 0x00FFFFFF;
 
-	uint32_t storage_len = last_info.storage_len & 0x00FFFFFF;
+    storage_info->begin_offset = storage_len_sum - storage_len;
+    storage_info->len = storage_len;
+    storage_info->storage_csum = last_info.csum.for_storage;
 
-	storage_info->begin_offset = storage_len_sum - storage_len;
-	storage_info->len = storage_len;
-	storage_info->storage_csum = last_info.csum.for_storage;
-
-	return kSOF_ErrNone;
+    return kSOF_ErrNone;
 }
 
 
 #if LOCAL_DEBUG
 static void dump_block(SOF_BlockHandle_t handle)
 {
-	DPRINTF("sector(%u)"DCRLF, SOF_dev_info(handle->hdev_)->sec_no);
-	DPRINTF("	offset               =%u"DCRLF, handle->cur_pos_);
-	DPRINTF("	writemode            =%d"DCRLF, handle->write_mode_);
-	DPRINTF("	storage_max_offset   =%u"DCRLF, handle->storage_max_offset_);
-	DPRINTF("	storage_begin_offset =%u"DCRLF, handle->storage_begin_offset_);
-	DPRINTF("	storage_end_offset   =%u"DCRLF, handle->storage_end_offset_);
-	DPRINTF("	free=%u total=%u"DCRLF,SOF_block_get_free_size(handle), handle->total_physical_block_size());
+    DPRINTF("sector(%u)"DCRLF, SOF_dev_info(handle->hdev_)->sec_no);
+    DPRINTF("	offset               =%u"DCRLF, handle->cur_pos_);
+    DPRINTF("	writemode            =%d"DCRLF, handle->write_mode_);
+    DPRINTF("	storage_max_offset   =%u"DCRLF, handle->storage_max_offset_);
+    DPRINTF("	storage_begin_offset =%u"DCRLF, handle->storage_begin_offset_);
+    DPRINTF("	storage_end_offset   =%u"DCRLF, handle->storage_end_offset_);
+    DPRINTF("	free=%u total=%u"DCRLF,SOF_block_get_free_size(handle), handle->total_physical_block_size());
 }
 #endif
 
 size_t SOF_block_get_free_size(SOF_BlockHandle_t handle)
 {
-	DASSERT(handle != NULL);
-	if (handle->storage_end_offset_ <= handle->storage_max_offset_-RESERVED_BLOCK_INFO_SIZE)
-		return (handle->storage_max_offset_- RESERVED_BLOCK_INFO_SIZE) - handle->storage_end_offset_;
-	else
-	{
-		return 0;
-	}
+    DASSERT(handle != NULL);
+    if (handle->storage_end_offset_ <= handle->storage_max_offset_-RESERVED_BLOCK_INFO_SIZE)
+        return (handle->storage_max_offset_- RESERVED_BLOCK_INFO_SIZE) - handle->storage_end_offset_;
+    else {
+        return 0;
+    }
 }
 
 uint32_t SOF_block_storage_size(SOF_BlockHandle_t handle)
 {
-	DASSERT(handle != NULL);
-	return handle->storage_end_offset_ - handle->storage_begin_offset_;
+    DASSERT(handle != NULL);
+    return handle->storage_end_offset_ - handle->storage_begin_offset_;
 }
 
 static uint16_t checksum(const uint8_t* data, int count)
 {
-	// Fletcher's checksum algorithm
-	uint16_t sum1 = 0;
-	uint16_t sum2 = 0;
-	int index;
+    // Fletcher's checksum algorithm
+    uint16_t sum1 = 0;
+    uint16_t sum2 = 0;
+    int index;
 
-	for( index = 0; index < count; ++index )
-	{
-		sum1 = (sum1 + data[index]) % 255;
-		sum2 = (sum2 + sum1) % 255;
-	}
+    for( index = 0; index < count; ++index ) {
+        sum1 = (sum1 + data[index]) % 255;
+        sum2 = (sum2 + sum1) % 255;
+    }
 
-	return (sum2 << 8) | sum1;
+    return (sum2 << 8) | sum1;
 }
 
 static uint16_t compute_storage_checksum(SOF_BlockHandle_t handle)
 {
-	uint8_t *addr = SOF_dev_get_hw_addr(handle->hdev_);
+    uint8_t *addr = SOF_dev_get_hw_addr(handle->hdev_);
 
-	return checksum(addr+handle->storage_begin_offset_, SOF_block_storage_size(handle));
+    return checksum(addr+handle->storage_begin_offset_, SOF_block_storage_size(handle));
 }
 
 static bool write_storage_info(SOF_BlockHandle_t handle)
 {
-	BlockInfo_t cs;
+    BlockInfo_t cs;
 
-	cs.storage_len = (SYNC_MARK_BYTE_IN_LEN << 24) | SOF_block_storage_size(handle);
-	cs.csum.for_info = checksum((uint8_t*)&cs.storage_len, 4);
-	cs.csum.for_storage = compute_storage_checksum(handle);
+    cs.storage_len = (SYNC_MARK_BYTE_IN_LEN << 24) | SOF_block_storage_size(handle);
+    cs.csum.for_info = checksum((uint8_t*)&cs.storage_len, 4);
+    cs.csum.for_storage = compute_storage_checksum(handle);
 
-	DPRINTF("write %#x at %#x"DCRLF,*((uint32_t*)&cs.csum), handle->storage_max_offset_);
-	if (SOF_dev_write_word(handle->hdev_, handle->storage_max_offset_, *((uint32_t*)&cs.csum)) < 0)
-		return false;
+    DPRINTF("write %#x at %#x"DCRLF,*((uint32_t*)&cs.csum), handle->storage_max_offset_);
+    if (SOF_dev_write_word(handle->hdev_, handle->storage_max_offset_, *((uint32_t*)&cs.csum)) < 0)
+        return false;
 
-	if (SOF_dev_write_word(handle->hdev_, handle->storage_max_offset_+4, *((uint32_t*)&cs.storage_len)) < 0)
-		return false;
-	
-	return true;
+    if (SOF_dev_write_word(handle->hdev_, handle->storage_max_offset_+4, *((uint32_t*)&cs.storage_len)) < 0)
+        return false;
+
+    return true;
 }
 
 static bool create_empty_storage(SOF_DevHandle_t hdev, uint8_t sector_index)
 {
-	SOF_BlockHandle handle_data;
+    SOF_BlockHandle handle_data;
+
+    handle_data.hdev_ = hdev;
+
+    uint32_t info_begin_offset;
 
-	handle_data.hdev_ = hdev;
-
-	uint32_t info_begin_offset;
+    if (!get_empty_info_location(&handle_data, &info_begin_offset)) {
+        EPRINTF("no info"DCRLF);
+        SOF_block_close(&handle_data);
+        return false;
+    }
 
-	if (!get_empty_info_location(&handle_data, &info_begin_offset))
-	{
-		EPRINTF("no info"DCRLF);
-		SOF_block_close(&handle_data);
-		return false;
-	}
+    handle_data.storage_max_offset_ = info_begin_offset;
+    handle_data.storage_begin_offset_ = 0;
+    handle_data.storage_end_offset_ = handle_data.storage_begin_offset_;
+    handle_data.cur_pos_ = handle_data.storage_begin_offset_;
 
-	handle_data.storage_max_offset_ = info_begin_offset;
-	handle_data.storage_begin_offset_ = 0;
-	handle_data.storage_end_offset_ = handle_data.storage_begin_offset_;
-	handle_data.cur_pos_ = handle_data.storage_begin_offset_;
+    DPRINTF("storage created: begin=%d end=%d free=%d"DCRLF,
+            handle_data.storage_begin_offset_, handle_data.storage_end_offset_, SOF_block_get_free_size(&handle_data));
 
-	DPRINTF("storage created: begin=%d end=%d free=%d"DCRLF,
-		handle_data.storage_begin_offset_, handle_data.storage_end_offset_, SOF_block_get_free_size(&handle_data));
+    write_storage_info(&handle_data);
 
-	write_storage_info(&handle_data);
-
-	return true;
+    return true;
 }
 
 
 bool SOF_block_format(uint8_t sector_index)
 {
-	if (!SOF_dev_is_valid_sector(sector_index))
-	{
-		DPRINTF("invalid sector_index=%d"DCRLF, sector_index);
-		return false;
-	}
+    if (!SOF_dev_is_valid_sector(sector_index)) {
+        DPRINTF("invalid sector_index=%d"DCRLF, sector_index);
+        return false;
+    }
 
-	SOF_DevHandle_t hdev = SOF_dev_open(sector_index);
+    SOF_DevHandle_t hdev = SOF_dev_open(sector_index);
 
-	if (hdev == SOF_INVALID_HANDLE)
-	{
-		DPRINTF("SOF_dev_open(%d) failed"DCRLF, sector_index);
-		return false;
-	}
+    if (hdev == SOF_INVALID_HANDLE) {
+        DPRINTF("SOF_dev_open(%d) failed"DCRLF, sector_index);
+        return false;
+    }
 
-	DPRINTF("Flash erase %d"DCRLF, sector_index);
-	SOF_dev_erase(hdev);
-	create_empty_storage(hdev, sector_index);
-	SOF_dev_close(hdev);
+    DPRINTF("Flash erase %d"DCRLF, sector_index);
+    SOF_dev_erase(hdev);
+    create_empty_storage(hdev, sector_index);
+    SOF_dev_close(hdev);
 
-	return true;
+    return true;
 }
 
 SOF_BlockHandle_t SOF_block_open_storage(uint8_t sector_index, SOF_Error_t *err)
 {
-	if (!SOF_dev_is_valid_sector(sector_index))
-	{
-		DPRINTF("invalid sector_index=%d"DCRLF, sector_index);
-		return false;
-	}
+    if (!SOF_dev_is_valid_sector(sector_index)) {
+        DPRINTF("invalid sector_index=%d"DCRLF, sector_index);
+        return false;
+    }
 
-	SOF_DevHandle_t hdev = SOF_dev_open(sector_index);
+    SOF_DevHandle_t hdev = SOF_dev_open(sector_index);
 
-	if (hdev == SOF_INVALID_HANDLE)
-	{
-		DPRINTF("SOF_dev_open(%d) failed"DCRLF, sector_index);
-		return false;
-	}
+    if (hdev == SOF_INVALID_HANDLE) {
+        DPRINTF("SOF_dev_open(%d) failed"DCRLF, sector_index);
+        return false;
+    }
 
-	SOF_BlockHandle_t handle = new SOF_BlockHandle();
+    SOF_BlockHandle_t handle = new SOF_BlockHandle();
 
-	handle->hdev_ = hdev;
+    handle->hdev_ = hdev;
 
-	StorageInfo_t storage_info;
+    StorageInfo_t storage_info;
 
-	if ((*err=probe_active_storage_info(handle, &storage_info)) != kSOF_ErrNone)
-	{
-		delete handle;
-		return NULL;
-	}
+    if ((*err=probe_active_storage_info(handle, &storage_info)) != kSOF_ErrNone) {
+        delete handle;
+        return NULL;
+    }
 
-	uint32_t info_begin_offset;
+    uint32_t info_begin_offset;
 
-	if (!get_empty_info_location(handle, &info_begin_offset))
-	{
-		*err = kSOF_ErrBadBlock;
-		delete handle;
-		return NULL;
-	}
+    if (!get_empty_info_location(handle, &info_begin_offset)) {
+        *err = kSOF_ErrBadBlock;
+        delete handle;
+        return NULL;
+    }
 
-	// set max offset that storage grows.
-	handle->storage_max_offset_ = info_begin_offset;
+    // set max offset that storage grows.
+    handle->storage_max_offset_ = info_begin_offset;
 
-	handle->storage_begin_offset_ = storage_info.begin_offset;
-	handle->storage_end_offset_ = storage_info.begin_offset + storage_info.len;
+    handle->storage_begin_offset_ = storage_info.begin_offset;
+    handle->storage_end_offset_ = storage_info.begin_offset + storage_info.len;
 
-	handle->cur_pos_ = handle->storage_begin_offset_;
+    handle->cur_pos_ = handle->storage_begin_offset_;
 
-	DPRINTF("open for read: begin=%d end=%d len=%d free=%d"DCRLF,
-		handle->storage_begin_offset_, handle->storage_end_offset_, storage_info.len,
-		SOF_block_get_free_size(handle));
-	if (compute_storage_checksum(handle) != storage_info.storage_csum)
-	{
-		EPRINTF("checksum error %#x != %#x"DCRLF, compute_storage_checksum(handle), storage_info.storage_csum);
-		*err = kSOF_ErrDataCurrupted;
-		delete handle;
-		return NULL;
-	}
+    DPRINTF("open for read: begin=%d end=%d len=%d free=%d"DCRLF,
+            handle->storage_begin_offset_, handle->storage_end_offset_, storage_info.len,
+            SOF_block_get_free_size(handle));
+    if (compute_storage_checksum(handle) != storage_info.storage_csum) {
+        EPRINTF("checksum error %#x != %#x"DCRLF, compute_storage_checksum(handle), storage_info.storage_csum);
+        *err = kSOF_ErrDataCurrupted;
+        delete handle;
+        return NULL;
+    }
 
-	DUMP_BLOCK(handle);
-	*err = kSOF_ErrNone;
+    DUMP_BLOCK(handle);
+    *err = kSOF_ErrNone;
 
-	return handle;
+    return handle;
 }
 
 SOF_BlockHandle_t SOF_block_create_storage(uint8_t sector_index, SOF_Error_t *err)
 {
-	if (!SOF_dev_is_valid_sector(sector_index))
-	{
-		DPRINTF("invalid sector_index=%d"DCRLF, sector_index);
-		return false;
-	}
+    if (!SOF_dev_is_valid_sector(sector_index)) {
+        DPRINTF("invalid sector_index=%d"DCRLF, sector_index);
+        return false;
+    }
 
-	SOF_DevHandle_t hdev = SOF_dev_open(sector_index);
+    SOF_DevHandle_t hdev = SOF_dev_open(sector_index);
 
-	if (hdev == SOF_INVALID_HANDLE)
-	{
-		DPRINTF("SOF_dev_open(%d) failed"DCRLF, sector_index);
-		return false;
-	}
+    if (hdev == SOF_INVALID_HANDLE) {
+        DPRINTF("SOF_dev_open(%d) failed"DCRLF, sector_index);
+        return false;
+    }
 
-	SOF_BlockHandle_t handle = new SOF_BlockHandle();
+    SOF_BlockHandle_t handle = new SOF_BlockHandle();
 
-	handle->hdev_ = hdev;
+    handle->hdev_ = hdev;
 
-	StorageInfo_t storage_info;
+    StorageInfo_t storage_info;
 
-	if ((*err=probe_active_storage_info(handle, &storage_info)) != kSOF_ErrNone)
-	{
-		delete handle;
-		return NULL;
-	}
+    if ((*err=probe_active_storage_info(handle, &storage_info)) != kSOF_ErrNone) {
+        delete handle;
+        return NULL;
+    }
 
-	uint32_t info_begin_offset;
+    uint32_t info_begin_offset;
 
-	if (!get_empty_info_location(handle, &info_begin_offset))
-	{
-		*err = kSOF_ErrBadBlock;
-		delete handle;
-		return NULL;
-	}
+    if (!get_empty_info_location(handle, &info_begin_offset)) {
+        *err = kSOF_ErrBadBlock;
+        delete handle;
+        return NULL;
+    }
 
-	// set max offset that storage grows.
-	handle->storage_max_offset_ = info_begin_offset;
+    // set max offset that storage grows.
+    handle->storage_max_offset_ = info_begin_offset;
 
-	// writing position is just after previous storage
-	handle->storage_begin_offset_ = storage_info.begin_offset + storage_info.len;
-	handle->storage_end_offset_ = handle->storage_begin_offset_;
+    // writing position is just after previous storage
+    handle->storage_begin_offset_ = storage_info.begin_offset + storage_info.len;
+    handle->storage_end_offset_ = handle->storage_begin_offset_;
 
-	handle->cur_pos_ = handle->storage_begin_offset_;
-	handle->write_mode_ = true;
-	DPRINTF("open for write: begin=%d end=%d free=%d"DCRLF,
-		handle->storage_begin_offset_, handle->storage_end_offset_, SOF_block_get_free_size(handle));
+    handle->cur_pos_ = handle->storage_begin_offset_;
+    handle->write_mode_ = true;
+    DPRINTF("open for write: begin=%d end=%d free=%d"DCRLF,
+            handle->storage_begin_offset_, handle->storage_end_offset_, SOF_block_get_free_size(handle));
 
-	DUMP_BLOCK(handle);
-	*err = kSOF_ErrNone;
+    DUMP_BLOCK(handle);
+    *err = kSOF_ErrNone;
 
-	return handle;
+    return handle;
 }
 
 bool SOF_block_close(SOF_BlockHandle_t handle)
 {
-	bool r = true;
+    bool r = true;
 
-	DASSERT(handle != NULL);
-	if (handle->write_mode_)
-		r = (bool)write_storage_info(handle);
-	SOF_dev_close(handle->hdev_);
-	delete handle;
+    DASSERT(handle != NULL);
+    if (handle->write_mode_)
+        r = (bool)write_storage_info(handle);
+    SOF_dev_close(handle->hdev_);
+    delete handle;
 
-	return r;
+    return r;
 }
 
 uint8_t *SOF_block_base_addr(SOF_BlockHandle_t handle)
 {
-	DASSERT(handle != NULL);
-	return SOF_dev_get_hw_addr(handle->hdev_) + handle->cur_pos_;
+    DASSERT(handle != NULL);
+    return SOF_dev_get_hw_addr(handle->hdev_) + handle->cur_pos_;
 }
 
 bool SOF_block_putc(SOF_BlockHandle_t handle, uint8_t c)
 {
-	DASSERT(handle != NULL);
-	DASSERT(handle->is_writable());
+    DASSERT(handle != NULL);
+    DASSERT(handle->is_writable());
 
-	if (SOF_block_get_free_size(handle) == 0)
-	{
-		DPRINTF("no free space"DCRLF);
-		DUMP_BLOCK(handle);
+    if (SOF_block_get_free_size(handle) == 0) {
+        DPRINTF("no free space"DCRLF);
+        DUMP_BLOCK(handle);
 
-		return false;
-	}
+        return false;
+    }
 
-	bool b = SOF_dev_write_byte(handle->hdev_, handle->cur_pos_, c) != -1;
-	if (b)
-	{
-		handle->cur_pos_++;
-		handle->storage_end_offset_++;
-	}
+    bool b = SOF_dev_write_byte(handle->hdev_, handle->cur_pos_, c) != -1;
+    if (b) {
+        handle->cur_pos_++;
+        handle->storage_end_offset_++;
+    }
 
-	return b;
+    return b;
 }
 
 size_t SOF_block_write(SOF_BlockHandle_t handle, const uint8_t *p, size_t p_size)
 {
-	size_t i;
+    size_t i;
 
-	for (i = 0; i < p_size; ++i)
-		if (SOF_block_putc(handle, *p++) != true)
-			return i;
+    for (i = 0; i < p_size; ++i)
+        if (SOF_block_putc(handle, *p++) != true)
+            return i;
 
-	return i;
+    return i;
 }
 
 bool SOF_block_getc(SOF_BlockHandle_t handle, uint8_t *c)
 {
-	DASSERT(handle != NULL);
-	DASSERT(handle->is_writable());
+    DASSERT(handle != NULL);
+    DASSERT(handle->is_writable());
+
+    if (handle->cur_pos_ >= handle->storage_end_offset_) {
+        DPRINTF("end of data\n"DCRLF);
+        DUMP_BLOCK(handle);
 
-	if (handle->cur_pos_ >= handle->storage_end_offset_)
-	{
-		DPRINTF("end of data\n"DCRLF);
-		DUMP_BLOCK(handle);
+        return false;
+    }
 
-		return false;
-	}
+    *c = SOF_dev_read_byte(handle->hdev_, handle->cur_pos_++);
 
-	*c = SOF_dev_read_byte(handle->hdev_, handle->cur_pos_++);
-
-	return true;
+    return true;
 }
 
 size_t SOF_block_read(SOF_BlockHandle_t handle, uint8_t *p, size_t p_size)
 {
-	size_t i;
+    size_t i;
 
-	for (i = 0; i < p_size; ++i)
-		if (!SOF_block_getc(handle, p++))
-			break;
+    for (i = 0; i < p_size; ++i)
+        if (!SOF_block_getc(handle, p++))
+            break;
 
-	return i;
+    return i;
 }
 
 SOF_Error_t SOF_block_get_statics(uint8_t sector_index, SOF_Statics_t *stat)
 {
-	if (!SOF_dev_is_valid_sector(sector_index))
-	{
-		DPRINTF("invalid sector_index=%d"DCRLF, sector_index);
-		return kSOF_ErrParam;
-	}
+    if (!SOF_dev_is_valid_sector(sector_index)) {
+        DPRINTF("invalid sector_index=%d"DCRLF, sector_index);
+        return kSOF_ErrParam;
+    }
 
-	SOF_Error_t err;
-	SOF_BlockHandle_t hblk = SOF_block_open_storage(sector_index, &err);
+    SOF_Error_t err;
+    SOF_BlockHandle_t hblk = SOF_block_open_storage(sector_index, &err);
 
-	if (hblk == NULL)
-	{
-		DPRINTF("SOF_block_open_storage(%d) failed"DCRLF, sector_index);
-		return err;
-	}
+    if (hblk == NULL) {
+        DPRINTF("SOF_block_open_storage(%d) failed"DCRLF, sector_index);
+        return err;
+    }
 
-	stat->data_addr = SOF_block_base_addr(hblk);
-	stat->data_size = SOF_block_storage_size(hblk);
-	stat->free_size = SOF_block_get_free_size(hblk);
+    stat->data_addr = SOF_block_base_addr(hblk);
+    stat->data_size = SOF_block_storage_size(hblk);
+    stat->free_size = SOF_block_get_free_size(hblk);
 
-	SOF_block_close(hblk);
+    SOF_block_close(hblk);
 
-	return kSOF_ErrNone;
+    return kSOF_ErrNone;
 }
 
 const SOF_SectorSpec_t *SOF_block_get_info(uint8_t sector_index)
 {
-	if (!SOF_dev_is_valid_sector(sector_index))
-	{
-		DPRINTF("invalid sector_index=%d"DCRLF, sector_index);
-		return NULL;
-	}
+    if (!SOF_dev_is_valid_sector(sector_index)) {
+        DPRINTF("invalid sector_index=%d"DCRLF, sector_index);
+        return NULL;
+    }
 
-	return SOF_dev_info_by_index(sector_index);
+    return SOF_dev_info_by_index(sector_index);
 }
 
+