X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=yaffs_tagscompat.c;h=092430beccb7780311d1f148870a83a443fa0164;hp=1e910f2f3c69988d6688c76c8898c72f0a9d175c;hb=93e9fdf712264bc18bad8b249e8e908494b0f774;hpb=a5bab2056ca3c68d3e15568f81a6e1d697d23da5 diff --git a/yaffs_tagscompat.c b/yaffs_tagscompat.c index 1e910f2..092430b 100644 --- a/yaffs_tagscompat.c +++ b/yaffs_tagscompat.c @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. * - * Copyright (C) 2002-2010 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning @@ -17,56 +17,16 @@ #include "yaffs_getblockinfo.h" #include "yaffs_trace.h" -static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk); -#ifdef NOTYET -static void yaffs_check_written_block(yaffs_dev_t *dev, int nand_chunk); -static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk, - const __u8 *data, - const yaffs_spare *spare); -static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk, - const yaffs_spare *spare); -static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk); -#endif - -static const char yaffs_count_bits_table[256] = { - 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, - 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, - 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, - 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, - 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, - 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8 -}; - -int yaffs_count_bits(__u8 x) -{ - int ret_val; - ret_val = yaffs_count_bits_table[x]; - return ret_val; -} +static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk); + /********** Tags ECC calculations *********/ -void yaffs_calc_ecc(const __u8 *data, yaffs_spare *spare) -{ - yaffs_ecc_cacl(data, spare->ecc1); - yaffs_ecc_cacl(&data[256], spare->ecc2); -} -void yaffs_calc_tags_ecc(yaffs_tags_t *tags) +void yaffs_calc_tags_ecc(struct yaffs_tags *tags) { /* Calculate an ecc */ - - unsigned char *b = ((yaffs_tags_union_t *) tags)->as_bytes; + unsigned char *b = ((union yaffs_tags_union *)tags)->as_bytes; unsigned i, j; unsigned ecc = 0; unsigned bit = 0; @@ -80,12 +40,10 @@ void yaffs_calc_tags_ecc(yaffs_tags_t *tags) ecc ^= bit; } } - tags->ecc = ecc; - } -int yaffs_check_tags_ecc(yaffs_tags_t *tags) +int yaffs_check_tags_ecc(struct yaffs_tags *tags) { unsigned ecc = tags->ecc; @@ -95,7 +53,7 @@ int yaffs_check_tags_ecc(yaffs_tags_t *tags) if (ecc && ecc <= 64) { /* TODO: Handle the failure better. Retire? */ - unsigned char *b = ((yaffs_tags_union_t *) tags)->as_bytes; + unsigned char *b = ((union yaffs_tags_union *)tags)->as_bytes; ecc--; @@ -110,16 +68,15 @@ int yaffs_check_tags_ecc(yaffs_tags_t *tags) /* TODO Need to do somethiong here */ return -1; /* unrecovered error */ } - return 0; } /********** Tags **********/ -static void yaffs_load_tags_to_spare(yaffs_spare *spare_ptr, - yaffs_tags_t *tags_ptr) +static void yaffs_load_tags_to_spare(struct yaffs_spare *spare_ptr, + struct yaffs_tags *tags_ptr) { - yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tags_ptr; + union yaffs_tags_union *tu = (union yaffs_tags_union *)tags_ptr; yaffs_calc_tags_ecc(tags_ptr); @@ -133,10 +90,11 @@ static void yaffs_load_tags_to_spare(yaffs_spare *spare_ptr, spare_ptr->tb7 = tu->as_bytes[7]; } -static void yaffs_get_tags_from_spare(yaffs_dev_t *dev, yaffs_spare *spare_ptr, - yaffs_tags_t *tags_ptr) +static void yaffs_get_tags_from_spare(struct yaffs_dev *dev, + struct yaffs_spare *spare_ptr, + struct yaffs_tags *tags_ptr) { - yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tags_ptr; + union yaffs_tags_union *tu = (union yaffs_tags_union *)tags_ptr; int result; tu->as_bytes[0] = spare_ptr->tb0; @@ -155,188 +113,119 @@ static void yaffs_get_tags_from_spare(yaffs_dev_t *dev, yaffs_spare *spare_ptr, dev->n_tags_ecc_unfixed++; } -static void yaffs_spare_init(yaffs_spare *spare) +static void yaffs_spare_init(struct yaffs_spare *spare) { - memset(spare, 0xFF, sizeof(yaffs_spare)); + memset(spare, 0xff, sizeof(struct yaffs_spare)); } -static int yaffs_wr_nand(struct yaffs_dev_s *dev, - int nand_chunk, const __u8 *data, - yaffs_spare *spare) +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) { - T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs chunk %d is not valid" TENDSTR), - nand_chunk)); - return YAFFS_FAIL; - } + int data_size = dev->data_bytes_per_chunk; - return dev->param.write_chunk_fn(dev, nand_chunk, data, spare); + return dev->drv.drv_write_chunk_fn(dev, nand_chunk, + data, data_size, + (u8 *) spare, sizeof(*spare)); } -static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev, - int nand_chunk, - __u8 *data, - yaffs_spare *spare, - yaffs_ecc_result *ecc_result, - int correct_errors) +static int yaffs_rd_chunk_nand(struct yaffs_dev *dev, + int nand_chunk, + u8 *data, + struct yaffs_spare *spare, + enum yaffs_ecc_result *ecc_result, + int correct_errors) { int ret_val; - yaffs_spare local_spare; + struct yaffs_spare local_spare; + int data_size; + int spare_size; + int ecc_result1, ecc_result2; + u8 calc_ecc[3]; - if (!spare && data) { + if (!spare) { /* If we don't have a real spare, then we use a local one. */ /* Need this for the calculation of the ecc */ spare = &local_spare; } - - if (!dev->param.use_nand_ecc) { - ret_val = dev->param.read_chunk_fn(dev, nand_chunk, data, spare); - if (data && correct_errors) { - /* Do ECC correction */ - /* Todo handle any errors */ - int ecc_result1, ecc_result2; - __u8 calc_ecc[3]; - - yaffs_ecc_cacl(data, calc_ecc); - ecc_result1 = - yaffs_ecc_correct(data, spare->ecc1, calc_ecc); - yaffs_ecc_cacl(&data[256], calc_ecc); - ecc_result2 = - yaffs_ecc_correct(&data[256], spare->ecc2, calc_ecc); - - if (ecc_result1 > 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>yaffs ecc error fix performed on chunk %d:0" - TENDSTR), nand_chunk)); - dev->n_ecc_fixed++; - } else if (ecc_result1 < 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>yaffs ecc error unfixed on chunk %d:0" - TENDSTR), nand_chunk)); - dev->n_ecc_unfixed++; - } - - if (ecc_result2 > 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>yaffs ecc error fix performed on chunk %d:1" - TENDSTR), nand_chunk)); - dev->n_ecc_fixed++; - } else if (ecc_result2 < 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>yaffs ecc error unfixed on chunk %d:1" - TENDSTR), nand_chunk)); - dev->n_ecc_unfixed++; - } - - if (ecc_result1 || ecc_result2) { - /* We had a data problem on this page */ - yaffs_handle_rd_data_error(dev, nand_chunk); - } - - if (ecc_result1 < 0 || ecc_result2 < 0) - *ecc_result = YAFFS_ECC_RESULT_UNFIXED; - else if (ecc_result1 > 0 || ecc_result2 > 0) - *ecc_result = YAFFS_ECC_RESULT_FIXED; - else - *ecc_result = YAFFS_ECC_RESULT_NO_ERROR; - } - } else { - /* Must allocate enough memory for spare+2*sizeof(int) */ - /* for ecc results from device. */ - struct yaffs_nand_spare nspare; - - memset(&nspare, 0, sizeof(nspare)); - - ret_val = dev->param.read_chunk_fn(dev, nand_chunk, data, - (yaffs_spare *) &nspare); - memcpy(spare, &nspare, sizeof(yaffs_spare)); - if (data && correct_errors) { - if (nspare.eccres1 > 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>mtd ecc error fix performed on chunk %d:0" - TENDSTR), nand_chunk)); - } else if (nspare.eccres1 < 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>mtd ecc error unfixed on chunk %d:0" - TENDSTR), nand_chunk)); - } - - if (nspare.eccres2 > 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>mtd ecc error fix performed on chunk %d:1" - TENDSTR), nand_chunk)); - } else if (nspare.eccres2 < 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>mtd ecc error unfixed on chunk %d:1" - TENDSTR), nand_chunk)); - } - - if (nspare.eccres1 || nspare.eccres2) { - /* We had a data problem on this page */ - yaffs_handle_rd_data_error(dev, nand_chunk); - } - - if (nspare.eccres1 < 0 || nspare.eccres2 < 0) - *ecc_result = YAFFS_ECC_RESULT_UNFIXED; - else if (nspare.eccres1 > 0 || nspare.eccres2 > 0) - *ecc_result = YAFFS_ECC_RESULT_FIXED; - else - *ecc_result = YAFFS_ECC_RESULT_NO_ERROR; - - } + data_size = dev->data_bytes_per_chunk; + spare_size = sizeof(struct yaffs_spare); + + if (dev->param.use_nand_ecc) + return dev->drv.drv_read_chunk_fn(dev, nand_chunk, + data, data_size, + (u8 *) spare, spare_size, + ecc_result); + + + /* Handle the ECC at this level. */ + + ret_val = dev->drv.drv_read_chunk_fn(dev, nand_chunk, + data, data_size, + (u8 *)spare, spare_size, + NULL); + if (!data || !correct_errors) + return ret_val; + + /* Do ECC correction if needed. */ + yaffs_ecc_calc(data, calc_ecc); + ecc_result1 = yaffs_ecc_correct(data, spare->ecc1, calc_ecc); + yaffs_ecc_calc(&data[256], calc_ecc); + ecc_result2 = yaffs_ecc_correct(&data[256], spare->ecc2, calc_ecc); + + if (ecc_result1 > 0) { + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>yaffs ecc error fix performed on chunk %d:0", + nand_chunk); + dev->n_ecc_fixed++; + } else if (ecc_result1 < 0) { + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>yaffs ecc error unfixed on chunk %d:0", + nand_chunk); + dev->n_ecc_unfixed++; } - return ret_val; -} -#ifdef NOTYET -static int yaffs_check_chunk_erased(struct yaffs_dev_s *dev, - int nand_chunk) -{ - static int init; - static __u8 cmpbuf[YAFFS_BYTES_PER_CHUNK]; - static __u8 data[YAFFS_BYTES_PER_CHUNK]; - /* Might as well always allocate the larger size for */ - /* dev->param.use_nand_ecc == true; */ - static __u8 spare[sizeof(struct yaffs_nand_spare)]; - - dev->param.read_chunk_fn(dev, nand_chunk, data, (yaffs_spare *) spare); - - if (!init) { - memset(cmpbuf, 0xff, YAFFS_BYTES_PER_CHUNK); - init = 1; + if (ecc_result2 > 0) { + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>yaffs ecc error fix performed on chunk %d:1", + nand_chunk); + dev->n_ecc_fixed++; + } else if (ecc_result2 < 0) { + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>yaffs ecc error unfixed on chunk %d:1", + nand_chunk); + dev->n_ecc_unfixed++; } - if (memcmp(cmpbuf, data, YAFFS_BYTES_PER_CHUNK)) - return YAFFS_FAIL; - if (memcmp(cmpbuf, spare, 16)) - return YAFFS_FAIL; + if (ecc_result1 || ecc_result2) { + /* We had a data problem on this page */ + yaffs_handle_rd_data_error(dev, nand_chunk); + } - return YAFFS_OK; + if (ecc_result1 < 0 || ecc_result2 < 0) + *ecc_result = YAFFS_ECC_RESULT_UNFIXED; + else if (ecc_result1 > 0 || ecc_result2 > 0) + *ecc_result = YAFFS_ECC_RESULT_FIXED; + else + *ecc_result = YAFFS_ECC_RESULT_NO_ERROR; + return ret_val; } -#endif /* * Functions for robustisizing */ -static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk) +static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk) { int flash_block = nand_chunk / dev->param.chunks_per_block; /* Mark the block for retirement */ - yaffs_get_block_info(dev, flash_block + dev->block_offset)->needs_retiring = 1; - T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, - (TSTR("**>>Block %d marked for retirement" TENDSTR), flash_block)); + yaffs_get_block_info(dev, flash_block + dev->block_offset)-> + needs_retiring = 1; + yaffs_trace(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, + "**>>Block %d marked for retirement", + flash_block); /* TODO: * Just do a garbage collection on the affected block @@ -345,64 +234,12 @@ static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk) */ } -#ifdef NOTYET -static void yaffs_check_written_block(yaffs_dev_t *dev, int nand_chunk) +static int yaffs_tags_compat_wr(struct yaffs_dev *dev, + int nand_chunk, + const u8 *data, const struct yaffs_ext_tags *ext_tags) { -} - -static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk, - const __u8 *data, - const yaffs_spare *spare) -{ -} - -static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk, - const yaffs_spare *spare) -{ -} - -static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk) -{ - int flash_block = nand_chunk / dev->param.chunks_per_block; - - /* Mark the block for retirement */ - yaffs_get_block_info(dev, flash_block)->needs_retiring = 1; - /* Delete the chunk */ - yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); -} - -static int yaffs_verify_cmp(const __u8 *d0, const __u8 *d1, - const yaffs_spare *s0, const yaffs_spare *s1) -{ - - if (memcmp(d0, d1, YAFFS_BYTES_PER_CHUNK) != 0 || - s0->tb0 != s1->tb0 || - s0->tb1 != s1->tb1 || - s0->tb2 != s1->tb2 || - s0->tb3 != s1->tb3 || - s0->tb4 != s1->tb4 || - s0->tb5 != s1->tb5 || - s0->tb6 != s1->tb6 || - s0->tb7 != s1->tb7 || - s0->ecc1[0] != s1->ecc1[0] || - s0->ecc1[1] != s1->ecc1[1] || - s0->ecc1[2] != s1->ecc1[2] || - s0->ecc2[0] != s1->ecc2[0] || - s0->ecc2[1] != s1->ecc2[1] || s0->ecc2[2] != s1->ecc2[2]) { - return 0; - } - - return 1; -} -#endif /* NOTYET */ - -int yaffs_tags_compat_wr(yaffs_dev_t *dev, - int nand_chunk, - const __u8 *data, - const yaffs_ext_tags *ext_tags) -{ - yaffs_spare spare; - yaffs_tags_t tags; + struct yaffs_spare spare; + struct yaffs_tags tags; yaffs_spare_init(&spare); @@ -412,128 +249,133 @@ int yaffs_tags_compat_wr(yaffs_dev_t *dev, tags.obj_id = ext_tags->obj_id; tags.chunk_id = ext_tags->chunk_id; - tags.n_bytes_lsb = ext_tags->n_bytes & 0x3ff; + tags.n_bytes_lsb = ext_tags->n_bytes & (1024 - 1); if (dev->data_bytes_per_chunk >= 1024) tags.n_bytes_msb = (ext_tags->n_bytes >> 10) & 3; else tags.n_bytes_msb = 3; - tags.serial_number = ext_tags->serial_number; - if (!dev->param.use_nand_ecc && data) - yaffs_calc_ecc(data, &spare); + if (!dev->param.use_nand_ecc && data) { + yaffs_ecc_calc(data, spare.ecc1); + yaffs_ecc_calc(&data[256], spare.ecc2); + } yaffs_load_tags_to_spare(&spare, &tags); - } - return yaffs_wr_nand(dev, nand_chunk, data, &spare); } -int yaffs_tags_compat_rd(yaffs_dev_t *dev, - int nand_chunk, - __u8 *data, - yaffs_ext_tags *ext_tags) +static int yaffs_tags_compat_rd(struct yaffs_dev *dev, + int nand_chunk, + u8 *data, struct yaffs_ext_tags *ext_tags) { - - yaffs_spare spare; - yaffs_tags_t tags; - yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_UNKNOWN; - - static yaffs_spare spare_ff; + struct yaffs_spare spare; + struct yaffs_tags tags; + enum yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_UNKNOWN; + static struct yaffs_spare spare_ff; static int init; + int deleted; if (!init) { - memset(&spare_ff, 0xFF, sizeof(spare_ff)); + memset(&spare_ff, 0xff, sizeof(spare_ff)); init = 1; } - if (yaffs_rd_chunk_nand - (dev, nand_chunk, data, &spare, &ecc_result, 1)) { - /* ext_tags may be NULL */ - if (ext_tags) { - - int deleted = - (yaffs_count_bits(spare.page_status) < 7) ? 1 : 0; + if (!yaffs_rd_chunk_nand(dev, nand_chunk, + data, &spare, &ecc_result, 1)) + return YAFFS_FAIL; - ext_tags->is_deleted = deleted; - ext_tags->ecc_result = ecc_result; - ext_tags->block_bad = 0; /* We're reading it */ - /* therefore it is not a bad block */ - ext_tags->chunk_used = - (memcmp(&spare_ff, &spare, sizeof(spare_ff)) != - 0) ? 1 : 0; + /* ext_tags may be NULL */ + if (!ext_tags) + return YAFFS_OK; - if (ext_tags->chunk_used) { - yaffs_get_tags_from_spare(dev, &spare, &tags); + deleted = (hweight8(spare.page_status) < 7) ? 1 : 0; - ext_tags->obj_id = tags.obj_id; - ext_tags->chunk_id = tags.chunk_id; - ext_tags->n_bytes = tags.n_bytes_lsb; + ext_tags->is_deleted = deleted; + ext_tags->ecc_result = ecc_result; + ext_tags->block_bad = 0; /* We're reading it */ + /* therefore it is not a bad block */ + ext_tags->chunk_used = + memcmp(&spare_ff, &spare, sizeof(spare_ff)) ? 1 : 0; - if (dev->data_bytes_per_chunk >= 1024) - ext_tags->n_bytes |= (((unsigned) tags.n_bytes_msb) << 10); + if (ext_tags->chunk_used) { + yaffs_get_tags_from_spare(dev, &spare, &tags); + ext_tags->obj_id = tags.obj_id; + ext_tags->chunk_id = tags.chunk_id; + ext_tags->n_bytes = tags.n_bytes_lsb; - ext_tags->serial_number = tags.serial_number; - } - } + if (dev->data_bytes_per_chunk >= 1024) + ext_tags->n_bytes |= + (((unsigned)tags.n_bytes_msb) << 10); - return YAFFS_OK; - } else { - return YAFFS_FAIL; + ext_tags->serial_number = tags.serial_number; } + + return YAFFS_OK; } -int yaffs_tags_compat_mark_bad(struct yaffs_dev_s *dev, - int flash_block) +static int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, int flash_block) { + struct yaffs_spare spare; - yaffs_spare spare; - - memset(&spare, 0xff, sizeof(yaffs_spare)); + memset(&spare, 0xff, sizeof(struct yaffs_spare)); spare.block_status = 'Y'; yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block, NULL, - &spare); + &spare); yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block + 1, - NULL, &spare); + NULL, &spare); return YAFFS_OK; - } -int yaffs_tags_compat_query_block(struct yaffs_dev_s *dev, - int block_no, - yaffs_block_state_t *state, - __u32 *seq_number) +static int yaffs_tags_compat_query_block(struct yaffs_dev *dev, + int block_no, + enum yaffs_block_state *state, + u32 *seq_number) { - - yaffs_spare spare0, spare1; - static yaffs_spare spare_ff; + struct yaffs_spare spare0, spare1; + static struct yaffs_spare spare_ff; static int init; - yaffs_ecc_result dummy; + enum yaffs_ecc_result dummy; if (!init) { - memset(&spare_ff, 0xFF, sizeof(spare_ff)); + memset(&spare_ff, 0xff, sizeof(spare_ff)); init = 1; } *seq_number = 0; - yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block, NULL, - &spare0, &dummy, 1); - yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block + 1, NULL, - &spare1, &dummy, 1); + /* Look for bad block markers in the first two chunks */ + yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block, + NULL, &spare0, &dummy, 0); + yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block + 1, + NULL, &spare1, &dummy, 0); - if (yaffs_count_bits(spare0.block_status & spare1.block_status) < 7) + if (hweight8(spare0.block_status & spare1.block_status) < 7) *state = YAFFS_BLOCK_STATE_DEAD; else if (memcmp(&spare_ff, &spare0, sizeof(spare_ff)) == 0) *state = YAFFS_BLOCK_STATE_EMPTY; else - *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; + *state = YAFFS_BLOCK_STATE_NEEDS_SCAN; return YAFFS_OK; } + +void yaffs_tags_compat_install(struct yaffs_dev *dev) +{ + if(dev->param.is_yaffs2) + return; + if(!dev->tagger.write_chunk_tags_fn) + dev->tagger.write_chunk_tags_fn = yaffs_tags_compat_wr; + if(!dev->tagger.read_chunk_tags_fn) + dev->tagger.read_chunk_tags_fn = yaffs_tags_compat_rd; + if(!dev->tagger.query_block_fn) + dev->tagger.query_block_fn = yaffs_tags_compat_query_block; + if(!dev->tagger.mark_bad_fn) + dev->tagger.mark_bad_fn = yaffs_tags_compat_mark_bad; +}