Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

/*

 * Copyright (c) International Business Machines Corp., 2006

 * Copyright (c) Nokia Corporation, 2006, 2007

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See

 * the GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

 *

 * Author: Artem Bityutskiy (Битюцкий Артём)

 */

/*

 * UBI input/output unit.

 *

 * This unit provides a uniform way to work with all kinds of the underlying

 * MTD devices. It also implements handy functions for reading and writing UBI

 * headers.

 *

 * We are trying to have a paranoid mindset and not to trust to what we read

 * from the flash media in order to be more secure and robust. So this unit

 * validates every single header it reads from the flash media.

 *

 * Some words about how the eraseblock headers are stored.

 *

 * The erase counter header is always stored at offset zero. By default, the

 * VID header is stored after the EC header at the closest aligned offset

 * (i.e. aligned to the minimum I/O unit size). Data starts next to the VID

 * header at the closest aligned offset. But this default layout may be

 * changed. For example, for different reasons (e.g., optimization) UBI may be

 * asked to put the VID header at further offset, and even at an unaligned

 * offset. Of course, if the offset of the VID header is unaligned, UBI adds

 * proper padding in front of it. Data offset may also be changed but it has to

 * be aligned.

 *

 * About minimal I/O units. In general, UBI assumes flash device model where

 * there is only one minimal I/O unit size. E.g., in case of NOR flash it is 1,

 * in case of NAND flash it is a NAND page, etc. This is reported by MTD in the

 * @ubi->mtd->writesize field. But as an exception, UBI admits of using another

 * (smaller) minimal I/O unit size for EC and VID headers to make it possible

 * to do different optimizations.

 *

 * This is extremely useful in case of NAND flashes which admit of several

 * write operations to one NAND page. In this case UBI can fit EC and VID

 * headers at one NAND page. Thus, UBI may use "sub-page" size as the minimal

 * I/O unit for the headers (the @ubi->hdrs_min_io_size field). But it still

 * reports NAND page size (@ubi->min_io_size) as a minimal I/O unit for the UBI

 * users.

 *

 * Example: some Samsung NANDs with 2KiB pages allow 4x 512-byte writes, so

 * although the minimal I/O unit is 2K, UBI uses 512 bytes for EC and VID

 * headers.

 *

 * Q: why not just to treat sub-page as a minimal I/O unit of this flash

 * device, e.g., make @ubi->min_io_size = 512 in the example above?

 *

 * A: because when writing a sub-page, MTD still writes a full 2K page but the

 * bytes which are no relevant to the sub-page are 0xFF. So, basically, writing

 * 4x512 sub-pages is 4 times slower then writing one 2KiB NAND page. Thus, we

 * prefer to use sub-pages only for EV and VID headers.

 *

 * As it was noted above, the VID header may start at a non-aligned offset.

 * For example, in case of a 2KiB page NAND flash with a 512 bytes sub-page,

 * the VID header may reside at offset 1984 which is the last 64 bytes of the

 * last sub-page (EC header is always at offset zero). This causes some

 * difficulties when reading and writing VID headers.

 *

 * Suppose we have a 64-byte buffer and we read a VID header at it. We change

 * the data and want to write this VID header out. As we can only write in

 * 512-byte chunks, we have to allocate one more buffer and copy our VID header

 * to offset 448 of this buffer.

 *

 * The I/O unit does the following trick in order to avoid this extra copy.

 * It always allocates a @ubi->vid_hdr_alsize bytes buffer for the VID header

 * and returns a pointer to offset @ubi->vid_hdr_shift of this buffer. When the

 * VID header is being written out, it shifts the VID header pointer back and

 * writes the whole sub-page.

 */

#include <linux/crc32.h>

#include <linux/err.h>

#include "ubi.h"

#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID

static int paranoid_check_not_bad(const struct ubi_device *ubi, int pnum);

static int paranoid_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum);

static int paranoid_check_ec_hdr(const struct ubi_device *ubi, int pnum,

                                 const struct ubi_ec_hdr *ec_hdr);

static int paranoid_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum);

static int paranoid_check_vid_hdr(const struct ubi_device *ubi, int pnum,

                                  const struct ubi_vid_hdr *vid_hdr);

