| // Copyright 2019 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <lib/ftl-mtd/nand-volume-driver.h> |
| #include <stdio.h> |
| #include <zircon/assert.h> |
| |
| #include <functional> |
| #include <utility> |
| |
| namespace ftl_mtd { |
| |
| using namespace std::placeholders; |
| |
| zx_status_t NandVolumeDriver::Create(uint32_t block_offset, uint32_t max_bad_blocks, |
| std::unique_ptr<mtd::NandInterface> interface, |
| std::unique_ptr<NandVolumeDriver>* out) { |
| uint32_t block_count = interface->Size() / interface->BlockSize(); |
| if (block_offset >= block_count) { |
| fprintf(stderr, "Block offset must be less than block count of %u.\n", block_count); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| uint32_t usable_block_count = block_count - block_offset; |
| if (max_bad_blocks >= usable_block_count) { |
| fprintf(stderr, "Max bad blocks must be less than block count of %u.\n", usable_block_count); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| uint32_t page_multiplier = 1; |
| while (page_multiplier * interface->OobSize() < kMinimumOobSize) { |
| page_multiplier *= 2; |
| } |
| |
| *out = std::unique_ptr<NandVolumeDriver>( |
| new NandVolumeDriver(block_offset, max_bad_blocks, page_multiplier, std::move(interface))); |
| return ZX_OK; |
| } |
| |
| NandVolumeDriver::NandVolumeDriver(uint32_t block_offset, uint32_t max_bad_blocks, |
| uint32_t page_multiplier, |
| std::unique_ptr<mtd::NandInterface> interface) |
| : block_offset_(block_offset), |
| page_multiplier_(page_multiplier), |
| max_bad_blocks_(max_bad_blocks), |
| interface_(std::move(interface)) {} |
| |
| const char* NandVolumeDriver::Init() { return nullptr; } |
| |
| const char* NandVolumeDriver::Attach(const ftl::Volume* ftl_volume) { |
| ftl::VolumeOptions options = { |
| .num_blocks = (interface_->Size() - ByteOffset()) / interface_->BlockSize(), |
| // This should be 2%, but that is of the whole device, not just this partition. |
| .max_bad_blocks = max_bad_blocks_, |
| .block_size = interface_->BlockSize(), |
| .page_size = MappedPageSize(), |
| .eb_size = MappedOobSize(), |
| .flags = 0 // Same as FSF_DRVR_PAGES (current default). |
| }; |
| |
| return CreateNdmVolume(ftl_volume, options); |
| } |
| |
| bool NandVolumeDriver::Detach() { return RemoveNdmVolume(); } |
| |
| int NandVolumeDriver::NandWrite(uint32_t start_page, uint32_t page_count, const void* page_buffer, |
| const void* oob_buffer) { |
| uint32_t real_start_page; |
| uint32_t real_end_page; |
| if (GetPageIndices(start_page, page_count, &real_start_page, &real_end_page) != ZX_OK) { |
| return ftl::kNdmFatalError; |
| } |
| |
| const uint8_t* page_buffer_ptr = reinterpret_cast<const uint8_t*>(page_buffer); |
| const uint8_t* oob_buffer_ptr = reinterpret_cast<const uint8_t*>(oob_buffer); |
| |
| for (uint32_t page = real_start_page; page < real_end_page; page++) { |
| zx_status_t status = |
| interface_->WritePage(GetByteOffsetForPage(page), page_buffer_ptr, oob_buffer_ptr); |
| |
| // We checked the inputs before, so the interface should never return ZX_ERR_INVALID_ARGS. |
| ZX_ASSERT(status != ZX_ERR_INVALID_ARGS); |
| |
| if (status != ZX_OK) { |
| return ftl::kNdmError; |
| } |
| |
| page_buffer_ptr += interface_->PageSize(); |
| oob_buffer_ptr += interface_->OobSize(); |
| } |
| |
| return ftl::kNdmOk; |
| } |
| |
| int NandVolumeDriver::NandRead(uint32_t start_page, uint32_t page_count, void* page_buffer, |
| void* oob_buffer) { |
| uint32_t real_start_page; |
| uint32_t real_end_page; |
| if (GetPageIndices(start_page, page_count, &real_start_page, &real_end_page) != ZX_OK) { |
| return ftl::kNdmFatalError; |
| } |
| |
| uint8_t* page_buffer_ptr = reinterpret_cast<uint8_t*>(page_buffer); |
| uint8_t* oob_buffer_ptr = reinterpret_cast<uint8_t*>(oob_buffer); |
| |
| for (uint32_t page = real_start_page; page < real_end_page; page++) { |
| zx_status_t status = |
| ReadPageAndOob(GetByteOffsetForPage(page), page_buffer_ptr, oob_buffer_ptr); |
| |
| if (status != ZX_OK) { |
| return ftl::kNdmFatalError; |
| } |
| |
| if (page_buffer) { |
| page_buffer_ptr += interface_->PageSize(); |
| } |
| |
| if (oob_buffer) { |
| oob_buffer_ptr += interface_->OobSize(); |
| } |
| } |
| |
| return ftl::kNdmOk; |
| } |
| |
| int NandVolumeDriver::NandErase(uint32_t page_num) { |
| uint32_t real_start_page; |
| uint32_t real_end_page; |
| if (GetPageIndices(page_num, 1, &real_start_page, &real_end_page) != ZX_OK) { |
| return ftl::kNdmError; |
| } |
| |
| zx_status_t status = interface_->EraseBlock(GetBlockOffsetForPage(real_start_page)); |
| return status == ZX_OK ? ftl::kNdmOk : ftl::kNdmError; |
| } |
| |
| int NandVolumeDriver::IsBadBlock(uint32_t page_num) { |
| bool is_bad_block = false; |
| |
| uint32_t real_start_page; |
| uint32_t real_end_page; |
| if (GetPageIndices(page_num, 1, &real_start_page, &real_end_page) != ZX_OK) { |
| return ftl::kNdmError; |
| } |
| |
| zx_status_t status = |
| interface_->IsBadBlock(GetBlockOffsetForPage(real_start_page), &is_bad_block); |
| if (status != ZX_OK) { |
| return ftl::kNdmError; |
| } |
| |
| return is_bad_block ? ftl::kTrue : ftl::kFalse; |
| } |
| |
| bool NandVolumeDriver::IsEmptyPage(uint32_t page_num, const uint8_t* page_buffer, |
| const uint8_t* oob_buffer) { |
| return IsEmptyPageImpl(page_buffer, MappedPageSize(), oob_buffer, MappedOobSize()); |
| } |
| |
| zx_status_t NandVolumeDriver::ReadPageAndOob(uint32_t byte_offset, void* page_buffer, |
| void* oob_buffer) { |
| if (page_buffer) { |
| uint32_t actual; |
| zx_status_t read_page_status = interface_->ReadPage(byte_offset, page_buffer, &actual); |
| |
| if (read_page_status != ZX_OK) { |
| return read_page_status; |
| } |
| |
| if (actual != interface_->PageSize()) { |
| return ZX_ERR_IO_DATA_LOSS; |
| } |
| } |
| |
| if (oob_buffer) { |
| zx_status_t read_oob_status = interface_->ReadOob(byte_offset, oob_buffer); |
| if (read_oob_status != ZX_OK) { |
| return read_oob_status; |
| } |
| } |
| |
| return ZX_OK; |
| } |
| |
| zx_status_t NandVolumeDriver::GetPageIndices(uint32_t mapped_page, uint32_t mapped_page_count, |
| uint32_t* start_page, uint32_t* end_page) { |
| uint32_t start = ByteOffset() / interface_->PageSize() + page_multiplier_ * mapped_page; |
| uint32_t end = start + page_multiplier_ * mapped_page_count; |
| uint32_t last_page = interface_->Size() / interface_->PageSize(); |
| |
| if (start >= last_page || end > last_page) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| |
| *start_page = start; |
| *end_page = end; |
| return ZX_OK; |
| } |
| |
| uint32_t NandVolumeDriver::GetBlockOffsetForPage(uint32_t real_page) { |
| return GetByteOffsetForPage(real_page) / interface_->BlockSize() * interface_->BlockSize(); |
| } |
| |
| uint32_t NandVolumeDriver::GetByteOffsetForPage(uint32_t real_page) { |
| return real_page * interface_->PageSize(); |
| } |
| |
| uint32_t NandVolumeDriver::ByteOffset() { return block_offset_ * interface_->BlockSize(); } |
| |
| uint32_t NandVolumeDriver::MappedPageSize() { return page_multiplier_ * interface_->PageSize(); } |
| |
| uint32_t NandVolumeDriver::MappedOobSize() { return page_multiplier_ * interface_->OobSize(); } |
| |
| } // namespace ftl_mtd |