X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=yaffs_tagscompat.c;h=7578075d9ac10a26dca7ff93a9e4d6735795c8a2;hp=5af3a3319f4db60a9efb81cc29f0359caaa4755f;hb=fe192b14d52d6c7d4722402686dcb553153916c3;hpb=cf6888f05f691aa1a357e7e94f9bf7b98174bbc3 diff --git a/yaffs_tagscompat.c b/yaffs_tagscompat.c index 5af3a33..7578075 100644 --- a/yaffs_tagscompat.c +++ b/yaffs_tagscompat.c @@ -17,48 +17,22 @@ #include "yaffs_getblockinfo.h" #include "yaffs_trace.h" -static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk); - - -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) +void yaffs_calc_ecc(const u8 * data, struct 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; @@ -77,7 +51,7 @@ void yaffs_calc_tags_ecc(yaffs_tags_t *tags) } -int yaffs_check_tags_ecc(yaffs_tags_t *tags) +int yaffs_check_tags_ecc(struct yaffs_tags *tags) { unsigned ecc = tags->ecc; @@ -87,7 +61,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--; @@ -108,10 +82,10 @@ int yaffs_check_tags_ecc(yaffs_tags_t *tags) /********** 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); @@ -125,10 +99,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; @@ -147,34 +122,34 @@ 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)); + 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_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; if (!spare && data) { /* If we don't have a real spare, then we use a local one. */ @@ -183,7 +158,8 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev, } if (!dev->param.use_nand_ecc) { - ret_val = dev->param.read_chunk_fn(dev, nand_chunk, data, spare); + ret_val = + dev->param.read_chunk_fn(dev, nand_chunk, data, spare); if (data && correct_errors) { /* Do ECC correction */ /* Todo handle any errors */ @@ -195,33 +171,30 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev, 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); + 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)); + 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) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>yaffs ecc error unfixed on chunk %d:0" - TENDSTR), nand_chunk)); + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>yaffs ecc error unfixed on chunk %d:0", + 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)); + 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) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>yaffs ecc error unfixed on chunk %d:1" - TENDSTR), nand_chunk)); + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>yaffs ecc error unfixed on chunk %d:1", + nand_chunk); dev->n_ecc_unfixed++; } @@ -245,31 +218,28 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev, 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)); + (struct yaffs_spare *) + &nspare); + memcpy(spare, &nspare, sizeof(struct 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)); + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>mtd ecc error fix performed on chunk %d:0", + nand_chunk); } else if (nspare.eccres1 < 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>mtd ecc error unfixed on chunk %d:0" - TENDSTR), nand_chunk)); + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>mtd ecc error unfixed on chunk %d:0", + nand_chunk); } if (nspare.eccres2 > 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>mtd ecc error fix performed on chunk %d:1" - TENDSTR), nand_chunk)); + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>mtd ecc error fix performed on chunk %d:1", + nand_chunk); } else if (nspare.eccres2 < 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>mtd ecc error unfixed on chunk %d:1" - TENDSTR), nand_chunk)); + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>mtd ecc error unfixed on chunk %d:1", + nand_chunk); } if (nspare.eccres1 || nspare.eccres2) { @@ -289,19 +259,21 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev, return ret_val; } - /* * 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 @@ -310,14 +282,12 @@ static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk) */ } - -int yaffs_tags_compat_wr(yaffs_dev_t *dev, - int nand_chunk, - const u8 *data, - const yaffs_ext_tags *ext_tags) +int yaffs_tags_compat_wr(struct yaffs_dev *dev, + int nand_chunk, + const u8 * data, const struct yaffs_ext_tags *ext_tags) { - yaffs_spare spare; - yaffs_tags_t tags; + struct yaffs_spare spare; + struct yaffs_tags tags; yaffs_spare_init(&spare); @@ -334,7 +304,6 @@ int yaffs_tags_compat_wr(yaffs_dev_t *dev, else tags.n_bytes_msb = 3; - tags.serial_number = ext_tags->serial_number; if (!dev->param.use_nand_ecc && data) @@ -347,17 +316,16 @@ int yaffs_tags_compat_wr(yaffs_dev_t *dev, 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) +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; + struct yaffs_spare spare; + struct yaffs_tags tags; + enum yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_UNKNOWN; - static yaffs_spare spare_ff; + static struct yaffs_spare spare_ff; static int init; if (!init) { @@ -365,13 +333,12 @@ int yaffs_tags_compat_rd(yaffs_dev_t *dev, init = 1; } - if (yaffs_rd_chunk_nand - (dev, nand_chunk, data, &spare, &ecc_result, 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; + (hweight8(spare.page_status) < 7) ? 1 : 0; ext_tags->is_deleted = deleted; ext_tags->ecc_result = ecc_result; @@ -389,7 +356,9 @@ int yaffs_tags_compat_rd(yaffs_dev_t *dev, ext_tags->n_bytes = tags.n_bytes_lsb; if (dev->data_bytes_per_chunk >= 1024) - ext_tags->n_bytes |= (((unsigned) tags.n_bytes_msb) << 10); + ext_tags->n_bytes |= + (((unsigned)tags. + n_bytes_msb) << 10); ext_tags->serial_number = tags.serial_number; } @@ -401,35 +370,34 @@ int yaffs_tags_compat_rd(yaffs_dev_t *dev, } } -int yaffs_tags_compat_mark_bad(struct yaffs_dev_s *dev, - int flash_block) +int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, int flash_block) { - yaffs_spare spare; + struct 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) +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)); @@ -439,11 +407,11 @@ int yaffs_tags_compat_query_block(struct yaffs_dev_s *dev, *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); + &spare0, &dummy, 1); + yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block + 1, + NULL, &spare1, &dummy, 1); - 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;