static int paranoid_check_all_ff(struct ubi_device *ubi, int pnum, int offset,

                                 int len);

#else

#define paranoid_check_not_bad(ubi, pnum) 0

#define paranoid_check_peb_ec_hdr(ubi, pnum)  0

#define paranoid_check_ec_hdr(ubi, pnum, ec_hdr)  0

#define paranoid_check_peb_vid_hdr(ubi, pnum) 0

#define paranoid_check_vid_hdr(ubi, pnum, vid_hdr) 0

#define paranoid_check_all_ff(ubi, pnum, offset, len) 0

#endif

/**

 * ubi_io_read - read data from a physical eraseblock.

 * @ubi: UBI device description object

 * @buf: buffer where to store the read data

 * @pnum: physical eraseblock number to read from

 * @offset: offset within the physical eraseblock from where to read

 * @len: how many bytes to read

 *

 * This function reads data from offset @offset of physical eraseblock @pnum

 * and stores the read data in the @buf buffer. The following return codes are

 * possible:

 *

 * o %0 if all the requested data were successfully read;

 * o %UBI_IO_BITFLIPS if all the requested data were successfully read, but

 *   correctable bit-flips were detected; this is harmless but may indicate

 *   that this eraseblock may become bad soon (but do not have to);

 * o %-EBADMSG if the MTD subsystem reported about data integrity problems, for

 *   example it can be an ECC error in case of NAND; this most probably means

 *   that the data is corrupted;

 * o %-EIO if some I/O error occurred;

 * o other negative error codes in case of other errors.

 */

int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset,

                int len)

{

        int err, retries = 0;

        size_t read;

        loff_t addr;

        dbg_io("read %d bytes from PEB %d:%d", len, pnum, offset);

        ubi_assert(pnum >= 0 && pnum < ubi->peb_count);

        ubi_assert(offset >= 0 && offset + len <= ubi->peb_size);

        ubi_assert(len > 0);

        err = paranoid_check_not_bad(ubi, pnum);

        if (err)

                return err > 0 ? -EINVAL : err;

        addr = (loff_t)pnum * ubi->peb_size + offset;

retry:

        err = ubi->mtd->read(ubi->mtd, addr, len, &read, buf);

        if (err) {

                if (err == -EUCLEAN) {

                        /*

                         * -EUCLEAN is reported if there was a bit-flip which

                         * was corrected, so this is harmless.

                         */

                        ubi_msg("fixable bit-flip detected at PEB %d", pnum);

                        ubi_assert(len == read);

                        return UBI_IO_BITFLIPS;

                }

                if (read != len && retries++ < UBI_IO_RETRIES) {

                        dbg_io("error %d while reading %d bytes from PEB %d:%d, "

                               "read only %zd bytes, retry",

                               err, len, pnum, offset, read);

                        yield();

                        goto retry;

                }

                ubi_err("error %d while reading %d bytes from PEB %d:%d, "

                        "read %zd bytes", err, len, pnum, offset, read);

                ubi_dbg_dump_stack();

        } else {

                ubi_assert(len == read);

                if (ubi_dbg_is_bitflip()) {

                        dbg_msg("bit-flip (emulated)");

                        err = UBI_IO_BITFLIPS;

                }

        }

        return err;

}

/**

 * ubi_io_write - write data to a physical eraseblock.

 * @ubi: UBI device description object

 * @buf: buffer with the data to write

 * @pnum: physical eraseblock number to write to

 * @offset: offset within the physical eraseblock where to write

 * @len: how many bytes to write

 *

 * This function writes @len bytes of data from buffer @buf to offset @offset

 * of physical eraseblock @pnum. If all the data were successfully written,

 * zero is returned. If an error occurred, this function returns a negative

 * error code. If %-EIO is returned, the physical eraseblock most probably went

 * bad.

 *

 * Note, in case of an error, it is possible that something was still written

 * to the flash media, but may be some garbage.

 */

int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,

                 int len)

