projects
/
yaffs2.git
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
yaffs Some changes to the quick tests README.
[yaffs2.git]
/
yaffs_tagscompat.c
diff --git
a/yaffs_tagscompat.c
b/yaffs_tagscompat.c
index 5af3a3319f4db60a9efb81cc29f0359caaa4755f..3a9a157e7e2470c44252cb338363347db7b04569 100644
(file)
--- a/
yaffs_tagscompat.c
+++ b/
yaffs_tagscompat.c
@@
-17,8
+17,7
@@
#include "yaffs_getblockinfo.h"
#include "yaffs_trace.h"
#include "yaffs_getblockinfo.h"
#include "yaffs_trace.h"
-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);
static const char yaffs_count_bits_table[256] = {
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
static const char yaffs_count_bits_table[256] = {
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
@@
-48,17
+47,17
@@
int yaffs_count_bits(u8 x)
/********** Tags ECC calculations *********/
/********** 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);
}
{
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 */
{
/* 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;
unsigned i, j;
unsigned ecc = 0;
unsigned bit = 0;
@@
-77,7
+76,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;
{
unsigned ecc = tags->ecc;
@@
-87,7
+86,7
@@
int yaffs_check_tags_ecc(yaffs_tags_t *tags)
if (ecc && ecc <= 64) {
/* TODO: Handle the failure better. Retire? */
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--;
ecc--;
@@
-108,10
+107,10
@@
int yaffs_check_tags_ecc(yaffs_tags_t *tags)
/********** 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);
yaffs_calc_tags_ecc(tags_ptr);
@@
-125,10
+124,11
@@
static void yaffs_load_tags_to_spare(yaffs_spare *spare_ptr,
spare_ptr->tb7 = tu->as_bytes[7];
}
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;
int result;
tu->as_bytes[0] = spare_ptr->tb0;
@@
-147,14
+147,14
@@
static void yaffs_get_tags_from_spare(yaffs_dev_t *dev, yaffs_spare *spare_ptr,
dev->n_tags_ecc_unfixed++;
}
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,
{
if (nand_chunk < dev->param.start_block * dev->param.chunks_per_block) {
T(YAFFS_TRACE_ERROR,
@@
-166,15
+166,15
@@
static int yaffs_wr_nand(struct yaffs_dev_s *dev,
return dev->param.write_chunk_fn(dev, nand_chunk, data, spare);
}
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;
{
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. */
if (!spare && data) {
/* If we don't have a real spare, then we use a local one. */
@@
-183,7
+183,8
@@
static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev,
}
if (!dev->param.use_nand_ecc) {
}
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 */
if (data && correct_errors) {
/* Do ECC correction */
/* Todo handle any errors */
@@
-195,7
+196,8
@@
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, 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,
if (ecc_result1 > 0) {
T(YAFFS_TRACE_ERROR,
@@
-245,8
+247,9
@@
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,
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,
if (data && correct_errors) {
if (nspare.eccres1 > 0) {
T(YAFFS_TRACE_ERROR,
@@
-289,17
+292,18
@@
static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev,
return ret_val;
}
return ret_val;
}
-
/*
* Functions for robustisizing
*/
/*
* 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 */
{
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;
+ 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));
T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
(TSTR("**>>Block %d marked for retirement" TENDSTR), flash_block));
@@
-310,14
+314,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);
yaffs_spare_init(&spare);
@@
-334,7
+336,6
@@
int yaffs_tags_compat_wr(yaffs_dev_t *dev,
else
tags.n_bytes_msb = 3;
else
tags.n_bytes_msb = 3;
-
tags.serial_number = ext_tags->serial_number;
if (!dev->param.use_nand_ecc && data)
tags.serial_number = ext_tags->serial_number;
if (!dev->param.use_nand_ecc && data)
@@
-347,17
+348,16
@@
int yaffs_tags_compat_wr(yaffs_dev_t *dev,
return yaffs_wr_nand(dev, nand_chunk, data, &spare);
}
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) {
static int init;
if (!init) {
@@
-365,8
+365,7
@@
int yaffs_tags_compat_rd(yaffs_dev_t *dev,
init = 1;
}
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) {
/* ext_tags may be NULL */
if (ext_tags) {
@@
-389,7
+388,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 = 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;
}
ext_tags->serial_number = tags.serial_number;
}
@@
-401,35
+402,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.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,
yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block + 1,
-
NULL, &spare);
+ NULL, &spare);
return YAFFS_OK;
}
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;
static int init;
- yaffs_ecc_result dummy;
+
enum
yaffs_ecc_result dummy;
if (!init) {
memset(&spare_ff, 0xFF, sizeof(spare_ff));
if (!init) {
memset(&spare_ff, 0xFF, sizeof(spare_ff));
@@
-439,9
+439,9
@@
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,
*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)
*state = YAFFS_BLOCK_STATE_DEAD;
if (yaffs_count_bits(spare0.block_status & spare1.block_status) < 7)
*state = YAFFS_BLOCK_STATE_DEAD;