int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk, const u8 *buffer, struct yaffs_ext_tags *tags) { int result; int flash_chunk = nand_chunk - dev->chunk_offset; dev->n_page_writes++; if (tags) { tags->seq_number = dev->seq_number; tags->chunk_used = 1; yaffs_trace(YAFFS_TRACE_WRITE, "Writing chunk %d tags %d %d", nand_chunk, tags->obj_id, tags->chunk_id); } else { yaffs_trace(YAFFS_TRACE_ERROR, "Writing with no tags"); BUG(); return YAFFS_FAIL; } if (dev->param.write_chunk_tags_fn) result = dev->param.write_chunk_tags_fn(dev, flash_chunk, buffer, tags); else result = yaffs_tags_compat_wr(dev, flash_chunk, buffer, tags); yaffs_summary_add(dev, tags, nand_chunk); return result; }
int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk, const u8 * buffer, struct yaffs_ext_tags *tags) { dev->n_page_writes++; nand_chunk -= dev->chunk_offset; if (tags) { tags->seq_number = dev->seq_number; tags->chunk_used = 1; if (!yaffs_validate_tags(tags)) { yaffs_trace(YAFFS_TRACE_ERROR, "Writing uninitialised tags"); YBUG(); } yaffs_trace(YAFFS_TRACE_WRITE, "Writing chunk %d tags %d %d", nand_chunk, tags->obj_id, tags->chunk_id); } else { yaffs_trace(YAFFS_TRACE_ERROR, "Writing with no tags"); YBUG(); } if (dev->param.write_chunk_tags_fn) return dev->param.write_chunk_tags_fn(dev, nand_chunk, buffer, tags); else return yaffs_tags_compat_wr(dev, nand_chunk, buffer, tags); }
int yaffs_verify_mtd(struct mtd_info *mtd, int yaffs_version, int inband_tags, int tags_9bytes) { if (yaffs_version == 2) { if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE || mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) && !inband_tags) { yaffs_trace(YAFFS_TRACE_ALWAYS, "MTD device does not have the right page sizes" ); return -1; } } else { if (WRITE_SIZE(mtd) < YAFFS_BYTES_PER_CHUNK || mtd->oobsize != YAFFS_BYTES_PER_SPARE) { yaffs_trace(YAFFS_TRACE_ALWAYS, "MTD device does not support have the right page sizes" ); return -1; } if (tags_9bytes && mtd->oobavail < 9) { yaffs_trace(YAFFS_TRACE_ALWAYS, "MTD device does not support 9-byte tags"); return -1; } } return 0; }
static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev) { int i; int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks; yaffs_trace(YAFFS_TRACE_CHECKPOINT, "allocating checkpt block: erased %d reserved %d avail %d next %d ", dev->n_erased_blocks, dev->param.n_reserved_blocks, blocks_avail, dev->checkpt_next_block); if (dev->checkpt_next_block >= 0 && dev->checkpt_next_block <= dev->internal_end_block && blocks_avail > 0) { for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) { struct yaffs_block_info *bi = yaffs_get_block_info(dev, i); if (bi->block_state == YAFFS_BLOCK_STATE_EMPTY) { dev->checkpt_next_block = i + 1; dev->checkpt_cur_block = i; yaffs_trace(YAFFS_TRACE_CHECKPOINT, "allocating checkpt block %d", i); return; } } } yaffs_trace(YAFFS_TRACE_CHECKPOINT, "out of checkpt blocks"); dev->checkpt_next_block = -1; dev->checkpt_cur_block = -1; }
static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes) { struct yaffs_allocator *allocator = (struct yaffs_allocator *)dev->allocator; int i; struct yaffs_tnode *new_tnodes; u8 *mem; struct yaffs_tnode *curr; struct yaffs_tnode *next; struct yaffs_tnode_list *tnl; if (!allocator) { YBUG(); return YAFFS_FAIL; } if (n_tnodes < 1) return YAFFS_OK; new_tnodes = kmalloc(n_tnodes * dev->tnode_size, GFP_NOFS); mem = (u8 *) new_tnodes; if (!new_tnodes) { yaffs_trace(YAFFS_TRACE_ERROR, "yaffs: Could not allocate Tnodes"); return YAFFS_FAIL; } for (i = 0; i < n_tnodes - 1; i++) { curr = (struct yaffs_tnode *)&mem[i * dev->tnode_size]; next = (struct yaffs_tnode *)&mem[(i + 1) * dev->tnode_size]; curr->internal[0] = next; } curr = (struct yaffs_tnode *)&mem[(n_tnodes - 1) * dev->tnode_size]; curr->internal[0] = allocator->free_tnodes; allocator->free_tnodes = (struct yaffs_tnode *)mem; allocator->n_free_tnodes += n_tnodes; allocator->n_tnodes_created += n_tnodes; tnl = kmalloc(sizeof(struct yaffs_tnode_list), GFP_NOFS); if (!tnl) { yaffs_trace(YAFFS_TRACE_ERROR, "Could not add tnodes to management list"); return YAFFS_FAIL; } else { tnl->tnodes = new_tnodes; tnl->next = allocator->alloc_tnode_list; allocator->alloc_tnode_list = tnl; } yaffs_trace(YAFFS_TRACE_ALLOCATE,"Tnodes added"); return YAFFS_OK; }
static void yaffs2_checkpt_find_block(struct yaffs_dev *dev) { int i; struct yaffs_ext_tags tags; yaffs_trace(YAFFS_TRACE_CHECKPOINT, "find next checkpt block: start: blocks %d next %d", dev->blocks_in_checkpt, dev->checkpt_next_block); if (dev->blocks_in_checkpt < dev->checkpt_max_blocks) for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) { int chunk = i * dev->param.chunks_per_block; enum yaffs_block_state state; u32 seq; dev->param.query_block_fn(dev, apply_block_offset(dev, i), &state, &seq); if (state == YAFFS_BLOCK_STATE_DEAD) continue; dev->param.read_chunk_tags_fn(dev, apply_chunk_offset(dev, chunk), NULL, &tags); yaffs_trace(YAFFS_TRACE_CHECKPOINT, "find next checkpt block: search: block %d state %d oid %d seq %d eccr %d", i, (int) state, tags.obj_id, tags.seq_number, tags.ecc_result); if (tags.seq_number != YAFFS_SEQUENCE_CHECKPOINT_DATA) continue; /* Right kind of block */ dev->checkpt_next_block = tags.obj_id; dev->checkpt_cur_block = i; dev->checkpt_block_list[dev->blocks_in_checkpt] = i; dev->blocks_in_checkpt++; yaffs_trace(YAFFS_TRACE_CHECKPOINT, "found checkpt block %d", i); return; } yaffs_trace(YAFFS_TRACE_CHECKPOINT, "found no more checkpt blocks"); dev->checkpt_next_block = -1; dev->checkpt_cur_block = -1; }
static void yaffs_dump_packed_tags2_tags_only(const struct yaffs_packed_tags2_tags_only *ptt) { yaffs_trace(YAFFS_TRACE_MTD, "packed tags obj %d chunk %d byte %d seq %d", ptt->obj_id, ptt->chunk_id, ptt->n_bytes, ptt->seq_number); }
static int yflash2_EraseBlock(struct yaffs_dev *dev, int block_no) { int i; int h; CheckInit(); if(block_no < 0 || block_no >= filedisk.nBlocks) { yaffs_trace(YAFFS_TRACE_ALWAYS,"Attempt to erase non-existant block %d",block_no); return YAFFS_FAIL; } else { u8 pg[PAGE_SIZE]; int syz = PAGE_SIZE; int pos; memset(pg,0xff,syz); h = filedisk.handle[(block_no / ( BLOCKS_PER_HANDLE))]; lseek(h,((block_no % BLOCKS_PER_HANDLE) * dev->param.chunks_per_block) * PAGE_SIZE,SEEK_SET); for(i = 0; i < dev->param.chunks_per_block; i++) { write(h,pg,PAGE_SIZE); } pos = lseek(h, 0,SEEK_CUR); return YAFFS_OK; } }
static int yaffs_mtd_write(struct yaffs_dev *dev, int nand_chunk, const u8 *data, int data_len, const u8 *oob, int oob_len) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); loff_t addr; struct mtd_oob_ops ops; int retval; addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; memset(&ops, 0, sizeof(ops)); ops.mode = MTD_OPS_AUTO_OOB; ops.len = (data) ? data_len : 0; ops.ooblen = oob_len; ops.datbuf = (u8 *)data; ops.oobbuf = (u8 *)oob; #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 3, 0)) retval = mtd_write_oob(mtd, addr, &ops); #else retval = mtd->write_oob(mtd, addr, &ops); #endif if (retval) { yaffs_trace(YAFFS_TRACE_MTD, "write_oob failed, chunk %d, mtd error %d", nand_chunk, retval); } return retval ? YAFFS_FAIL : YAFFS_OK; }
static int yaffs_mtd_read(struct yaffs_dev *dev, int nand_chunk, u8 *data, int data_len, u8 *oob, int oob_len, enum yaffs_ecc_result *ecc_result) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); loff_t addr; struct mtd_oob_ops ops; int retval; addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; memset(&ops, 0, sizeof(ops)); ops.mode = MTD_OPS_AUTO_OOB; ops.len = (data) ? data_len : 0; ops.ooblen = oob_len; ops.datbuf = data; ops.oobbuf = oob; #if (MTD_VERSION_CODE < MTD_VERSION(2, 6, 20)) /* In MTD 2.6.18 to 2.6.19 nand_base.c:nand_do_read_oob() has a bug; * help it out with ops.len = ops.ooblen when ops.datbuf == NULL. */ ops.len = (ops.datbuf) ? ops.len : ops.ooblen; #endif /* Read page and oob using MTD. * Check status and determine ECC result. */ retval = mtd_read_oob(mtd, addr, &ops); if (retval) yaffs_trace(YAFFS_TRACE_MTD, "read_oob failed, chunk %d, mtd error %d", nand_chunk, retval); switch (retval) { case 0: /* no error */ if(ecc_result) *ecc_result = YAFFS_ECC_RESULT_NO_ERROR; break; case -EUCLEAN: /* MTD's ECC fixed the data */ if(ecc_result) *ecc_result = YAFFS_ECC_RESULT_FIXED; dev->n_ecc_fixed++; break; case -EBADMSG: default: /* MTD's ECC could not fix the data */ dev->n_ecc_unfixed++; if(ecc_result) *ecc_result = YAFFS_ECC_RESULT_UNFIXED; return YAFFS_FAIL; } return YAFFS_OK; }
int nandmtd2_query_block(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, u32 * seq_number) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int retval; yaffs_trace(YAFFS_TRACE_MTD, "nandmtd2_query_block %d", block_no); retval = mtd_block_isbad(mtd, block_no * dev->param.chunks_per_block * dev->param.total_bytes_per_chunk); if (retval) { yaffs_trace(YAFFS_TRACE_MTD, "block is bad"); *state = YAFFS_BLOCK_STATE_DEAD; *seq_number = 0; } else { struct yaffs_ext_tags t; nandmtd2_read_chunk_tags(dev, block_no * dev->param.chunks_per_block, NULL, &t); if (t.chunk_used) { *seq_number = t.seq_number; *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; } else { *seq_number = 0; *state = YAFFS_BLOCK_STATE_EMPTY; } /*if ecc unfixed, set the block empty. This block will be erased when allocate.*/ if(t.ecc_result == YAFFS_ECC_RESULT_UNFIXED) { printk("yaffsdebug : unfixed ecc error when scan block, seqnum:0x%x\n",t.seq_number); *seq_number = 0; *state = YAFFS_BLOCK_STATE_EMPTY; } } yaffs_trace(YAFFS_TRACE_MTD, "block is bad seq %d state %d", *seq_number, *state); if (retval == 0) return YAFFS_OK; else return YAFFS_FAIL; }
static void yaffs_dump_tags2(const struct yaffs_ext_tags *t) { yaffs_trace(YAFFS_TRACE_MTD, "ext.tags eccres %d blkbad %d chused %d obj %d chunk%d byte %d del %d ser %d seq %d", t->ecc_result, t->block_bad, t->chunk_used, t->obj_id, t->chunk_id, t->n_bytes, t->is_deleted, t->serial_number, t->seq_number); }
static int yaffs2_checkpt_space_ok(struct yaffs_dev *dev) { int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks; yaffs_trace(YAFFS_TRACE_CHECKPOINT, "checkpt blocks_avail = %d", blocks_avail); return (blocks_avail <= 0) ? 0 : 1; }
static int yaffs2_checkpt_flush_buffer(struct yaffs_dev *dev) { int chunk; int realigned_chunk; struct yaffs_ext_tags tags; if (dev->checkpt_cur_block < 0) { yaffs2_checkpt_find_erased_block(dev); dev->checkpt_cur_chunk = 0; } if (dev->checkpt_cur_block < 0) return 0; tags.is_deleted = 0; tags.obj_id = dev->checkpt_next_block; /* Hint to next place to look */ tags.chunk_id = dev->checkpt_page_seq + 1; tags.seq_number = YAFFS_SEQUENCE_CHECKPOINT_DATA; tags.n_bytes = dev->data_bytes_per_chunk; if (dev->checkpt_cur_chunk == 0) { /* First chunk we write for the block? Set block state to checkpoint */ struct yaffs_block_info *bi = yaffs_get_block_info(dev, dev->checkpt_cur_block); bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT; dev->blocks_in_checkpt++; } chunk = dev->checkpt_cur_block * dev->param.chunks_per_block + dev->checkpt_cur_chunk; yaffs_trace(YAFFS_TRACE_CHECKPOINT, "checkpoint wite buffer nand %d(%d:%d) objid %d chId %d", chunk, dev->checkpt_cur_block, dev->checkpt_cur_chunk, tags.obj_id, tags.chunk_id); realigned_chunk = chunk - dev->chunk_offset; dev->n_page_writes++; dev->param.write_chunk_tags_fn(dev, realigned_chunk, dev->checkpt_buffer, &tags); dev->checkpt_page_seq++; dev->checkpt_cur_chunk++; if (dev->checkpt_cur_chunk >= dev->param.chunks_per_block) { dev->checkpt_cur_chunk = 0; dev->checkpt_cur_block = -1; } memset(dev->checkpt_buffer, 0, dev->data_bytes_per_chunk); yaffs2_checkpt_init_chunk_hdr(dev); return 1; }
int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev) { /* Erase the checkpoint data */ yaffs_trace(YAFFS_TRACE_CHECKPOINT, "checkpoint invalidate of %d blocks", dev->blocks_in_checkpt); return yaffs_checkpt_erase(dev); }
void yaffs_verify_chunk_bit_id(struct yaffs_dev *dev, int blk, int chunk) { if (blk < dev->internal_start_block || blk > dev->internal_end_block || chunk < 0 || chunk >= dev->param.chunks_per_block) { yaffs_trace(YAFFS_TRACE_ERROR, "Chunk Id (%d:%d) invalid", blk, chunk); BUG(); } }
/* Write a chunk (page) of data to NAND. * * Caller always provides ExtendedTags data which are converted to a more * compact (packed) form for storage in NAND. A mini-ECC runs over the * contents of the tags meta-data; used to valid the tags when read. * * - Pack ExtendedTags to packed_tags1 form * - Compute mini-ECC for packed_tags1 * - Write data and packed tags to NAND. * * Note: Due to the use of the packed_tags1 meta-data which does not include * a full sequence number (as found in the larger packed_tags2 form) it is * necessary for Yaffs to re-write a chunk/page (just once) to mark it as * discarded and dirty. This is not ideal: newer NAND parts are supposed * to be written just once. When Yaffs performs this operation, this * function is called with a NULL data pointer -- calling MTD write_oob * without data is valid usage (2.6.17). * * Any underlying MTD error results in YAFFS_FAIL. * Returns YAFFS_OK or YAFFS_FAIL. */ int nandmtd1_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, const u8 *data, const struct yaffs_ext_tags *etags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int chunk_bytes = dev->data_bytes_per_chunk; loff_t addr = ((loff_t) nand_chunk) * chunk_bytes; struct mtd_oob_ops ops; struct yaffs_packed_tags1 pt1; int retval; /* we assume that packed_tags1 and struct yaffs_tags are compatible */ compile_time_assertion(sizeof(struct yaffs_packed_tags1) == 12); compile_time_assertion(sizeof(struct yaffs_tags) == 8); yaffs_pack_tags1(&pt1, etags); yaffs_calc_tags_ecc((struct yaffs_tags *)&pt1); /* When deleting a chunk, the upper layer provides only skeletal * etags, one with is_deleted set. However, we need to update the * tags, not erase them completely. So we use the NAND write property * that only zeroed-bits stick and set tag bytes to all-ones and * zero just the (not) deleted bit. */ if(dev->param.tags_9bytes) { ((u8 *) &pt1)[8] = 0xff; if (etags->is_deleted) { memset(&pt1, 0xff, 8); /* zero page_status byte to indicate deleted */ ((u8 *) &pt1)[8] = 0; } } else { if (etags->is_deleted) { memset(&pt1, 0xff, 8); /* clear delete status bit to indicate deleted */ pt1.deleted = 0; } } memset(&ops, 0, sizeof(ops)); ops.mode = MTD_OPS_AUTO_OOB; ops.len = (data) ? chunk_bytes : 0; ops.ooblen = dev->param.tags_9bytes ? 9 : 8; ops.datbuf = (u8 *) data; ops.oobbuf = (u8 *) &pt1; retval = mtd->write_oob(mtd, addr, &ops); if (retval) { yaffs_trace(YAFFS_TRACE_MTD, "write_oob failed, chunk %d, mtd error %d", nand_chunk, retval); } return retval ? YAFFS_FAIL : YAFFS_OK; }
/* Write a chunk (page) of data to NAND. * * Caller always provides ExtendedTags data which are converted to a more * compact (packed) form for storage in NAND. A mini-ECC runs over the * contents of the tags meta-data; used to valid the tags when read. * * - Pack ExtendedTags to PackedTags1 form * - Compute mini-ECC for PackedTags1 * - Write data and packed tags to NAND. * * Note: Due to the use of the PackedTags1 meta-data which does not include * a full sequence number (as found in the larger PackedTags2 form) it is * necessary for Yaffs to re-write a chunk/page (just once) to mark it as * discarded and dirty. This is not ideal: newer NAND parts are supposed * to be written just once. When Yaffs performs this operation, this * function is called with a NULL data pointer -- calling MTD write_oob * without data is valid usage (2.6.17). * * Any underlying MTD error results in YAFFS_FAIL. * Returns YAFFS_OK or YAFFS_FAIL. */ int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND, const __u8 * data, const yaffs_ExtendedTags * etags) { struct mtd_info * mtd = dev->genericDevice; int chunkBytes = dev->nDataBytesPerChunk; loff_t addr = ((loff_t)chunkInNAND) * chunkBytes; struct mtd_oob_ops ops; yaffs_PackedTags1 pt1; int retval; /* we assume that PackedTags1 and yaffs_Tags are compatible */ compile_time_assertion(sizeof(yaffs_PackedTags1) == 12); compile_time_assertion(sizeof(yaffs_Tags) == 8); dev->nPageWrites++; yaffs_PackTags1(&pt1, etags); yaffs_CalcTagsECC((yaffs_Tags *)&pt1); /* When deleting a chunk, the upper layer provides only skeletal * etags, one with chunkDeleted set. However, we need to update the * tags, not erase them completely. So we use the NAND write property * that only zeroed-bits stick and set tag bytes to all-ones and * zero just the (not) deleted bit. */ #ifndef CONFIG_YAFFS_9BYTE_TAGS if (etags->chunkDeleted) { memset(&pt1, 0xff, 8); /* clear delete status bit to indicate deleted */ pt1.deleted = 0; } #else ((__u8 *)&pt1)[8] = 0xff; if (etags->chunkDeleted) { memset(&pt1, 0xff, 8); /* zero pageStatus byte to indicate deleted */ ((__u8 *)&pt1)[8] = 0; } #endif memset(&ops, 0, sizeof(ops)); ops.mode = MTD_OOB_AUTO; ops.len = (data) ? chunkBytes : 0; ops.ooblen = YTAG1_SIZE; ops.datbuf = (__u8 *)data; ops.oobbuf = (__u8 *)&pt1; retval = mtd->write_oob(mtd, addr, &ops); if (retval) { yaffs_trace(YAFFS_TRACE_MTD, "write_oob failed, chunk %d, mtd error %d\n", chunkInNAND, retval); } return retval ? YAFFS_FAIL : YAFFS_OK; }
/* Mark a block bad. * * This is a persistant state. * Use of this function should be rare. * * Returns YAFFS_OK or YAFFS_FAIL. */ int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int blocksize = dev->param.chunks_per_block * dev->data_bytes_per_chunk; int retval; yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, "marking block %d bad", block_no); retval = mtd->block_markbad(mtd, (loff_t) blocksize * block_no); return (retval) ? YAFFS_FAIL : YAFFS_OK; }
static inline u8 *yaffs_block_bits(struct yaffs_dev *dev, int blk) { if (blk < dev->internal_start_block || blk > dev->internal_end_block) { yaffs_trace(YAFFS_TRACE_ERROR, "BlockBits block %d is not valid", blk); BUG(); } return dev->chunk_bits + (dev->chunk_bit_stride * (blk - dev->internal_start_block)); }
static int yaffs_mtd_check_bad(struct yaffs_dev *dev, int block_no) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int blocksize = dev->param.chunks_per_block * dev->param.total_bytes_per_chunk; int retval; yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, "checking block %d bad", block_no); retval = mtd_block_isbad(mtd, (loff_t) blocksize * block_no); return (retval) ? YAFFS_FAIL : YAFFS_OK; }
/* Mark a block bad. * * This is a persistant state. * Use of this function should be rare. * * Returns YAFFS_OK or YAFFS_FAIL. */ int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) { struct mtd_info * mtd = dev->genericDevice; int blocksize = dev->nChunksPerBlock * dev->nDataBytesPerChunk; int retval; yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, "marking block %d bad\n", blockNo); retval = mtd->block_markbad(mtd, (loff_t)blocksize * blockNo); return (retval) ? YAFFS_FAIL : YAFFS_OK; }
static int yaffs_tags_marshall_query_block(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, u32 *seq_number) { int retval; yaffs_trace(YAFFS_TRACE_MTD, "yaffs_tags_marshall_query_block %d", block_no); retval = dev->drv.drv_check_bad_fn(dev, block_no); if (retval== YAFFS_FAIL) { yaffs_trace(YAFFS_TRACE_MTD, "block is bad"); *state = YAFFS_BLOCK_STATE_DEAD; *seq_number = 0; } else { struct yaffs_ext_tags t; yaffs_tags_marshall_read(dev, block_no * dev->param.chunks_per_block, NULL, &t); if (t.chunk_used) { *seq_number = t.seq_number; *state = YAFFS_BLOCK_STATE_NEEDS_SCAN; } else { *seq_number = 0; *state = YAFFS_BLOCK_STATE_EMPTY; } } yaffs_trace(YAFFS_TRACE_MTD, "block query returns seq %d state %d", *seq_number, *state); if (retval == 0) return YAFFS_OK; else return YAFFS_FAIL; }
/* NB For use with inband tags.... * We assume that the data buffer is of size total_bytes_per_chunk so that we can also * use it to load the tags. */ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, const u8 * data, const struct yaffs_ext_tags *tags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); struct mtd_oob_ops ops; int retval = 0; loff_t addr; struct yaffs_packed_tags2 pt; int packed_tags_size = dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); void *packed_tags_ptr = dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt; yaffs_trace(YAFFS_TRACE_MTD, "nandmtd2_write_chunk_tags chunk %d data %p tags %p", nand_chunk, data, tags); addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; /* For yaffs2 writing there must be both data and tags. * If we're using inband tags, then the tags are stuffed into * the end of the data buffer. */ if (!data || !tags) BUG(); else if (dev->param.inband_tags) { struct yaffs_packed_tags2_tags_only *pt2tp; pt2tp = (struct yaffs_packed_tags2_tags_only *)(data + dev-> data_bytes_per_chunk); yaffs_pack_tags2_tags_only(pt2tp, tags); } else { yaffs_pack_tags2(&pt, tags, !dev->param.no_tags_ecc); } ops.mode = MTD_OOB_AUTO; ops.ooblen = (dev->param.inband_tags) ? 0 : packed_tags_size; ops.len = dev->param.total_bytes_per_chunk; ops.ooboffs = 0; ops.datbuf = (u8 *) data; ops.oobbuf = (dev->param.inband_tags) ? NULL : packed_tags_ptr; retval = mtd->write_oob(mtd, addr, &ops); if (retval == 0) return YAFFS_OK; else return YAFFS_FAIL; }
static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj) { struct yaffs_allocator *allocator = dev->allocator; int i; struct yaffs_obj *new_objs; struct yaffs_obj_list *list; if (!allocator) { YBUG(); return YAFFS_FAIL; } if (n_obj < 1) return YAFFS_OK; new_objs = kmalloc(n_obj * sizeof(struct yaffs_obj), GFP_NOFS); list = kmalloc(sizeof(struct yaffs_obj_list), GFP_NOFS); if (!new_objs || !list) { if (new_objs) { kfree(new_objs); new_objs = NULL; } if (list) { kfree(list); list = NULL; } yaffs_trace(YAFFS_TRACE_ALLOCATE, "Could not allocate more objects"); return YAFFS_FAIL; } for (i = 0; i < n_obj - 1; i++) { new_objs[i].siblings.next = (struct list_head *)(&new_objs[i + 1]); } new_objs[n_obj - 1].siblings.next = (void *)allocator->free_objs; allocator->free_objs = new_objs; allocator->n_free_objects += n_obj; allocator->n_obj_created += n_obj; list->objects = new_objs; list->next = allocator->allocated_obj_list; allocator->allocated_obj_list = list; return YAFFS_OK; }
static void yaffs2_checkpt_find_block(struct yaffs_dev *dev) { int i; struct yaffs_ext_tags tags; yaffs_trace(YAFFS_TRACE_CHECKPOINT, "find next checkpt block: start: blocks %d next %d", dev->blocks_in_checkpt, dev->checkpt_next_block); if (dev->blocks_in_checkpt < dev->checkpt_max_blocks) for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) { int chunk = i * dev->param.chunks_per_block; int realigned_chunk = chunk - dev->chunk_offset; dev->param.read_chunk_tags_fn(dev, realigned_chunk, NULL, &tags); yaffs_trace(YAFFS_TRACE_CHECKPOINT, "find next checkpt block: search: block %d oid %d seq %d eccr %d", i, tags.obj_id, tags.seq_number, tags.ecc_result); if (tags.seq_number == YAFFS_SEQUENCE_CHECKPOINT_DATA) { /* Right kind of block */ dev->checkpt_next_block = tags.obj_id; dev->checkpt_cur_block = i; dev->checkpt_block_list[dev-> blocks_in_checkpt] = i; dev->blocks_in_checkpt++; yaffs_trace(YAFFS_TRACE_CHECKPOINT, "found checkpt block %d", i); return; } } yaffs_trace(YAFFS_TRACE_CHECKPOINT, "found no more checkpt blocks"); dev->checkpt_next_block = -1; dev->checkpt_cur_block = -1; }
struct mtd_info * yaffs_get_mtd_device(dev_t sdev) { struct mtd_info *mtd; mtd = yaffs_get_mtd_device(sdev); /* Check it's an mtd device..... */ if (MAJOR(sdev) != MTD_BLOCK_MAJOR) return NULL; /* This isn't an mtd device */ /* Check it's NAND */ if (mtd->type != MTD_NANDFLASH) { yaffs_trace(YAFFS_TRACE_ALWAYS, "yaffs: MTD device is not NAND it's type %d", mtd->type); return NULL; } yaffs_trace(YAFFS_TRACE_OS, " %s %d", WRITE_SIZE_STR, WRITE_SIZE(mtd)); yaffs_trace(YAFFS_TRACE_OS, " oobsize %d", mtd->oobsize); yaffs_trace(YAFFS_TRACE_OS, " erasesize %d", mtd->erasesize); #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 29) yaffs_trace(YAFFS_TRACE_OS, " size %u", mtd->size); #else yaffs_trace(YAFFS_TRACE_OS, " size %lld", mtd->size); #endif return mtd; }
static int yaffs_wr_nand(struct yaffs_dev *dev, int nand_chunk, const u8 * data, struct yaffs_spare *spare) { if (nand_chunk < dev->param.start_block * dev->param.chunks_per_block) { yaffs_trace(YAFFS_TRACE_ERROR, "**>> yaffs chunk %d is not valid", nand_chunk); return YAFFS_FAIL; } return dev->param.write_chunk_fn(dev, nand_chunk, data, spare); }
static int yaffs_mtd_write(struct yaffs_dev *dev, int nand_chunk, const u8 *data, int data_len, const u8 *oob, int oob_len) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); loff_t addr; struct mtd_oob_ops ops; int retval; yaffs_trace(YAFFS_TRACE_MTD, "yaffs_mtd_write(%p, %d, %p, %d, %p, %d)\n", dev, nand_chunk, data, data_len, oob, oob_len); if (!data || !data_len) { data = NULL; data_len = 0; } if (!oob || !oob_len) { oob = NULL; oob_len = 0; } addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; memset(&ops, 0, sizeof(ops)); ops.mode = MTD_OPS_AUTO_OOB; ops.len = (data) ? data_len : 0; ops.ooblen = oob_len; ops.datbuf = (u8 *)data; ops.oobbuf = (u8 *)oob; retval = mtd_write_oob(mtd, addr, &ops); if (retval) { yaffs_trace(YAFFS_TRACE_MTD, "write_oob failed, chunk %d, mtd error %d", nand_chunk, retval); } return retval ? YAFFS_FAIL : YAFFS_OK; }
int nandmtd2_query_block(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, u32 *seq_number) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int retval; yaffs_trace(YAFFS_TRACE_MTD, "nandmtd2_query_block %d", block_no); retval = mtd->block_isbad(mtd, ((loff_t)block_no) * dev->param.chunks_per_block * dev->param.total_bytes_per_chunk); if (retval) { yaffs_trace(YAFFS_TRACE_MTD, "block is bad"); *state = YAFFS_BLOCK_STATE_DEAD; *seq_number = 0; } else { struct yaffs_ext_tags t; nandmtd2_read_chunk_tags(dev, block_no * dev->param.chunks_per_block, NULL, &t); if (t.chunk_used) { *seq_number = t.seq_number; *state = YAFFS_BLOCK_STATE_NEEDS_SCAN; } else { *seq_number = 0; *state = YAFFS_BLOCK_STATE_EMPTY; } } yaffs_trace(YAFFS_TRACE_MTD, "block is bad seq %d state %d", *seq_number, *state); if (retval == 0) return YAFFS_OK; else return YAFFS_FAIL; }