{

        int err;

        size_t written;

        loff_t addr;

        dbg_io("write %d bytes to PEB %d:%d", len, pnum, offset);

        ubi_assert(pnum >= 0 && pnum < ubi->peb_count);

        ubi_assert(offset >= 0 && offset + len <= ubi->peb_size);

        ubi_assert(offset % ubi->hdrs_min_io_size == 0);

        ubi_assert(len > 0 && len % ubi->hdrs_min_io_size == 0);

        if (ubi->ro_mode) {

                ubi_err("read-only mode");

                return -EROFS;

        }

        /* The below has to be compiled out if paranoid checks are disabled */

        err = paranoid_check_not_bad(ubi, pnum);

        if (err)

                return err > 0 ? -EINVAL : err;

        /* The area we are writing to has to contain all 0xFF bytes */

        err = paranoid_check_all_ff(ubi, pnum, offset, len);

        if (err)

                return err > 0 ? -EINVAL : err;

        if (offset >= ubi->leb_start) {

                /*

                 * We write to the data area of the physical eraseblock. Make

                 * sure it has valid EC and VID headers.

                 */

                err = paranoid_check_peb_ec_hdr(ubi, pnum);

                if (err)

                        return err > 0 ? -EINVAL : err;

                err = paranoid_check_peb_vid_hdr(ubi, pnum);

                if (err)

                        return err > 0 ? -EINVAL : err;

        }

        if (ubi_dbg_is_write_failure()) {

                dbg_err("cannot write %d bytes to PEB %d:%d "

                        "(emulated)", len, pnum, offset);

                ubi_dbg_dump_stack();

                return -EIO;

        }

        addr = (loff_t)pnum * ubi->peb_size + offset;

        err = ubi->mtd->write(ubi->mtd, addr, len, &written, buf);

        if (err) {

                ubi_err("error %d while writing %d bytes to PEB %d:%d, written"

                        " %zd bytes", err, len, pnum, offset, written);

                ubi_dbg_dump_stack();

        } else

                ubi_assert(written == len);

        return err;

}

/**

 * erase_callback - MTD erasure call-back.

 * @ei: MTD erase information object.

 *

 * Note, even though MTD erase interface is asynchronous, all the current

 * implementations are synchronous anyway.

 */

static void erase_callback(struct erase_info *ei)

{

        wake_up_interruptible((wait_queue_head_t *)ei->priv);

}

/**

 * do_sync_erase - synchronously erase a physical eraseblock.

 * @ubi: UBI device description object

 * @pnum: the physical eraseblock number to erase

 *

 * This function synchronously erases physical eraseblock @pnum and returns

 * zero in case of success and a negative error code in case of failure. If

 * %-EIO is returned, the physical eraseblock most probably went bad.

 */

static int do_sync_erase(struct ubi_device *ubi, int pnum)

{

        int err, retries = 0;

        struct erase_info ei;

        wait_queue_head_t wq;

        dbg_io("erase PEB %d", pnum);

retry:

        init_waitqueue_head(&wq);

        memset(&ei, 0, sizeof(struct erase_info));

        ei.mtd      = ubi->mtd;

        ei.addr     = (loff_t)pnum * ubi->peb_size;

        ei.len      = ubi->peb_size;

        ei.callback = erase_callback;

        ei.priv     = (unsigned long)&wq;

        err = ubi->mtd->erase(ubi->mtd, &ei);

        if (err) {

                if (retries++ < UBI_IO_RETRIES) {

                        dbg_io("error %d while erasing PEB %d, retry",

                               err, pnum);

                        yield();

                        goto retry;

                }

                ubi_err("cannot erase PEB %d, error %d", pnum, err);

                ubi_dbg_dump_stack();

                return err;

        }

        err = wait_event_interruptible(wq, ei.state == MTD_ERASE_DONE ||

                                           ei.state == MTD_ERASE_FAILED);

        if (err) {

                ubi_err("interrupted PEB %d erasure", pnum);

                return -EINTR;

        }

        if (ei.state == MTD_ERASE_FAILED) {

                if (retries++ < UBI_IO_RETRIES) {

                        dbg_io("error while erasing PEB %d, retry", pnum);

                        yield();

                        goto retry;

                }

                ubi_err("cannot erase PEB %d", pnum);

                ubi_dbg_dump_stack();

                return -EIO;

        }

        err = paranoid_check_all_ff(ubi, pnum, 0, ubi->peb_size);

        if (err)

                return err > 0 ? -EINVAL : err;

        if (ubi_dbg_is_erase_failure() && !err) {

                dbg_err("cannot erase PEB %d (emulated)", pnum);

                return -EIO;

        }

        return 0;

}

