X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;ds=sidebyside;f=bertos%2Fcpu%2Fcortex-m3%2Fdrv%2Fmt29f_sam3.c;h=73faca1d1d418f13ef4c1db86317d99341f2231f;hb=f27e89243740eda77ee5a845e0b7a38f6964f9e2;hp=130b251eaacf170e9b12d61129f4d6fd8ad8b27a;hpb=fd68545ee6d05fd6bdb183127b3444a1c87c65f9;p=bertos.git diff --git a/bertos/cpu/cortex-m3/drv/mt29f_sam3.c b/bertos/cpu/cortex-m3/drv/mt29f_sam3.c index 130b251e..73faca1d 100644 --- a/bertos/cpu/cortex-m3/drv/mt29f_sam3.c +++ b/bertos/cpu/cortex-m3/drv/mt29f_sam3.c @@ -86,6 +86,13 @@ // Get chip select mask for command register #define MT29F_CSID(chip) (((chip)->chip_select << NFC_CMD_CSID_SHIFT) & NFC_CMD_CSID_MASK) +// Get block from page +#define PAGE(blk) ((blk) * MT29F_PAGES_PER_BLOCK) + +// Page from block and page in block +#define BLOCK(page) ((uint16_t)((page) / MT29F_PAGES_PER_BLOCK)) +#define PAGE_IN_BLOCK(page) ((uint16_t)((page) % MT29F_PAGES_PER_BLOCK)) + /* * Remap info written in the first page of each block @@ -236,7 +243,14 @@ int mt29f_blockErase(Mt29f *chip, uint16_t block) uint32_t cycle0; uint32_t cycle1234; - getAddrCycles(block * MT29F_PAGES_PER_BLOCK, 0, &cycle0, &cycle1234); + uint16_t remapped_block = chip->block_map[block]; + if (block != remapped_block) + { + LOG_INFO("mt29f_blockErase: remapped block: blk %d->%d\n", block, remapped_block); + block = remapped_block; + } + + getAddrCycles(PAGE(block), 0, &cycle0, &cycle1234); sendCommand(MT29F_CSID(chip) | NFC_CMD_NFCCMD | NFC_CMD_ACYCLE_THREE | NFC_CMD_VCMD2 | @@ -332,16 +346,23 @@ static bool mt29f_readPage(Mt29f *chip, uint32_t page, uint16_t offset) * Read page data and ECC, checking for errors. * TODO: fix errors with ECC when possible. */ -bool mt29f_read(Mt29f *chip, uint32_t page, void *buf, uint16_t size) +static bool mt29f_read(Mt29f *chip, uint32_t page, void *buf, uint16_t size) { - ASSERT(size <= MT29F_DATA_SIZE); + uint32_t remapped_page = PAGE(chip->block_map[BLOCK(page)]) + PAGE_IN_BLOCK(page); + + if (page != remapped_page) + { + LOG_INFO("mt29f_read: remapped block: blk %d->%d, pg %ld->%ld\n", + BLOCK(page), chip->block_map[BLOCK(page)], page, remapped_page); + page = remapped_page; + } if (!mt29f_readPage(chip, page, 0)) return false; memcpy(buf, (void *)NFC_SRAM_BASE_ADDR, size); - return checkEcc(); + return checkEcc(chip); } @@ -361,7 +382,7 @@ static bool mt29f_writePage(Mt29f *chip, uint32_t page, uint16_t offset) uint32_t cycle0; uint32_t cycle1234; - LOG_INFO("mt29f_writePage: page 0x%lx off 0x%x\n", page, offset); + //LOG_INFO("mt29f_writePage: page 0x%lx off 0x%x\n", page, offset); getAddrCycles(page, offset, &cycle0, &cycle1234); @@ -411,18 +432,18 @@ static bool mt29f_writePageData(Mt29f *chip, uint32_t page, const void *buf, uin /* * Write the spare area in a page: ECC and remap block index. + * \param page the page to be written + * \parma original_page if different from page, it's the page that's being remapped * * ECC data are extracted from ECC_PRx registers and written * in the page's spare area. * For 2048 bytes pages and 1 ECC word each 256 bytes, * 24 bytes of ECC data are stored. */ -static bool mt29f_writePageSpare(Mt29f *chip, uint32_t page) +static bool mt29f_writePageSpare(Mt29f *chip, uint32_t page, uint32_t original_page) { int i; uint32_t *buf = (uint32_t *)NFC_SRAM_BASE_ADDR; - uint16_t blk = page / MT29F_PAGES_PER_BLOCK; - uint16_t page_in_blk = page % MT29F_PAGES_PER_BLOCK; struct RemapInfo *remap_info = (struct RemapInfo *)(NFC_SRAM_BASE_ADDR + MT29F_REMAP_TAG_OFFSET); memset((void *)NFC_SRAM_BASE_ADDR, 0xff, MT29F_SPARE_SIZE); @@ -430,35 +451,25 @@ static bool mt29f_writePageSpare(Mt29f *chip, uint32_t page) for (i = 0; i < MT29F_ECC_NWORDS; i++) buf[i] = *((reg32_t *)(SMC_BASE + SMC_ECC_PR0_OFF) + i); - // Check for remapped block - if (chip->block_map[blk] != blk) - page = chip->block_map[blk] * MT29F_PAGES_PER_BLOCK + page_in_blk; - // Write remap tag remap_info->tag = MT29F_REMAP_TAG; - remap_info->mapped_blk = blk; + remap_info->mapped_blk = BLOCK(original_page); return mt29f_writePage(chip, page, MT29F_DATA_SIZE); } -bool mt29f_write(Mt29f *chip, uint32_t page, const void *buf, uint16_t size) -{ - return - mt29f_writePageData(chip, page, buf, size) && - mt29f_writePageSpare(chip, page); -} - - -int mt29f_error(Mt29f *chip) +static bool mt29f_write(Mt29f *chip, uint32_t page, const void *buf, uint16_t size) { - return chip->status; -} + uint32_t remapped_page = PAGE(chip->block_map[BLOCK(page)]) + PAGE_IN_BLOCK(page); + if (page != remapped_page) + LOG_INFO("mt29f_write: remapped block: blk %d->%d, pg %ld->%ld\n", + BLOCK(page), chip->block_map[BLOCK(page)], page, remapped_page); -void mt29f_clearError(Mt29f *chip) -{ - chip->status = 0; + return + mt29f_writePageData(chip, remapped_page, buf, size) && + mt29f_writePageSpare(chip, remapped_page, page); } @@ -473,8 +484,8 @@ static bool blockIsGood(Mt29f *chip, uint16_t blk) bool good; // Check first byte in spare area of first page in block - mt29f_readPage(chip, blk * MT29F_PAGES_PER_BLOCK, MT29F_DATA_SIZE); - good = *first_byte == 0xFF; + mt29f_readPage(chip, PAGE(blk), MT29F_DATA_SIZE); + good = *first_byte != 0; if (!good) LOG_INFO("mt29f: bad block %d\n", blk); @@ -491,7 +502,7 @@ static int getBadBlockFromRemapBlock(Mt29f *chip, uint16_t dest_blk) { struct RemapInfo *remap_info = (struct RemapInfo *)NFC_SRAM_BASE_ADDR; - if (!mt29f_readPage(chip, dest_blk * MT29F_PAGES_PER_BLOCK, MT29F_DATA_SIZE + MT29F_REMAP_TAG_OFFSET)) + if (!mt29f_readPage(chip, PAGE(dest_blk), MT29F_DATA_SIZE + MT29F_REMAP_TAG_OFFSET)) return -1; if (remap_info->tag == MT29F_REMAP_TAG) @@ -511,13 +522,13 @@ static bool setMapping(Mt29f *chip, uint32_t src_blk, uint32_t dest_blk) LOG_INFO("mt29f, setMapping(): src=%ld dst=%ld\n", src_blk, dest_blk); - if (!mt29f_readPage(chip, dest_blk * MT29F_PAGES_PER_BLOCK, MT29F_DATA_SIZE + MT29F_REMAP_TAG_OFFSET)) + if (!mt29f_readPage(chip, PAGE(dest_blk), MT29F_DATA_SIZE + MT29F_REMAP_TAG_OFFSET)) return false; remap_info->tag = MT29F_REMAP_TAG; remap_info->mapped_blk = src_blk; - return mt29f_writePage(chip, dest_blk * MT29F_PAGES_PER_BLOCK, MT29F_DATA_SIZE + MT29F_REMAP_TAG_OFFSET); + return mt29f_writePage(chip, PAGE(dest_blk), MT29F_DATA_SIZE + MT29F_REMAP_TAG_OFFSET); } @@ -559,10 +570,10 @@ static bool chipIsMarked(Mt29f *chip) */ static void initBlockMap(Mt29f *chip) { - unsigned b, last; + int b, last; // Default is for each block to not be remapped - for (b = 0; b < MT29F_NUM_USER_BLOCKS; b++) + for (b = 0; b < MT29F_NUM_BLOCKS; b++) chip->block_map[b] = b; chip->remap_start = MT29F_NUM_USER_BLOCKS; @@ -573,15 +584,12 @@ static void initBlockMap(Mt29f *chip) // Scan for assigned blocks in remap area for (b = last = MT29F_NUM_USER_BLOCKS; b < MT29F_NUM_BLOCKS; b++) { - if (blockIsGood(chip, b)) + int remapped_blk = getBadBlockFromRemapBlock(chip, b); + if (remapped_blk != -1 && remapped_blk != b) { - int remapped_blk = getBadBlockFromRemapBlock(chip, b); - if (remapped_blk != -1 && remapped_blk != MT29F_NULL_REMAP) - { - LOG_INFO("mt29f: found remapped block %d->%d\n", remapped_blk, b); - chip->block_map[remapped_blk] = b; - last = b + 1; - } + LOG_INFO("mt29f: found remapped block %d->%d\n", remapped_blk, b); + chip->block_map[remapped_blk] = b; + last = b + 1; } } chip->remap_start = last; @@ -609,7 +617,7 @@ static void initBlockMap(Mt29f *chip) */ if (!remapped_anything) { - setMapping(chip, MT29F_NULL_REMAP, MT29F_NUM_USER_BLOCKS); + setMapping(chip, MT29F_NUM_USER_BLOCKS, MT29F_NUM_USER_BLOCKS); LOG_INFO("mt29f: no bad block founds, marked NAND\n"); } } @@ -619,18 +627,21 @@ static void initBlockMap(Mt29f *chip) #ifdef _DEBUG /* - * Erase all blocks. + * Reset bad blocks map and erase all blocks. * DON'T USE on production chips: this function will try to erase * factory marked bad blocks too. */ static void mt29f_wipe(Mt29f *chip) { int b; + for (b = 0; b < MT29F_NUM_BLOCKS; b++) { LOG_INFO("mt29f: erasing block %d\n", b); + chip->block_map[b] = b; mt29f_blockErase(chip, b); } + chip->remap_start = MT29F_NUM_USER_BLOCKS; } /* @@ -649,9 +660,9 @@ static void mt29f_ruinSomeBlocks(Mt29f *chip) LOG_INFO("mt29f: erasing block %d\n", bads[i]); mt29f_blockErase(chip, bads[i]); - LOG_INFO("mt29f: marking page %d as bad\n", bads[i] * MT29F_PAGES_PER_BLOCK); + LOG_INFO("mt29f: marking page %d as bad\n", PAGE(bads[i])); memset((void *)NFC_SRAM_BASE_ADDR, 0, MT29F_SPARE_SIZE); - mt29f_writePage(chip, bads[i] * MT29F_PAGES_PER_BLOCK, MT29F_DATA_SIZE); + mt29f_writePage(chip, PAGE(bads[i]), MT29F_DATA_SIZE); } } @@ -728,12 +739,16 @@ static void initSmc(void) } -bool mt29f_init(Mt29f *chip, struct Heap *heap, uint8_t chip_select) +static bool commonInit(Mt29f *chip, struct Heap *heap, unsigned chip_select) { memset(chip, 0, sizeof(Mt29f)); + DB(chip->fd.priv.type = KBT_NAND); + chip->fd.blk_size = MT29F_BLOCK_SIZE; + chip->fd.blk_cnt = MT29F_NUM_USER_BLOCKS; + chip->chip_select = chip_select; - chip->block_map = heap_allocmem(heap, MT29F_NUM_USER_BLOCKS * sizeof(*chip->block_map)); + chip->block_map = heap_allocmem(heap, MT29F_NUM_BLOCKS * sizeof(*chip->block_map)); if (!chip->block_map) { LOG_ERR("mt29f: error allocating block map\n"); @@ -748,3 +763,122 @@ bool mt29f_init(Mt29f *chip, struct Heap *heap, uint8_t chip_select) return true; } + +/**************** Kblock interface ****************/ + + +static size_t mt29f_writeDirect(struct KBlock *kblk, block_idx_t idx, const void *buf, size_t offset, size_t size) +{ + ASSERT(offset <= MT29F_BLOCK_SIZE); + ASSERT(offset % MT29F_DATA_SIZE == 0); + ASSERT(size <= MT29F_BLOCK_SIZE); + ASSERT(size % MT29F_DATA_SIZE == 0); + + LOG_INFO("mt29f_writeDirect: blk=%ld\n", idx); + + mt29f_blockErase(MT29F_CAST(kblk), idx); + + while (offset < size) + { + uint32_t page = PAGE(idx) + (offset / MT29F_DATA_SIZE); + + if (!mt29f_write(MT29F_CAST(kblk), page, buf, MT29F_DATA_SIZE)) + break; + + offset += MT29F_DATA_SIZE; + buf = (const char *)buf + MT29F_DATA_SIZE; + } + + return offset; +} + + +static size_t mt29f_readDirect(struct KBlock *kblk, block_idx_t idx, void *buf, size_t offset, size_t size) +{ + ASSERT(offset <= MT29F_BLOCK_SIZE); + ASSERT(offset % MT29F_DATA_SIZE == 0); + ASSERT(size <= MT29F_BLOCK_SIZE); + ASSERT(size % MT29F_DATA_SIZE == 0); + + LOG_INFO("mt29f_readDirect: blk=%ld\n", idx); + + while (offset < size) + { + uint32_t page = PAGE(idx) + (offset / MT29F_DATA_SIZE); + + if (!mt29f_read(MT29F_CAST(kblk), page, buf, MT29F_DATA_SIZE)) + break; + + offset += MT29F_DATA_SIZE; + buf = (char *)buf + MT29F_DATA_SIZE; + } + + return offset; +} + + +static int mt29f_error(struct KBlock *kblk) +{ + Mt29f *chip = MT29F_CAST(kblk); + return chip->status; +} + + +static void mt29f_clearError(struct KBlock *kblk) +{ + Mt29f *chip = MT29F_CAST(kblk); + chip->status = 0; +} + + +static const KBlockVTable mt29f_buffered_vt = +{ + .readDirect = mt29f_readDirect, + .writeDirect = mt29f_writeDirect, + + .readBuf = kblock_swReadBuf, + .writeBuf = kblock_swWriteBuf, + .load = kblock_swLoad, + .store = kblock_swStore, + + .error = mt29f_error, + .clearerr = mt29f_clearError, +}; + +static const KBlockVTable mt29f_unbuffered_vt = +{ + .readDirect = mt29f_readDirect, + .writeDirect = mt29f_writeDirect, + + .error = mt29f_error, + .clearerr = mt29f_clearError, +}; + + +bool mt29f_init(Mt29f *chip, struct Heap *heap, unsigned chip_select) +{ + if (!commonInit(chip, heap, chip_select)) + return false; + + chip->fd.priv.vt = &mt29f_buffered_vt; + chip->fd.priv.flags |= KB_BUFFERED; + + chip->fd.priv.buf = heap_allocmem(heap, MT29F_BLOCK_SIZE); + if (!chip->fd.priv.buf) + { + LOG_ERR("mt29f: error allocating block buffer\n"); + return false; + } + + // Load the first block in the cache + return mt29f_readDirect(&chip->fd, 0, chip->fd.priv.buf, 0, MT29F_DATA_SIZE); +} + + +bool mt29f_initUnbuffered(Mt29f *chip, struct Heap *heap, unsigned chip_select) +{ + chip->fd.priv.vt = &mt29f_unbuffered_vt; + return commonInit(chip, heap, chip_select); +} + +