#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,
int yaffs_count_bits(__u8 x)
{
- int retVal;
- retVal = yaffs_count_bits_table[x];
- return retVal;
+ int ret_val;
+ ret_val = yaffs_count_bits_table[x];
+ return ret_val;
}
/********** Tags ECC calculations *********/
/********** Tags **********/
-static void yaffs_load_tags_to_spare(yaffs_spare *sparePtr,
- yaffs_tags_t *tagsPtr)
+static void yaffs_load_tags_to_spare(yaffs_spare *spare_ptr,
+ yaffs_tags_t *tags_ptr)
{
- yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tagsPtr;
-
- yaffs_calc_tags_ecc(tagsPtr);
-
- sparePtr->tb0 = tu->as_bytes[0];
- sparePtr->tb1 = tu->as_bytes[1];
- sparePtr->tb2 = tu->as_bytes[2];
- sparePtr->tb3 = tu->as_bytes[3];
- sparePtr->tb4 = tu->as_bytes[4];
- sparePtr->tb5 = tu->as_bytes[5];
- sparePtr->tb6 = tu->as_bytes[6];
- sparePtr->tb7 = tu->as_bytes[7];
+ yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tags_ptr;
+
+ yaffs_calc_tags_ecc(tags_ptr);
+
+ spare_ptr->tb0 = tu->as_bytes[0];
+ spare_ptr->tb1 = tu->as_bytes[1];
+ spare_ptr->tb2 = tu->as_bytes[2];
+ spare_ptr->tb3 = tu->as_bytes[3];
+ spare_ptr->tb4 = tu->as_bytes[4];
+ spare_ptr->tb5 = tu->as_bytes[5];
+ spare_ptr->tb6 = tu->as_bytes[6];
+ spare_ptr->tb7 = tu->as_bytes[7];
}
-static void yaffs_get_tags_from_spare(yaffs_dev_t *dev, yaffs_spare *sparePtr,
- yaffs_tags_t *tagsPtr)
+static void yaffs_get_tags_from_spare(yaffs_dev_t *dev, yaffs_spare *spare_ptr,
+ yaffs_tags_t *tags_ptr)
{
- yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tagsPtr;
+ yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tags_ptr;
int result;
- tu->as_bytes[0] = sparePtr->tb0;
- tu->as_bytes[1] = sparePtr->tb1;
- tu->as_bytes[2] = sparePtr->tb2;
- tu->as_bytes[3] = sparePtr->tb3;
- tu->as_bytes[4] = sparePtr->tb4;
- tu->as_bytes[5] = sparePtr->tb5;
- tu->as_bytes[6] = sparePtr->tb6;
- tu->as_bytes[7] = sparePtr->tb7;
+ tu->as_bytes[0] = spare_ptr->tb0;
+ tu->as_bytes[1] = spare_ptr->tb1;
+ tu->as_bytes[2] = spare_ptr->tb2;
+ tu->as_bytes[3] = spare_ptr->tb3;
+ tu->as_bytes[4] = spare_ptr->tb4;
+ tu->as_bytes[5] = spare_ptr->tb5;
+ tu->as_bytes[6] = spare_ptr->tb6;
+ tu->as_bytes[7] = spare_ptr->tb7;
- result = yaffs_check_tags_ecc(tagsPtr);
+ result = yaffs_check_tags_ecc(tags_ptr);
if (result > 0)
dev->n_tags_ecc_fixed++;
else if (result < 0)
__u8 *data,
yaffs_spare *spare,
yaffs_ecc_result *ecc_result,
- int doErrorCorrection)
+ int correct_errors)
{
- int retVal;
- yaffs_spare localSpare;
+ int ret_val;
+ yaffs_spare local_spare;
if (!spare && data) {
/* If we don't have a real spare, then we use a local one. */
/* Need this for the calculation of the ecc */
- spare = &localSpare;
+ spare = &local_spare;
}
if (!dev->param.use_nand_ecc) {
- retVal = dev->param.read_chunk_fn(dev, nand_chunk, data, spare);
- if (data && doErrorCorrection) {
+ 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 calcEcc[3];
+ __u8 calc_ecc[3];
- yaffs_ecc_cacl(data, calcEcc);
+ yaffs_ecc_cacl(data, calc_ecc);
ecc_result1 =
- yaffs_ecc_correct(data, spare->ecc1, calcEcc);
- yaffs_ecc_cacl(&data[256], calcEcc);
+ yaffs_ecc_correct(data, spare->ecc1, calc_ecc);
+ yaffs_ecc_cacl(&data[256], calc_ecc);
ecc_result2 =
- yaffs_ecc_correct(&data[256], spare->ecc2, calcEcc);
+ yaffs_ecc_correct(&data[256], spare->ecc2, calc_ecc);
if (ecc_result1 > 0) {
T(YAFFS_TRACE_ERROR,
memset(&nspare, 0, sizeof(nspare));
- retVal = dev->param.read_chunk_fn(dev, nand_chunk, data,
+ ret_val = dev->param.read_chunk_fn(dev, nand_chunk, data,
(yaffs_spare *) &nspare);
memcpy(spare, &nspare, sizeof(yaffs_spare));
- if (data && doErrorCorrection) {
+ if (data && correct_errors) {
if (nspare.eccres1 > 0) {
T(YAFFS_TRACE_ERROR,
(TSTR
}
}
- return retVal;
+ 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 (memcmp(cmpbuf, data, YAFFS_BYTES_PER_CHUNK))
- return YAFFS_FAIL;
- if (memcmp(cmpbuf, spare, 16))
- return YAFFS_FAIL;
-
- return YAFFS_OK;
-
-}
-#endif
/*
* Functions for robustisizing
*/
}
-#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)
-{
- 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 *eTags)
+ const yaffs_ext_tags *ext_tags)
{
yaffs_spare spare;
yaffs_tags_t tags;
yaffs_spare_init(&spare);
- if (eTags->is_deleted)
+ if (ext_tags->is_deleted)
spare.page_status = 0;
else {
- tags.obj_id = eTags->obj_id;
- tags.chunk_id = eTags->chunk_id;
+ tags.obj_id = ext_tags->obj_id;
+ tags.chunk_id = ext_tags->chunk_id;
- tags.n_bytes_lsb = eTags->n_bytes & 0x3ff;
+ tags.n_bytes_lsb = ext_tags->n_bytes & 0x3ff;
if (dev->data_bytes_per_chunk >= 1024)
- tags.n_bytes_msb = (eTags->n_bytes >> 10) & 3;
+ tags.n_bytes_msb = (ext_tags->n_bytes >> 10) & 3;
else
tags.n_bytes_msb = 3;
- tags.serial_number = eTags->serial_number;
+ tags.serial_number = ext_tags->serial_number;
if (!dev->param.use_nand_ecc && data)
yaffs_calc_ecc(data, &spare);
int yaffs_tags_compat_rd(yaffs_dev_t *dev,
int nand_chunk,
__u8 *data,
- yaffs_ext_tags *eTags)
+ yaffs_ext_tags *ext_tags)
{
yaffs_spare spare;
yaffs_tags_t tags;
yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_UNKNOWN;
- static yaffs_spare spareFF;
+ static yaffs_spare spare_ff;
static int init;
if (!init) {
- memset(&spareFF, 0xFF, sizeof(spareFF));
+ memset(&spare_ff, 0xFF, sizeof(spare_ff));
init = 1;
}
if (yaffs_rd_chunk_nand
(dev, nand_chunk, data, &spare, &ecc_result, 1)) {
- /* eTags may be NULL */
- if (eTags) {
+ /* ext_tags may be NULL */
+ if (ext_tags) {
int deleted =
(yaffs_count_bits(spare.page_status) < 7) ? 1 : 0;
- eTags->is_deleted = deleted;
- eTags->ecc_result = ecc_result;
- eTags->block_bad = 0; /* We're reading it */
+ 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 */
- eTags->chunk_used =
- (memcmp(&spareFF, &spare, sizeof(spareFF)) !=
+ ext_tags->chunk_used =
+ (memcmp(&spare_ff, &spare, sizeof(spare_ff)) !=
0) ? 1 : 0;
- if (eTags->chunk_used) {
+ if (ext_tags->chunk_used) {
yaffs_get_tags_from_spare(dev, &spare, &tags);
- eTags->obj_id = tags.obj_id;
- eTags->chunk_id = tags.chunk_id;
- eTags->n_bytes = tags.n_bytes_lsb;
+ ext_tags->obj_id = tags.obj_id;
+ ext_tags->chunk_id = tags.chunk_id;
+ ext_tags->n_bytes = tags.n_bytes_lsb;
if (dev->data_bytes_per_chunk >= 1024)
- eTags->n_bytes |= (((unsigned) tags.n_bytes_msb) << 10);
+ ext_tags->n_bytes |= (((unsigned) tags.n_bytes_msb) << 10);
- eTags->serial_number = tags.serial_number;
+ ext_tags->serial_number = tags.serial_number;
}
}
{
yaffs_spare spare0, spare1;
- static yaffs_spare spareFF;
+ static yaffs_spare spare_ff;
static int init;
yaffs_ecc_result dummy;
if (!init) {
- memset(&spareFF, 0xFF, sizeof(spareFF));
+ memset(&spare_ff, 0xFF, sizeof(spare_ff));
init = 1;
}
if (yaffs_count_bits(spare0.block_status & spare1.block_status) < 7)
*state = YAFFS_BLOCK_STATE_DEAD;
- else if (memcmp(&spareFF, &spare0, sizeof(spareFF)) == 0)
+ else if (memcmp(&spare_ff, &spare0, sizeof(spare_ff)) == 0)
*state = YAFFS_BLOCK_STATE_EMPTY;
else
*state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;