/**

 * check_pattern - check if buffer contains only a certain byte pattern.

 * @buf: buffer to check

 * @patt: the pattern to check

 * @size: buffer size in bytes

 *

 * This function returns %1 in there are only @patt bytes in @buf, and %0 if

 * something else was also found.

 */

static int check_pattern(const void *buf, uint8_t patt, int size)

{

        int i;

        for (i = 0; i < size; i++)

                if (((const uint8_t *)buf)[i] != patt)

                        return 0;

        return 1;

}

/* Patterns to write to a physical eraseblock when torturing it */

static uint8_t patterns[] = {0xa5, 0x5a, 0x0};

/**

 * torture_peb - test a supposedly bad physical eraseblock.

 * @ubi: UBI device description object

 * @pnum: the physical eraseblock number to test

 *

 * This function returns %-EIO if the physical eraseblock did not pass the

 * test, a positive number of erase operations done if the test was

 * successfully passed, and other negative error codes in case of other errors.

 */

static int torture_peb(struct ubi_device *ubi, int pnum)

{

        int err, i, patt_count;

        patt_count = ARRAY_SIZE(patterns);

        ubi_assert(patt_count > 0);

        mutex_lock(&ubi->buf_mutex);

        for (i = 0; i < patt_count; i++) {

                err = do_sync_erase(ubi, pnum);

                if (err)

                        goto out;

                /* Make sure the PEB contains only 0xFF bytes */

                err = ubi_io_read(ubi, ubi->peb_buf1, pnum, 0, ubi->peb_size);

                if (err)

                        goto out;

                err = check_pattern(ubi->peb_buf1, 0xFF, ubi->peb_size);

                if (err == 0) {

                        ubi_err("erased PEB %d, but a non-0xFF byte found",

                                pnum);

                        err = -EIO;

                        goto out;

                }

                /* Write a pattern and check it */

                memset(ubi->peb_buf1, patterns[i], ubi->peb_size);

                err = ubi_io_write(ubi, ubi->peb_buf1, pnum, 0, ubi->peb_size);

                if (err)

                        goto out;

                memset(ubi->peb_buf1, ~patterns[i], ubi->peb_size);

                err = ubi_io_read(ubi, ubi->peb_buf1, pnum, 0, ubi->peb_size);

                if (err)

                        goto out;

                err = check_pattern(ubi->peb_buf1, patterns[i], ubi->peb_size);

                if (err == 0) {

                        ubi_err("pattern %x checking failed for PEB %d",

                                patterns[i], pnum);

                        err = -EIO;

                        goto out;

                }

        }

        err = patt_count;

out:

        mutex_unlock(&ubi->buf_mutex);

        if (err == UBI_IO_BITFLIPS || err == -EBADMSG) {

                /*

                 * If a bit-flip or data integrity error was detected, the test

                 * has not passed because it happened on a freshly erased

                 * physical eraseblock which means something is wrong with it.

                 */

                ubi_err("read problems on freshly erased PEB %d, must be bad",

                        pnum);

                err = -EIO;

        }

        return err;

}

/**

 * ubi_io_sync_erase - synchronously erase a physical eraseblock.

 * @ubi: UBI device description object

 * @pnum: physical eraseblock number to erase

 * @torture: if this physical eraseblock has to be tortured

 *

 * This function synchronously erases physical eraseblock @pnum. If @torture

 * flag is not zero, the physical eraseblock is checked by means of writing

 * different patterns to it and reading them back. If the torturing is enabled,

 * the physical eraseblock is erased more then once.

 *

 * This function returns the number of erasures made in case of success, %-EIO

 * if the erasure failed or the torturing test failed, and other negative error

 * codes in case of other errors. Note, %-EIO means that the physical

 * eraseblock is bad.

 */

int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture)

