]>
git.ipfire.org Git - people/ms/u-boot.git/blob - drivers/mtd/nand/nand_bch.c
2 * This file provides ECC correction for more than 1 bit per block of data,
3 * using binary BCH codes. It relies on the generic BCH library lib/bch.c.
5 * Copyright © 2011 Ivan Djelic <ivan.djelic@parrot.com>
7 * SPDX-License-Identifier: GPL-2.0+
11 /*#include <asm/io.h>*/
12 #include <linux/types.h>
14 #include <linux/bitops.h>
15 #include <linux/mtd/mtd.h>
16 #include <linux/mtd/nand.h>
17 #include <linux/mtd/nand_bch.h>
18 #include <linux/bch.h>
22 * struct nand_bch_control - private NAND BCH control structure
23 * @bch: BCH control structure
24 * @ecclayout: private ecc layout for this BCH configuration
25 * @errloc: error location array
26 * @eccmask: XOR ecc mask, allows erased pages to be decoded as valid
28 struct nand_bch_control
{
29 struct bch_control
*bch
;
30 struct nand_ecclayout ecclayout
;
32 unsigned char *eccmask
;
36 * nand_bch_calculate_ecc - [NAND Interface] Calculate ECC for data block
37 * @mtd: MTD block structure
38 * @buf: input buffer with raw data
39 * @code: output buffer with ECC
41 int nand_bch_calculate_ecc(struct mtd_info
*mtd
, const unsigned char *buf
,
44 const struct nand_chip
*chip
= mtd_to_nand(mtd
);
45 struct nand_bch_control
*nbc
= chip
->ecc
.priv
;
48 memset(code
, 0, chip
->ecc
.bytes
);
49 encode_bch(nbc
->bch
, buf
, chip
->ecc
.size
, code
);
51 /* apply mask so that an erased page is a valid codeword */
52 for (i
= 0; i
< chip
->ecc
.bytes
; i
++)
53 code
[i
] ^= nbc
->eccmask
[i
];
59 * nand_bch_correct_data - [NAND Interface] Detect and correct bit error(s)
60 * @mtd: MTD block structure
61 * @buf: raw data read from the chip
62 * @read_ecc: ECC from the chip
63 * @calc_ecc: the ECC calculated from raw data
65 * Detect and correct bit errors for a data byte block
67 int nand_bch_correct_data(struct mtd_info
*mtd
, unsigned char *buf
,
68 unsigned char *read_ecc
, unsigned char *calc_ecc
)
70 const struct nand_chip
*chip
= mtd_to_nand(mtd
);
71 struct nand_bch_control
*nbc
= chip
->ecc
.priv
;
72 unsigned int *errloc
= nbc
->errloc
;
75 count
= decode_bch(nbc
->bch
, NULL
, chip
->ecc
.size
, read_ecc
, calc_ecc
,
78 for (i
= 0; i
< count
; i
++) {
79 if (errloc
[i
] < (chip
->ecc
.size
*8))
80 /* error is located in data, correct it */
81 buf
[errloc
[i
] >> 3] ^= (1 << (errloc
[i
] & 7));
82 /* else error in ecc, no action needed */
84 pr_debug("%s: corrected bitflip %u\n",
87 } else if (count
< 0) {
88 printk(KERN_ERR
"ecc unrecoverable error\n");
95 * nand_bch_init - [NAND Interface] Initialize NAND BCH error correction
96 * @mtd: MTD block structure
99 * a pointer to a new NAND BCH control structure, or NULL upon failure
101 * Initialize NAND BCH error correction. Parameters @eccsize and @eccbytes
102 * are used to compute BCH parameters m (Galois field order) and t (error
103 * correction capability). @eccbytes should be equal to the number of bytes
104 * required to store m*t bits, where m is such that 2^m-1 > @eccsize*8.
106 * Example: to configure 4 bit correction per 512 bytes, you should pass
107 * @eccsize = 512 (thus, m=13 is the smallest integer such that 2^m-1 > 512*8)
108 * @eccbytes = 7 (7 bytes are required to store m*t = 13*4 = 52 bits)
110 struct nand_bch_control
*nand_bch_init(struct mtd_info
*mtd
)
112 struct nand_chip
*nand
= mtd_to_nand(mtd
);
113 unsigned int m
, t
, eccsteps
, i
;
114 struct nand_ecclayout
*layout
= nand
->ecc
.layout
;
115 struct nand_bch_control
*nbc
= NULL
;
116 unsigned char *erased_page
;
117 unsigned int eccsize
= nand
->ecc
.size
;
118 unsigned int eccbytes
= nand
->ecc
.bytes
;
119 unsigned int eccstrength
= nand
->ecc
.strength
;
121 if (!eccbytes
&& eccstrength
) {
122 eccbytes
= DIV_ROUND_UP(eccstrength
* fls(8 * eccsize
), 8);
123 nand
->ecc
.bytes
= eccbytes
;
126 if (!eccsize
|| !eccbytes
) {
127 printk(KERN_WARNING
"ecc parameters not supplied\n");
131 m
= fls(1+8*eccsize
);
134 nbc
= kzalloc(sizeof(*nbc
), GFP_KERNEL
);
138 nbc
->bch
= init_bch(m
, t
, 0);
142 /* verify that eccbytes has the expected value */
143 if (nbc
->bch
->ecc_bytes
!= eccbytes
) {
144 printk(KERN_WARNING
"invalid eccbytes %u, should be %u\n",
145 eccbytes
, nbc
->bch
->ecc_bytes
);
149 eccsteps
= mtd
->writesize
/eccsize
;
151 /* if no ecc placement scheme was provided, build one */
154 /* handle large page devices only */
155 if (mtd
->oobsize
< 64) {
156 printk(KERN_WARNING
"must provide an oob scheme for "
157 "oobsize %d\n", mtd
->oobsize
);
161 layout
= &nbc
->ecclayout
;
162 layout
->eccbytes
= eccsteps
*eccbytes
;
164 /* reserve 2 bytes for bad block marker */
165 if (layout
->eccbytes
+2 > mtd
->oobsize
) {
166 printk(KERN_WARNING
"no suitable oob scheme available "
167 "for oobsize %d eccbytes %u\n", mtd
->oobsize
,
171 /* put ecc bytes at oob tail */
172 for (i
= 0; i
< layout
->eccbytes
; i
++)
173 layout
->eccpos
[i
] = mtd
->oobsize
-layout
->eccbytes
+i
;
175 layout
->oobfree
[0].offset
= 2;
176 layout
->oobfree
[0].length
= mtd
->oobsize
-2-layout
->eccbytes
;
178 nand
->ecc
.layout
= layout
;
182 if (8*(eccsize
+eccbytes
) >= (1 << m
)) {
183 printk(KERN_WARNING
"eccsize %u is too large\n", eccsize
);
186 if (layout
->eccbytes
!= (eccsteps
*eccbytes
)) {
187 printk(KERN_WARNING
"invalid ecc layout\n");
191 nbc
->eccmask
= kmalloc(eccbytes
, GFP_KERNEL
);
192 nbc
->errloc
= kmalloc(t
*sizeof(*nbc
->errloc
), GFP_KERNEL
);
193 if (!nbc
->eccmask
|| !nbc
->errloc
)
196 * compute and store the inverted ecc of an erased ecc block
198 erased_page
= kmalloc(eccsize
, GFP_KERNEL
);
202 memset(erased_page
, 0xff, eccsize
);
203 memset(nbc
->eccmask
, 0, eccbytes
);
204 encode_bch(nbc
->bch
, erased_page
, eccsize
, nbc
->eccmask
);
207 for (i
= 0; i
< eccbytes
; i
++)
208 nbc
->eccmask
[i
] ^= 0xff;
211 nand
->ecc
.strength
= (eccbytes
* 8) / fls(8 * eccsize
);
220 * nand_bch_free - [NAND Interface] Release NAND BCH ECC resources
221 * @nbc: NAND BCH control structure
223 void nand_bch_free(struct nand_bch_control
*nbc
)