summaryrefslogtreecommitdiffstats
path: root/common/imx-bbu-nand-fcb.c
diff options
context:
space:
mode:
authorJan Remmet <J.Remmet@phytec.de>2017-04-27 09:00:47 +0200
committerSascha Hauer <s.hauer@pengutronix.de>2017-05-05 09:10:26 +0200
commita2618c215bff762c60826a4bc008b2cdc45321dd (patch)
treeb06e5fa14511a7da346d85b5c5a7c5c4d591b911 /common/imx-bbu-nand-fcb.c
parent21b46e5258f8f3749bd8c48cf65e20d8265ec91b (diff)
downloadbarebox-a2618c215bff762c60826a4bc008b2cdc45321dd.tar.gz
imx-bbu-nand-fcb: add support for imx6ul
imx6ul secure the fcb with bch 40. The imx-kobs tool use a own modified bch lib. They reverse the bit order of the data and the ecc. To use the bch lib in barebox the bytes in the data buffers must be reversed. The data layout on nand is bit aligned. But with 40 bits this is not an issue for imx6ul now. Signed-off-by: Jan Remmet <J.Remmet@phytec.de> Signed-off-by: Sascha Hauer <s.hauer@pengutronix.de>
Diffstat (limited to 'common/imx-bbu-nand-fcb.c')
-rw-r--r--common/imx-bbu-nand-fcb.c145
1 files changed, 142 insertions, 3 deletions
diff --git a/common/imx-bbu-nand-fcb.c b/common/imx-bbu-nand-fcb.c
index 34a5f83..5d3d3f7 100644
--- a/common/imx-bbu-nand-fcb.c
+++ b/common/imx-bbu-nand-fcb.c
@@ -33,9 +33,12 @@
#include <linux/mtd/mtd.h>
#include <linux/mtd/nand.h>
#include <linux/stat.h>
+#include <linux/bch.h>
+#include <linux/bitops.h>
#include <io.h>
#include <crc.h>
#include <mach/generic.h>
+#include <mach/imx6.h>
#include <mtd/mtd-peb.h>
struct dbbt_block {
@@ -129,6 +132,132 @@ static uint8_t calculate_parity_13_8(uint8_t d)
return p;
}
+static uint8_t reverse_bit(uint8_t b)
+{
+ b = (b & 0xf0) >> 4 | (b & 0x0f) << 4;
+ b = (b & 0xcc) >> 2 | (b & 0x33) << 2;
+ b = (b & 0xaa) >> 1 | (b & 0x55) << 1;
+
+ return b;
+}
+
+static void encode_bch_ecc(void *buf, struct fcb_block *fcb, int eccbits)
+{
+ int i, j, m = 13;
+ int blocksize = 128;
+ int numblocks = 8;
+ int ecc_buf_size = (m * eccbits + 7) / 8;
+ struct bch_control *bch = init_bch(m, eccbits, 0);
+ uint8_t *ecc_buf = xmalloc(ecc_buf_size);
+ uint8_t *tmp_buf = xzalloc(blocksize * numblocks);
+ uint8_t *psrc, *pdst;
+
+ /*
+ * The blocks here are bit aligned. If eccbits is a multiple of 8,
+ * we just can copy bytes. Otherwiese we must move the blocks to
+ * the next free bit position.
+ */
+ BUG_ON(eccbits % 8);
+
+ memcpy(tmp_buf, fcb, sizeof(*fcb));
+
+ for (i = 0; i < numblocks; i++) {
+ memset(ecc_buf, 0, ecc_buf_size);
+ psrc = tmp_buf + i * blocksize;
+ pdst = buf + i * (blocksize + ecc_buf_size);
+
+ /* copy data byte aligned to destination buf */
+ memcpy(pdst, psrc, blocksize);
+
+ /*
+ * imx-kobs use a modified encode_bch which reverse the
+ * bit order of the data before calculating bch.
+ * Do this in the buffer and use the bch lib here.
+ */
+ for (j = 0; j < blocksize; j++)
+ psrc[j] = reverse_bit(psrc[j]);
+
+ encode_bch(bch, psrc, blocksize, ecc_buf);
+
+ /* reverse ecc bit */
+ for (j = 0; j < ecc_buf_size; j++)
+ ecc_buf[j] = reverse_bit(ecc_buf[j]);
+
+ /* Here eccbuf is byte aligned and we can just copy it */
+ memcpy(pdst + blocksize, ecc_buf, ecc_buf_size);
+ }
+
+ free(ecc_buf);
+ free(tmp_buf);
+ free_bch(bch);
+}
+
+struct fcb_block *read_fcb_bch(void *rawpage, int eccbits)
+{
+ int i, j, ret, errbit, m = 13;
+ int blocksize = 128;
+ int numblocks = 8;
+ int ecc_buf_size = (m * eccbits + 7) / 8;
+ struct bch_control *bch = init_bch(m, eccbits, 0);
+ uint8_t *fcb = xmalloc(numblocks * blocksize);
+ uint8_t *ecc_buf = xmalloc(ecc_buf_size);
+ uint8_t *data_buf = xmalloc(blocksize);
+ unsigned int *errloc = xmalloc(eccbits * sizeof(*errloc));
+ uint8_t *psrc, *pdst;
+
+ /* see encode_bch_ecc */
+ BUG_ON(eccbits % 8);
+
+ for (i = 0; i < numblocks; i++) {
+ psrc = rawpage + 32 + i * (blocksize + ecc_buf_size);
+ pdst = fcb + i * blocksize;
+
+ /* reverse data bit */
+ for (j = 0; j < blocksize; j++)
+ data_buf[j] = reverse_bit(psrc[j]);
+
+ /* reverse ecc bit */
+ for (j = 0; j < ecc_buf_size; j++)
+ ecc_buf[j] = reverse_bit(psrc[j + blocksize]);
+
+ ret = decode_bch(bch, data_buf, blocksize, ecc_buf,
+ NULL, NULL, errloc);
+
+ if (ret < 0) {
+ pr_err("Uncorrectable error at block %d\n", i);
+ free(fcb);
+ fcb = ERR_PTR(ret);
+ goto out;
+ }
+ if (ret > 0)
+ pr_info("Found %d correctable errors in block %d\n",
+ ret, i);
+
+ for (j = 0; j < ret; j++) {
+ /*
+ * calculate the reverse position
+ * pos - (pos % 8) -> byte offset
+ * 7 - (pos % 8) -> reverse bit position
+ */
+ errbit = errloc[j] - 2 * (errloc[j] % 8) + 7;
+ pr_debug("Found error: bit %d in block %d\n",
+ errbit, i);
+ if (errbit < blocksize * 8)
+ change_bit(errbit, psrc);
+ /* else error in ecc, ignore it */
+ }
+ memcpy(pdst, psrc, blocksize);
+ }
+
+out:
+ free(data_buf);
+ free(ecc_buf);
+ free(errloc);
+ free_bch(bch);
+
+ return (struct fcb_block *)fcb;
+}
+
static void encode_hamming_13_8(void *_src, void *_ecc, size_t size)
{
int i;
@@ -312,7 +441,11 @@ static int read_fcb(struct mtd_info *mtd, int num, struct fcb_block **retfcb)
goto err;
}
- fcb = read_fcb_hamming_13_8(rawpage);
+ if (cpu_is_mx6ul())
+ fcb = read_fcb_bch(rawpage, 40);
+ else
+ fcb = read_fcb_hamming_13_8(rawpage);
+
if (IS_ERR(fcb)) {
pr_err("Cannot read fcb\n");
ret = PTR_ERR(fcb);
@@ -766,8 +899,14 @@ static int imx_bbu_write_fcbs_dbbts(struct mtd_info *mtd, struct fcb_block *fcb)
fcb_raw_page = xzalloc(mtd->writesize + mtd->oobsize);
- memcpy(fcb_raw_page + 12, fcb, sizeof(struct fcb_block));
- encode_hamming_13_8(fcb_raw_page + 12, fcb_raw_page + 12 + 512, 512);
+ if (cpu_is_mx6ul()) {
+ /* 40 bit BCH, for i.MX6UL */
+ encode_bch_ecc(fcb_raw_page + 32, fcb, 40);
+ } else {
+ memcpy(fcb_raw_page + 12, fcb, sizeof(struct fcb_block));
+ encode_hamming_13_8(fcb_raw_page + 12,
+ fcb_raw_page + 12 + 512, 512);
+ }
dbbt = dbbt_data_create(mtd);