{

        int err, ret = 0;

        ubi_assert(pnum >= 0 && pnum < ubi->peb_count);

        err = paranoid_check_not_bad(ubi, pnum);

        if (err != 0)

                return err > 0 ? -EINVAL : err;

        if (ubi->ro_mode) {

                ubi_err("read-only mode");

                return -EROFS;

        }

        if (torture) {

                ret = torture_peb(ubi, pnum);

                if (ret < 0)

                        return ret;

        }

        err = do_sync_erase(ubi, pnum);

        if (err)

                return err;

        return ret + 1;

}

/**

 * ubi_io_is_bad - check if a physical eraseblock is bad.

 * @ubi: UBI device description object

 * @pnum: the physical eraseblock number to check

 *

 * This function returns a positive number if the physical eraseblock is bad,

 * zero if not, and a negative error code if an error occurred.

 */

int ubi_io_is_bad(const struct ubi_device *ubi, int pnum)

{

        struct mtd_info *mtd = ubi->mtd;

        ubi_assert(pnum >= 0 && pnum < ubi->peb_count);

        if (ubi->bad_allowed) {

                int ret;

                ret = mtd->block_isbad(mtd, (loff_t)pnum * ubi->peb_size);

                if (ret < 0)

                        ubi_err("error %d while checking if PEB %d is bad",

                                ret, pnum);

                else if (ret)

                        dbg_io("PEB %d is bad", pnum);

                return ret;

        }

        return 0;

}

/**

 * ubi_io_mark_bad - mark a physical eraseblock as bad.

 * @ubi: UBI device description object

 * @pnum: the physical eraseblock number to mark

 *

 * This function returns zero in case of success and a negative error code in

 * case of failure.

 */

int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum)

{

        int err;

        struct mtd_info *mtd = ubi->mtd;

        ubi_assert(pnum >= 0 && pnum < ubi->peb_count);

        if (ubi->ro_mode) {

                ubi_err("read-only mode");

                return -EROFS;

        }

        if (!ubi->bad_allowed)

                return 0;

        err = mtd->block_markbad(mtd, (loff_t)pnum * ubi->peb_size);

        if (err)

                ubi_err("cannot mark PEB %d bad, error %d", pnum, err);

        return err;

}

/**

 * validate_ec_hdr - validate an erase counter header.

 * @ubi: UBI device description object

 * @ec_hdr: the erase counter header to check

 *

 * This function returns zero if the erase counter header is OK, and %1 if

 * not.

 */

static int validate_ec_hdr(const struct ubi_device *ubi,

                           const struct ubi_ec_hdr *ec_hdr)

{

        long long ec;

        int vid_hdr_offset, leb_start;

        ec = be64_to_cpu(ec_hdr->ec);

        vid_hdr_offset = be32_to_cpu(ec_hdr->vid_hdr_offset);

        leb_start = be32_to_cpu(ec_hdr->data_offset);

        if (ec_hdr->version != UBI_VERSION) {

                ubi_err("node with incompatible UBI version found: "

                        "this UBI version is %d, image version is %d",

                        UBI_VERSION, (int)ec_hdr->version);

                goto bad;

        }

        if (vid_hdr_offset != ubi->vid_hdr_offset) {

                ubi_err("bad VID header offset %d, expected %d",

                        vid_hdr_offset, ubi->vid_hdr_offset);

                goto bad;

        }

        if (leb_start != ubi->leb_start) {

                ubi_err("bad data offset %d, expected %d",

                        leb_start, ubi->leb_start);

                goto bad;

        }

        if (ec < 0 || ec > UBI_MAX_ERASECOUNTER) {

                ubi_err("bad erase counter %lld", ec);

                goto bad;

        }

        return 0;

bad:

        ubi_err("bad EC header");

        ubi_dbg_dump_ec_hdr(ec_hdr);

        ubi_dbg_dump_stack();

        return 1;

}

/**

 * ubi_io_read_ec_hdr - read and check an erase counter header.

 * @ubi: UBI device description object

 * @pnum: physical eraseblock to read from

 * @ec_hdr: a &struct ubi_ec_hdr object where to store the read erase counter

 * header

 * @verbose: be verbose if the header is corrupted or was not found

 *

 * This function reads erase counter header from physical eraseblock @pnum and

 * stores it in @ec_hdr. This function also checks CRC checksum of the read

 * erase counter header. The following codes may be returned:

 *

 * o %0 if the CRC checksum is correct and the header was successfully read;

 * o %UBI_IO_BITFLIPS if the CRC is correct, but bit-flips were detected

 *   and corrected by the flash driver; this is harmless but may indicate that

 *   this eraseblock may become bad soon (but may be not);

 * o %UBI_IO_BAD_EC_HDR if the erase counter header is corrupted (a CRC error);

 * o %UBI_IO_PEB_EMPTY if the physical eraseblock is empty;

 * o a negative error code in case of failure.

 */

int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,

                       struct ubi_ec_hdr *ec_hdr, int verbose)

{

        int err, read_err = 0;

        uint32_t crc, magic, hdr_crc;

        dbg_io("read EC header from PEB %d", pnum);

        ubi_assert(pnum >= 0 && pnum < ubi->peb_count);

        err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);

        if (err) {

                if (err != UBI_IO_BITFLIPS && err != -EBADMSG)

                        return err;

                /*

                 * We read all the data, but either a correctable bit-flip

                 * occurred, or MTD reported about some data integrity error,

                 * like an ECC error in case of NAND. The former is harmless,

                 * the later may mean that the read data is corrupted. But we

                 * have a CRC check-sum and we will detect this. If the EC

                 * header is still OK, we just report this as there was a

                 * bit-flip.

                 */

                read_err = err;

        }

        magic = be32_to_cpu(ec_hdr->magic);

        if (magic != UBI_EC_HDR_MAGIC) {

                /*

                 * The magic field is wrong. Let's check if we have read all

                 * 0xFF. If yes, this physical eraseblock is assumed to be

                 * empty.

                 *

                 * But if there was a read error, we do not test it for all

                 * 0xFFs. Even if it does contain all 0xFFs, this error

                 * indicates that something is still wrong with this physical

                 * eraseblock and we anyway cannot treat it as empty.

                 */

                if (read_err != -EBADMSG &&

                    check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {

                        /* The physical eraseblock is supposedly empty */

                        /*

                         * The below is just a paranoid check, it has to be

                         * compiled out if paranoid checks are disabled.

                         */

                        err = paranoid_check_all_ff(ubi, pnum, 0,

                                                    ubi->peb_size);

                        if (err)

                                return err > 0 ? UBI_IO_BAD_EC_HDR : err;

                        if (verbose)

                                ubi_warn("no EC header found at PEB %d, "

                                         "only 0xFF bytes", pnum);

                        return UBI_IO_PEB_EMPTY;

                }

                /*

                 * This is not a valid erase counter header, and these are not

                 * 0xFF bytes. Report that the header is corrupted.

                 */

                if (verbose) {

                        ubi_warn("bad magic number at PEB %d: %08x instead of "

                                 "%08x", pnum, magic, UBI_EC_HDR_MAGIC);

                        ubi_dbg_dump_ec_hdr(ec_hdr);

                }

                return UBI_IO_BAD_EC_HDR;

        }

        crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);

        hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);

        if (hdr_crc != crc) {

                if (verbose) {

                        ubi_warn("bad EC header CRC at PEB %d, calculated %#08x,"

                                 " read %#08x", pnum, crc, hdr_crc);

                        ubi_dbg_dump_ec_hdr(ec_hdr);

                }

                return UBI_IO_BAD_EC_HDR;

        }

        /* And of course validate what has just been read from the media */

        err = validate_ec_hdr(ubi, ec_hdr);

        if (err) {

                ubi_err("validation failed for PEB %d", pnum);

                return -EINVAL;

        }

        return read_err ? UBI_IO_BITFLIPS : 0;

}

/**

 * ubi_io_write_ec_hdr - write an erase counter header.

 * @ubi: UBI device description object

 * @pnum: physical eraseblock to write to

 * @ec_hdr: the erase counter header to write

 *

 * This function writes erase counter header described by @ec_hdr to physical

 * eraseblock @pnum. It also fills most fields of @ec_hdr before writing, so

 * the caller do not have to fill them. Callers must only fill the @ec_hdr->ec

 * field.

 *

 * This function returns zero in case of success and a negative error code in

 * case of failure. If %-EIO is returned, the physical eraseblock most probably

 * went bad.

 */

int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,

                        struct ubi_ec_hdr *ec_hdr)

{

        int err;