12d262c48SKyungmin Park /* 22d262c48SKyungmin Park * Copyright (c) International Business Machines Corp., 2006 32d262c48SKyungmin Park * Copyright (c) Nokia Corporation, 2006, 2007 41a459660SWolfgang Denk * SPDX-License-Identifier: GPL-2.0+ 52d262c48SKyungmin Park * 62d262c48SKyungmin Park * Author: Artem Bityutskiy (Битюцкий Артём) 72d262c48SKyungmin Park */ 82d262c48SKyungmin Park 92d262c48SKyungmin Park /* 10*ff94bc40SHeiko Schocher * UBI input/output sub-system. 112d262c48SKyungmin Park * 12*ff94bc40SHeiko Schocher * This sub-system provides a uniform way to work with all kinds of the 13*ff94bc40SHeiko Schocher * underlying MTD devices. It also implements handy functions for reading and 14*ff94bc40SHeiko Schocher * writing UBI headers. 152d262c48SKyungmin Park * 162d262c48SKyungmin Park * We are trying to have a paranoid mindset and not to trust to what we read 17*ff94bc40SHeiko Schocher * from the flash media in order to be more secure and robust. So this 18*ff94bc40SHeiko Schocher * sub-system validates every single header it reads from the flash media. 192d262c48SKyungmin Park * 202d262c48SKyungmin Park * Some words about how the eraseblock headers are stored. 212d262c48SKyungmin Park * 222d262c48SKyungmin Park * The erase counter header is always stored at offset zero. By default, the 232d262c48SKyungmin Park * VID header is stored after the EC header at the closest aligned offset 242d262c48SKyungmin Park * (i.e. aligned to the minimum I/O unit size). Data starts next to the VID 252d262c48SKyungmin Park * header at the closest aligned offset. But this default layout may be 262d262c48SKyungmin Park * changed. For example, for different reasons (e.g., optimization) UBI may be 272d262c48SKyungmin Park * asked to put the VID header at further offset, and even at an unaligned 282d262c48SKyungmin Park * offset. Of course, if the offset of the VID header is unaligned, UBI adds 292d262c48SKyungmin Park * proper padding in front of it. Data offset may also be changed but it has to 302d262c48SKyungmin Park * be aligned. 312d262c48SKyungmin Park * 322d262c48SKyungmin Park * About minimal I/O units. In general, UBI assumes flash device model where 332d262c48SKyungmin Park * there is only one minimal I/O unit size. E.g., in case of NOR flash it is 1, 342d262c48SKyungmin Park * in case of NAND flash it is a NAND page, etc. This is reported by MTD in the 352d262c48SKyungmin Park * @ubi->mtd->writesize field. But as an exception, UBI admits of using another 362d262c48SKyungmin Park * (smaller) minimal I/O unit size for EC and VID headers to make it possible 372d262c48SKyungmin Park * to do different optimizations. 382d262c48SKyungmin Park * 392d262c48SKyungmin Park * This is extremely useful in case of NAND flashes which admit of several 402d262c48SKyungmin Park * write operations to one NAND page. In this case UBI can fit EC and VID 412d262c48SKyungmin Park * headers at one NAND page. Thus, UBI may use "sub-page" size as the minimal 422d262c48SKyungmin Park * I/O unit for the headers (the @ubi->hdrs_min_io_size field). But it still 432d262c48SKyungmin Park * reports NAND page size (@ubi->min_io_size) as a minimal I/O unit for the UBI 442d262c48SKyungmin Park * users. 452d262c48SKyungmin Park * 462d262c48SKyungmin Park * Example: some Samsung NANDs with 2KiB pages allow 4x 512-byte writes, so 472d262c48SKyungmin Park * although the minimal I/O unit is 2K, UBI uses 512 bytes for EC and VID 482d262c48SKyungmin Park * headers. 492d262c48SKyungmin Park * 502d262c48SKyungmin Park * Q: why not just to treat sub-page as a minimal I/O unit of this flash 512d262c48SKyungmin Park * device, e.g., make @ubi->min_io_size = 512 in the example above? 522d262c48SKyungmin Park * 532d262c48SKyungmin Park * A: because when writing a sub-page, MTD still writes a full 2K page but the 54*ff94bc40SHeiko Schocher * bytes which are not relevant to the sub-page are 0xFF. So, basically, 55*ff94bc40SHeiko Schocher * writing 4x512 sub-pages is 4 times slower than writing one 2KiB NAND page. 56*ff94bc40SHeiko Schocher * Thus, we prefer to use sub-pages only for EC and VID headers. 572d262c48SKyungmin Park * 582d262c48SKyungmin Park * As it was noted above, the VID header may start at a non-aligned offset. 592d262c48SKyungmin Park * For example, in case of a 2KiB page NAND flash with a 512 bytes sub-page, 602d262c48SKyungmin Park * the VID header may reside at offset 1984 which is the last 64 bytes of the 612d262c48SKyungmin Park * last sub-page (EC header is always at offset zero). This causes some 622d262c48SKyungmin Park * difficulties when reading and writing VID headers. 632d262c48SKyungmin Park * 642d262c48SKyungmin Park * Suppose we have a 64-byte buffer and we read a VID header at it. We change 652d262c48SKyungmin Park * the data and want to write this VID header out. As we can only write in 662d262c48SKyungmin Park * 512-byte chunks, we have to allocate one more buffer and copy our VID header 672d262c48SKyungmin Park * to offset 448 of this buffer. 682d262c48SKyungmin Park * 69*ff94bc40SHeiko Schocher * The I/O sub-system does the following trick in order to avoid this extra 70*ff94bc40SHeiko Schocher * copy. It always allocates a @ubi->vid_hdr_alsize bytes buffer for the VID 71*ff94bc40SHeiko Schocher * header and returns a pointer to offset @ubi->vid_hdr_shift of this buffer. 72*ff94bc40SHeiko Schocher * When the VID header is being written out, it shifts the VID header pointer 73*ff94bc40SHeiko Schocher * back and writes the whole sub-page. 742d262c48SKyungmin Park */ 752d262c48SKyungmin Park 76*ff94bc40SHeiko Schocher #define __UBOOT__ 77*ff94bc40SHeiko Schocher #ifndef __UBOOT__ 782d262c48SKyungmin Park #include <linux/crc32.h> 792d262c48SKyungmin Park #include <linux/err.h> 80*ff94bc40SHeiko Schocher #include <linux/slab.h> 81*ff94bc40SHeiko Schocher #else 82*ff94bc40SHeiko Schocher #include <ubi_uboot.h> 832d262c48SKyungmin Park #endif 842d262c48SKyungmin Park 852d262c48SKyungmin Park #include "ubi.h" 862d262c48SKyungmin Park 87*ff94bc40SHeiko Schocher static int self_check_not_bad(const struct ubi_device *ubi, int pnum); 88*ff94bc40SHeiko Schocher static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum); 89*ff94bc40SHeiko Schocher static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum, 902d262c48SKyungmin Park const struct ubi_ec_hdr *ec_hdr); 91*ff94bc40SHeiko Schocher static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum); 92*ff94bc40SHeiko Schocher static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum, 932d262c48SKyungmin Park const struct ubi_vid_hdr *vid_hdr); 94*ff94bc40SHeiko Schocher static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum, 95*ff94bc40SHeiko Schocher int offset, int len); 962d262c48SKyungmin Park 972d262c48SKyungmin Park /** 982d262c48SKyungmin Park * ubi_io_read - read data from a physical eraseblock. 992d262c48SKyungmin Park * @ubi: UBI device description object 1002d262c48SKyungmin Park * @buf: buffer where to store the read data 1012d262c48SKyungmin Park * @pnum: physical eraseblock number to read from 1022d262c48SKyungmin Park * @offset: offset within the physical eraseblock from where to read 1032d262c48SKyungmin Park * @len: how many bytes to read 1042d262c48SKyungmin Park * 1052d262c48SKyungmin Park * This function reads data from offset @offset of physical eraseblock @pnum 1062d262c48SKyungmin Park * and stores the read data in the @buf buffer. The following return codes are 1072d262c48SKyungmin Park * possible: 1082d262c48SKyungmin Park * 1092d262c48SKyungmin Park * o %0 if all the requested data were successfully read; 1102d262c48SKyungmin Park * o %UBI_IO_BITFLIPS if all the requested data were successfully read, but 1112d262c48SKyungmin Park * correctable bit-flips were detected; this is harmless but may indicate 1122d262c48SKyungmin Park * that this eraseblock may become bad soon (but do not have to); 1132d262c48SKyungmin Park * o %-EBADMSG if the MTD subsystem reported about data integrity problems, for 1142d262c48SKyungmin Park * example it can be an ECC error in case of NAND; this most probably means 1152d262c48SKyungmin Park * that the data is corrupted; 1162d262c48SKyungmin Park * o %-EIO if some I/O error occurred; 1172d262c48SKyungmin Park * o other negative error codes in case of other errors. 1182d262c48SKyungmin Park */ 1192d262c48SKyungmin Park int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset, 1202d262c48SKyungmin Park int len) 1212d262c48SKyungmin Park { 1222d262c48SKyungmin Park int err, retries = 0; 1232d262c48SKyungmin Park size_t read; 1242d262c48SKyungmin Park loff_t addr; 1252d262c48SKyungmin Park 1262d262c48SKyungmin Park dbg_io("read %d bytes from PEB %d:%d", len, pnum, offset); 1272d262c48SKyungmin Park 1282d262c48SKyungmin Park ubi_assert(pnum >= 0 && pnum < ubi->peb_count); 1292d262c48SKyungmin Park ubi_assert(offset >= 0 && offset + len <= ubi->peb_size); 1302d262c48SKyungmin Park ubi_assert(len > 0); 1312d262c48SKyungmin Park 132*ff94bc40SHeiko Schocher err = self_check_not_bad(ubi, pnum); 1332d262c48SKyungmin Park if (err) 134*ff94bc40SHeiko Schocher return err; 135*ff94bc40SHeiko Schocher 136*ff94bc40SHeiko Schocher /* 137*ff94bc40SHeiko Schocher * Deliberately corrupt the buffer to improve robustness. Indeed, if we 138*ff94bc40SHeiko Schocher * do not do this, the following may happen: 139*ff94bc40SHeiko Schocher * 1. The buffer contains data from previous operation, e.g., read from 140*ff94bc40SHeiko Schocher * another PEB previously. The data looks like expected, e.g., if we 141*ff94bc40SHeiko Schocher * just do not read anything and return - the caller would not 142*ff94bc40SHeiko Schocher * notice this. E.g., if we are reading a VID header, the buffer may 143*ff94bc40SHeiko Schocher * contain a valid VID header from another PEB. 144*ff94bc40SHeiko Schocher * 2. The driver is buggy and returns us success or -EBADMSG or 145*ff94bc40SHeiko Schocher * -EUCLEAN, but it does not actually put any data to the buffer. 146*ff94bc40SHeiko Schocher * 147*ff94bc40SHeiko Schocher * This may confuse UBI or upper layers - they may think the buffer 148*ff94bc40SHeiko Schocher * contains valid data while in fact it is just old data. This is 149*ff94bc40SHeiko Schocher * especially possible because UBI (and UBIFS) relies on CRC, and 150*ff94bc40SHeiko Schocher * treats data as correct even in case of ECC errors if the CRC is 151*ff94bc40SHeiko Schocher * correct. 152*ff94bc40SHeiko Schocher * 153*ff94bc40SHeiko Schocher * Try to prevent this situation by changing the first byte of the 154*ff94bc40SHeiko Schocher * buffer. 155*ff94bc40SHeiko Schocher */ 156*ff94bc40SHeiko Schocher *((uint8_t *)buf) ^= 0xFF; 1572d262c48SKyungmin Park 1582d262c48SKyungmin Park addr = (loff_t)pnum * ubi->peb_size + offset; 1592d262c48SKyungmin Park retry: 160dfe64e2cSSergey Lapin err = mtd_read(ubi->mtd, addr, len, &read, buf); 1612d262c48SKyungmin Park if (err) { 162*ff94bc40SHeiko Schocher const char *errstr = mtd_is_eccerr(err) ? " (ECC error)" : ""; 163*ff94bc40SHeiko Schocher 164*ff94bc40SHeiko Schocher if (mtd_is_bitflip(err)) { 1652d262c48SKyungmin Park /* 1662d262c48SKyungmin Park * -EUCLEAN is reported if there was a bit-flip which 1672d262c48SKyungmin Park * was corrected, so this is harmless. 168*ff94bc40SHeiko Schocher * 169*ff94bc40SHeiko Schocher * We do not report about it here unless debugging is 170*ff94bc40SHeiko Schocher * enabled. A corresponding message will be printed 171*ff94bc40SHeiko Schocher * later, when it is has been scrubbed. 1722d262c48SKyungmin Park */ 1732d262c48SKyungmin Park ubi_msg("fixable bit-flip detected at PEB %d", pnum); 1742d262c48SKyungmin Park ubi_assert(len == read); 1752d262c48SKyungmin Park return UBI_IO_BITFLIPS; 1762d262c48SKyungmin Park } 1772d262c48SKyungmin Park 178*ff94bc40SHeiko Schocher if (retries++ < UBI_IO_RETRIES) { 179*ff94bc40SHeiko Schocher ubi_warn("error %d%s while reading %d bytes from PEB %d:%d, read only %zd bytes, retry", 180*ff94bc40SHeiko Schocher err, errstr, len, pnum, offset, read); 1812d262c48SKyungmin Park yield(); 1822d262c48SKyungmin Park goto retry; 1832d262c48SKyungmin Park } 1842d262c48SKyungmin Park 185*ff94bc40SHeiko Schocher ubi_err("error %d%s while reading %d bytes from PEB %d:%d, read %zd bytes", 186*ff94bc40SHeiko Schocher err, errstr, len, pnum, offset, read); 187*ff94bc40SHeiko Schocher dump_stack(); 1882d262c48SKyungmin Park 1892d262c48SKyungmin Park /* 1902d262c48SKyungmin Park * The driver should never return -EBADMSG if it failed to read 1912d262c48SKyungmin Park * all the requested data. But some buggy drivers might do 1922d262c48SKyungmin Park * this, so we change it to -EIO. 1932d262c48SKyungmin Park */ 194*ff94bc40SHeiko Schocher if (read != len && mtd_is_eccerr(err)) { 1952d262c48SKyungmin Park ubi_assert(0); 196*ff94bc40SHeiko Schocher err = -EIO; 1972d262c48SKyungmin Park } 1982d262c48SKyungmin Park } else { 1992d262c48SKyungmin Park ubi_assert(len == read); 2002d262c48SKyungmin Park 201*ff94bc40SHeiko Schocher if (ubi_dbg_is_bitflip(ubi)) { 202*ff94bc40SHeiko Schocher dbg_gen("bit-flip (emulated)"); 2032d262c48SKyungmin Park err = UBI_IO_BITFLIPS; 2042d262c48SKyungmin Park } 2052d262c48SKyungmin Park } 2062d262c48SKyungmin Park 2072d262c48SKyungmin Park return err; 2082d262c48SKyungmin Park } 2092d262c48SKyungmin Park 2102d262c48SKyungmin Park /** 2112d262c48SKyungmin Park * ubi_io_write - write data to a physical eraseblock. 2122d262c48SKyungmin Park * @ubi: UBI device description object 2132d262c48SKyungmin Park * @buf: buffer with the data to write 2142d262c48SKyungmin Park * @pnum: physical eraseblock number to write to 2152d262c48SKyungmin Park * @offset: offset within the physical eraseblock where to write 2162d262c48SKyungmin Park * @len: how many bytes to write 2172d262c48SKyungmin Park * 2182d262c48SKyungmin Park * This function writes @len bytes of data from buffer @buf to offset @offset 2192d262c48SKyungmin Park * of physical eraseblock @pnum. If all the data were successfully written, 2202d262c48SKyungmin Park * zero is returned. If an error occurred, this function returns a negative 2212d262c48SKyungmin Park * error code. If %-EIO is returned, the physical eraseblock most probably went 2222d262c48SKyungmin Park * bad. 2232d262c48SKyungmin Park * 2242d262c48SKyungmin Park * Note, in case of an error, it is possible that something was still written 2252d262c48SKyungmin Park * to the flash media, but may be some garbage. 2262d262c48SKyungmin Park */ 2272d262c48SKyungmin Park int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset, 2282d262c48SKyungmin Park int len) 2292d262c48SKyungmin Park { 2302d262c48SKyungmin Park int err; 2312d262c48SKyungmin Park size_t written; 2322d262c48SKyungmin Park loff_t addr; 2332d262c48SKyungmin Park 2342d262c48SKyungmin Park dbg_io("write %d bytes to PEB %d:%d", len, pnum, offset); 2352d262c48SKyungmin Park 2362d262c48SKyungmin Park ubi_assert(pnum >= 0 && pnum < ubi->peb_count); 2372d262c48SKyungmin Park ubi_assert(offset >= 0 && offset + len <= ubi->peb_size); 2382d262c48SKyungmin Park ubi_assert(offset % ubi->hdrs_min_io_size == 0); 2392d262c48SKyungmin Park ubi_assert(len > 0 && len % ubi->hdrs_min_io_size == 0); 2402d262c48SKyungmin Park 2412d262c48SKyungmin Park if (ubi->ro_mode) { 2422d262c48SKyungmin Park ubi_err("read-only mode"); 2432d262c48SKyungmin Park return -EROFS; 2442d262c48SKyungmin Park } 2452d262c48SKyungmin Park 246*ff94bc40SHeiko Schocher err = self_check_not_bad(ubi, pnum); 2472d262c48SKyungmin Park if (err) 248*ff94bc40SHeiko Schocher return err; 2492d262c48SKyungmin Park 2502d262c48SKyungmin Park /* The area we are writing to has to contain all 0xFF bytes */ 251*ff94bc40SHeiko Schocher err = ubi_self_check_all_ff(ubi, pnum, offset, len); 2522d262c48SKyungmin Park if (err) 253*ff94bc40SHeiko Schocher return err; 2542d262c48SKyungmin Park 2552d262c48SKyungmin Park if (offset >= ubi->leb_start) { 2562d262c48SKyungmin Park /* 2572d262c48SKyungmin Park * We write to the data area of the physical eraseblock. Make 2582d262c48SKyungmin Park * sure it has valid EC and VID headers. 2592d262c48SKyungmin Park */ 260*ff94bc40SHeiko Schocher err = self_check_peb_ec_hdr(ubi, pnum); 2612d262c48SKyungmin Park if (err) 262*ff94bc40SHeiko Schocher return err; 263*ff94bc40SHeiko Schocher err = self_check_peb_vid_hdr(ubi, pnum); 2642d262c48SKyungmin Park if (err) 265*ff94bc40SHeiko Schocher return err; 2662d262c48SKyungmin Park } 2672d262c48SKyungmin Park 268*ff94bc40SHeiko Schocher if (ubi_dbg_is_write_failure(ubi)) { 269*ff94bc40SHeiko Schocher ubi_err("cannot write %d bytes to PEB %d:%d (emulated)", 270*ff94bc40SHeiko Schocher len, pnum, offset); 271*ff94bc40SHeiko Schocher dump_stack(); 2722d262c48SKyungmin Park return -EIO; 2732d262c48SKyungmin Park } 2742d262c48SKyungmin Park 2752d262c48SKyungmin Park addr = (loff_t)pnum * ubi->peb_size + offset; 276dfe64e2cSSergey Lapin err = mtd_write(ubi->mtd, addr, len, &written, buf); 2772d262c48SKyungmin Park if (err) { 278*ff94bc40SHeiko Schocher ubi_err("error %d while writing %d bytes to PEB %d:%d, written %zd bytes", 279*ff94bc40SHeiko Schocher err, len, pnum, offset, written); 280*ff94bc40SHeiko Schocher dump_stack(); 281*ff94bc40SHeiko Schocher ubi_dump_flash(ubi, pnum, offset, len); 2822d262c48SKyungmin Park } else 2832d262c48SKyungmin Park ubi_assert(written == len); 2842d262c48SKyungmin Park 285*ff94bc40SHeiko Schocher if (!err) { 286*ff94bc40SHeiko Schocher err = self_check_write(ubi, buf, pnum, offset, len); 287*ff94bc40SHeiko Schocher if (err) 288*ff94bc40SHeiko Schocher return err; 289*ff94bc40SHeiko Schocher 290*ff94bc40SHeiko Schocher /* 291*ff94bc40SHeiko Schocher * Since we always write sequentially, the rest of the PEB has 292*ff94bc40SHeiko Schocher * to contain only 0xFF bytes. 293*ff94bc40SHeiko Schocher */ 294*ff94bc40SHeiko Schocher offset += len; 295*ff94bc40SHeiko Schocher len = ubi->peb_size - offset; 296*ff94bc40SHeiko Schocher if (len) 297*ff94bc40SHeiko Schocher err = ubi_self_check_all_ff(ubi, pnum, offset, len); 298*ff94bc40SHeiko Schocher } 299*ff94bc40SHeiko Schocher 3002d262c48SKyungmin Park return err; 3012d262c48SKyungmin Park } 3022d262c48SKyungmin Park 3032d262c48SKyungmin Park /** 3042d262c48SKyungmin Park * erase_callback - MTD erasure call-back. 3052d262c48SKyungmin Park * @ei: MTD erase information object. 3062d262c48SKyungmin Park * 3072d262c48SKyungmin Park * Note, even though MTD erase interface is asynchronous, all the current 3082d262c48SKyungmin Park * implementations are synchronous anyway. 3092d262c48SKyungmin Park */ 3102d262c48SKyungmin Park static void erase_callback(struct erase_info *ei) 3112d262c48SKyungmin Park { 3122d262c48SKyungmin Park wake_up_interruptible((wait_queue_head_t *)ei->priv); 3132d262c48SKyungmin Park } 3142d262c48SKyungmin Park 3152d262c48SKyungmin Park /** 3162d262c48SKyungmin Park * do_sync_erase - synchronously erase a physical eraseblock. 3172d262c48SKyungmin Park * @ubi: UBI device description object 3182d262c48SKyungmin Park * @pnum: the physical eraseblock number to erase 3192d262c48SKyungmin Park * 3202d262c48SKyungmin Park * This function synchronously erases physical eraseblock @pnum and returns 3212d262c48SKyungmin Park * zero in case of success and a negative error code in case of failure. If 3222d262c48SKyungmin Park * %-EIO is returned, the physical eraseblock most probably went bad. 3232d262c48SKyungmin Park */ 3242d262c48SKyungmin Park static int do_sync_erase(struct ubi_device *ubi, int pnum) 3252d262c48SKyungmin Park { 3262d262c48SKyungmin Park int err, retries = 0; 3272d262c48SKyungmin Park struct erase_info ei; 3282d262c48SKyungmin Park wait_queue_head_t wq; 3292d262c48SKyungmin Park 3302d262c48SKyungmin Park dbg_io("erase PEB %d", pnum); 331*ff94bc40SHeiko Schocher ubi_assert(pnum >= 0 && pnum < ubi->peb_count); 332*ff94bc40SHeiko Schocher 333*ff94bc40SHeiko Schocher if (ubi->ro_mode) { 334*ff94bc40SHeiko Schocher ubi_err("read-only mode"); 335*ff94bc40SHeiko Schocher return -EROFS; 336*ff94bc40SHeiko Schocher } 3372d262c48SKyungmin Park 3382d262c48SKyungmin Park retry: 3392d262c48SKyungmin Park init_waitqueue_head(&wq); 3402d262c48SKyungmin Park memset(&ei, 0, sizeof(struct erase_info)); 3412d262c48SKyungmin Park 3422d262c48SKyungmin Park ei.mtd = ubi->mtd; 3432d262c48SKyungmin Park ei.addr = (loff_t)pnum * ubi->peb_size; 3442d262c48SKyungmin Park ei.len = ubi->peb_size; 3452d262c48SKyungmin Park ei.callback = erase_callback; 3462d262c48SKyungmin Park ei.priv = (unsigned long)&wq; 3472d262c48SKyungmin Park 348dfe64e2cSSergey Lapin err = mtd_erase(ubi->mtd, &ei); 3492d262c48SKyungmin Park if (err) { 3502d262c48SKyungmin Park if (retries++ < UBI_IO_RETRIES) { 351*ff94bc40SHeiko Schocher ubi_warn("error %d while erasing PEB %d, retry", 3522d262c48SKyungmin Park err, pnum); 3532d262c48SKyungmin Park yield(); 3542d262c48SKyungmin Park goto retry; 3552d262c48SKyungmin Park } 3562d262c48SKyungmin Park ubi_err("cannot erase PEB %d, error %d", pnum, err); 357*ff94bc40SHeiko Schocher dump_stack(); 3582d262c48SKyungmin Park return err; 3592d262c48SKyungmin Park } 3602d262c48SKyungmin Park 3612d262c48SKyungmin Park err = wait_event_interruptible(wq, ei.state == MTD_ERASE_DONE || 3622d262c48SKyungmin Park ei.state == MTD_ERASE_FAILED); 3632d262c48SKyungmin Park if (err) { 3642d262c48SKyungmin Park ubi_err("interrupted PEB %d erasure", pnum); 3652d262c48SKyungmin Park return -EINTR; 3662d262c48SKyungmin Park } 3672d262c48SKyungmin Park 3682d262c48SKyungmin Park if (ei.state == MTD_ERASE_FAILED) { 3692d262c48SKyungmin Park if (retries++ < UBI_IO_RETRIES) { 370*ff94bc40SHeiko Schocher ubi_warn("error while erasing PEB %d, retry", pnum); 3712d262c48SKyungmin Park yield(); 3722d262c48SKyungmin Park goto retry; 3732d262c48SKyungmin Park } 3742d262c48SKyungmin Park ubi_err("cannot erase PEB %d", pnum); 375*ff94bc40SHeiko Schocher dump_stack(); 3762d262c48SKyungmin Park return -EIO; 3772d262c48SKyungmin Park } 3782d262c48SKyungmin Park 379*ff94bc40SHeiko Schocher err = ubi_self_check_all_ff(ubi, pnum, 0, ubi->peb_size); 3802d262c48SKyungmin Park if (err) 381*ff94bc40SHeiko Schocher return err; 3822d262c48SKyungmin Park 383*ff94bc40SHeiko Schocher if (ubi_dbg_is_erase_failure(ubi)) { 384*ff94bc40SHeiko Schocher ubi_err("cannot erase PEB %d (emulated)", pnum); 3852d262c48SKyungmin Park return -EIO; 3862d262c48SKyungmin Park } 3872d262c48SKyungmin Park 3882d262c48SKyungmin Park return 0; 3892d262c48SKyungmin Park } 3902d262c48SKyungmin Park 3912d262c48SKyungmin Park /* Patterns to write to a physical eraseblock when torturing it */ 3922d262c48SKyungmin Park static uint8_t patterns[] = {0xa5, 0x5a, 0x0}; 3932d262c48SKyungmin Park 3942d262c48SKyungmin Park /** 3952d262c48SKyungmin Park * torture_peb - test a supposedly bad physical eraseblock. 3962d262c48SKyungmin Park * @ubi: UBI device description object 3972d262c48SKyungmin Park * @pnum: the physical eraseblock number to test 3982d262c48SKyungmin Park * 3992d262c48SKyungmin Park * This function returns %-EIO if the physical eraseblock did not pass the 4002d262c48SKyungmin Park * test, a positive number of erase operations done if the test was 4012d262c48SKyungmin Park * successfully passed, and other negative error codes in case of other errors. 4022d262c48SKyungmin Park */ 4032d262c48SKyungmin Park static int torture_peb(struct ubi_device *ubi, int pnum) 4042d262c48SKyungmin Park { 4052d262c48SKyungmin Park int err, i, patt_count; 4062d262c48SKyungmin Park 407*ff94bc40SHeiko Schocher ubi_msg("run torture test for PEB %d", pnum); 4082d262c48SKyungmin Park patt_count = ARRAY_SIZE(patterns); 4092d262c48SKyungmin Park ubi_assert(patt_count > 0); 4102d262c48SKyungmin Park 4112d262c48SKyungmin Park mutex_lock(&ubi->buf_mutex); 4122d262c48SKyungmin Park for (i = 0; i < patt_count; i++) { 4132d262c48SKyungmin Park err = do_sync_erase(ubi, pnum); 4142d262c48SKyungmin Park if (err) 4152d262c48SKyungmin Park goto out; 4162d262c48SKyungmin Park 4172d262c48SKyungmin Park /* Make sure the PEB contains only 0xFF bytes */ 418*ff94bc40SHeiko Schocher err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size); 4192d262c48SKyungmin Park if (err) 4202d262c48SKyungmin Park goto out; 4212d262c48SKyungmin Park 422*ff94bc40SHeiko Schocher err = ubi_check_pattern(ubi->peb_buf, 0xFF, ubi->peb_size); 4232d262c48SKyungmin Park if (err == 0) { 4242d262c48SKyungmin Park ubi_err("erased PEB %d, but a non-0xFF byte found", 4252d262c48SKyungmin Park pnum); 4262d262c48SKyungmin Park err = -EIO; 4272d262c48SKyungmin Park goto out; 4282d262c48SKyungmin Park } 4292d262c48SKyungmin Park 4302d262c48SKyungmin Park /* Write a pattern and check it */ 431*ff94bc40SHeiko Schocher memset(ubi->peb_buf, patterns[i], ubi->peb_size); 432*ff94bc40SHeiko Schocher err = ubi_io_write(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size); 4332d262c48SKyungmin Park if (err) 4342d262c48SKyungmin Park goto out; 4352d262c48SKyungmin Park 436*ff94bc40SHeiko Schocher memset(ubi->peb_buf, ~patterns[i], ubi->peb_size); 437*ff94bc40SHeiko Schocher err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size); 4382d262c48SKyungmin Park if (err) 4392d262c48SKyungmin Park goto out; 4402d262c48SKyungmin Park 441*ff94bc40SHeiko Schocher err = ubi_check_pattern(ubi->peb_buf, patterns[i], 442*ff94bc40SHeiko Schocher ubi->peb_size); 4432d262c48SKyungmin Park if (err == 0) { 4442d262c48SKyungmin Park ubi_err("pattern %x checking failed for PEB %d", 4452d262c48SKyungmin Park patterns[i], pnum); 4462d262c48SKyungmin Park err = -EIO; 4472d262c48SKyungmin Park goto out; 4482d262c48SKyungmin Park } 4492d262c48SKyungmin Park } 4502d262c48SKyungmin Park 4512d262c48SKyungmin Park err = patt_count; 452*ff94bc40SHeiko Schocher ubi_msg("PEB %d passed torture test, do not mark it as bad", pnum); 4532d262c48SKyungmin Park 4542d262c48SKyungmin Park out: 4552d262c48SKyungmin Park mutex_unlock(&ubi->buf_mutex); 456*ff94bc40SHeiko Schocher if (err == UBI_IO_BITFLIPS || mtd_is_eccerr(err)) { 4572d262c48SKyungmin Park /* 4582d262c48SKyungmin Park * If a bit-flip or data integrity error was detected, the test 4592d262c48SKyungmin Park * has not passed because it happened on a freshly erased 4602d262c48SKyungmin Park * physical eraseblock which means something is wrong with it. 4612d262c48SKyungmin Park */ 4622d262c48SKyungmin Park ubi_err("read problems on freshly erased PEB %d, must be bad", 4632d262c48SKyungmin Park pnum); 4642d262c48SKyungmin Park err = -EIO; 4652d262c48SKyungmin Park } 4662d262c48SKyungmin Park return err; 4672d262c48SKyungmin Park } 4682d262c48SKyungmin Park 4692d262c48SKyungmin Park /** 470*ff94bc40SHeiko Schocher * nor_erase_prepare - prepare a NOR flash PEB for erasure. 471*ff94bc40SHeiko Schocher * @ubi: UBI device description object 472*ff94bc40SHeiko Schocher * @pnum: physical eraseblock number to prepare 473*ff94bc40SHeiko Schocher * 474*ff94bc40SHeiko Schocher * NOR flash, or at least some of them, have peculiar embedded PEB erasure 475*ff94bc40SHeiko Schocher * algorithm: the PEB is first filled with zeroes, then it is erased. And 476*ff94bc40SHeiko Schocher * filling with zeroes starts from the end of the PEB. This was observed with 477*ff94bc40SHeiko Schocher * Spansion S29GL512N NOR flash. 478*ff94bc40SHeiko Schocher * 479*ff94bc40SHeiko Schocher * This means that in case of a power cut we may end up with intact data at the 480*ff94bc40SHeiko Schocher * beginning of the PEB, and all zeroes at the end of PEB. In other words, the 481*ff94bc40SHeiko Schocher * EC and VID headers are OK, but a large chunk of data at the end of PEB is 482*ff94bc40SHeiko Schocher * zeroed. This makes UBI mistakenly treat this PEB as used and associate it 483*ff94bc40SHeiko Schocher * with an LEB, which leads to subsequent failures (e.g., UBIFS fails). 484*ff94bc40SHeiko Schocher * 485*ff94bc40SHeiko Schocher * This function is called before erasing NOR PEBs and it zeroes out EC and VID 486*ff94bc40SHeiko Schocher * magic numbers in order to invalidate them and prevent the failures. Returns 487*ff94bc40SHeiko Schocher * zero in case of success and a negative error code in case of failure. 488*ff94bc40SHeiko Schocher */ 489*ff94bc40SHeiko Schocher static int nor_erase_prepare(struct ubi_device *ubi, int pnum) 490*ff94bc40SHeiko Schocher { 491*ff94bc40SHeiko Schocher int err; 492*ff94bc40SHeiko Schocher size_t written; 493*ff94bc40SHeiko Schocher loff_t addr; 494*ff94bc40SHeiko Schocher uint32_t data = 0; 495*ff94bc40SHeiko Schocher struct ubi_ec_hdr ec_hdr; 496*ff94bc40SHeiko Schocher 497*ff94bc40SHeiko Schocher /* 498*ff94bc40SHeiko Schocher * Note, we cannot generally define VID header buffers on stack, 499*ff94bc40SHeiko Schocher * because of the way we deal with these buffers (see the header 500*ff94bc40SHeiko Schocher * comment in this file). But we know this is a NOR-specific piece of 501*ff94bc40SHeiko Schocher * code, so we can do this. But yes, this is error-prone and we should 502*ff94bc40SHeiko Schocher * (pre-)allocate VID header buffer instead. 503*ff94bc40SHeiko Schocher */ 504*ff94bc40SHeiko Schocher struct ubi_vid_hdr vid_hdr; 505*ff94bc40SHeiko Schocher 506*ff94bc40SHeiko Schocher /* 507*ff94bc40SHeiko Schocher * If VID or EC is valid, we have to corrupt them before erasing. 508*ff94bc40SHeiko Schocher * It is important to first invalidate the EC header, and then the VID 509*ff94bc40SHeiko Schocher * header. Otherwise a power cut may lead to valid EC header and 510*ff94bc40SHeiko Schocher * invalid VID header, in which case UBI will treat this PEB as 511*ff94bc40SHeiko Schocher * corrupted and will try to preserve it, and print scary warnings. 512*ff94bc40SHeiko Schocher */ 513*ff94bc40SHeiko Schocher addr = (loff_t)pnum * ubi->peb_size; 514*ff94bc40SHeiko Schocher err = ubi_io_read_ec_hdr(ubi, pnum, &ec_hdr, 0); 515*ff94bc40SHeiko Schocher if (err != UBI_IO_BAD_HDR_EBADMSG && err != UBI_IO_BAD_HDR && 516*ff94bc40SHeiko Schocher err != UBI_IO_FF){ 517*ff94bc40SHeiko Schocher err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data); 518*ff94bc40SHeiko Schocher if(err) 519*ff94bc40SHeiko Schocher goto error; 520*ff94bc40SHeiko Schocher } 521*ff94bc40SHeiko Schocher 522*ff94bc40SHeiko Schocher err = ubi_io_read_vid_hdr(ubi, pnum, &vid_hdr, 0); 523*ff94bc40SHeiko Schocher if (err != UBI_IO_BAD_HDR_EBADMSG && err != UBI_IO_BAD_HDR && 524*ff94bc40SHeiko Schocher err != UBI_IO_FF){ 525*ff94bc40SHeiko Schocher addr += ubi->vid_hdr_aloffset; 526*ff94bc40SHeiko Schocher err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data); 527*ff94bc40SHeiko Schocher if (err) 528*ff94bc40SHeiko Schocher goto error; 529*ff94bc40SHeiko Schocher } 530*ff94bc40SHeiko Schocher return 0; 531*ff94bc40SHeiko Schocher 532*ff94bc40SHeiko Schocher error: 533*ff94bc40SHeiko Schocher /* 534*ff94bc40SHeiko Schocher * The PEB contains a valid VID or EC header, but we cannot invalidate 535*ff94bc40SHeiko Schocher * it. Supposedly the flash media or the driver is screwed up, so 536*ff94bc40SHeiko Schocher * return an error. 537*ff94bc40SHeiko Schocher */ 538*ff94bc40SHeiko Schocher ubi_err("cannot invalidate PEB %d, write returned %d", pnum, err); 539*ff94bc40SHeiko Schocher ubi_dump_flash(ubi, pnum, 0, ubi->peb_size); 540*ff94bc40SHeiko Schocher return -EIO; 541*ff94bc40SHeiko Schocher } 542*ff94bc40SHeiko Schocher 543*ff94bc40SHeiko Schocher /** 5442d262c48SKyungmin Park * ubi_io_sync_erase - synchronously erase a physical eraseblock. 5452d262c48SKyungmin Park * @ubi: UBI device description object 5462d262c48SKyungmin Park * @pnum: physical eraseblock number to erase 5472d262c48SKyungmin Park * @torture: if this physical eraseblock has to be tortured 5482d262c48SKyungmin Park * 5492d262c48SKyungmin Park * This function synchronously erases physical eraseblock @pnum. If @torture 5502d262c48SKyungmin Park * flag is not zero, the physical eraseblock is checked by means of writing 5512d262c48SKyungmin Park * different patterns to it and reading them back. If the torturing is enabled, 552*ff94bc40SHeiko Schocher * the physical eraseblock is erased more than once. 5532d262c48SKyungmin Park * 5542d262c48SKyungmin Park * This function returns the number of erasures made in case of success, %-EIO 5552d262c48SKyungmin Park * if the erasure failed or the torturing test failed, and other negative error 5562d262c48SKyungmin Park * codes in case of other errors. Note, %-EIO means that the physical 5572d262c48SKyungmin Park * eraseblock is bad. 5582d262c48SKyungmin Park */ 5592d262c48SKyungmin Park int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture) 5602d262c48SKyungmin Park { 5612d262c48SKyungmin Park int err, ret = 0; 5622d262c48SKyungmin Park 5632d262c48SKyungmin Park ubi_assert(pnum >= 0 && pnum < ubi->peb_count); 5642d262c48SKyungmin Park 565*ff94bc40SHeiko Schocher err = self_check_not_bad(ubi, pnum); 5662d262c48SKyungmin Park if (err != 0) 567*ff94bc40SHeiko Schocher return err; 5682d262c48SKyungmin Park 5692d262c48SKyungmin Park if (ubi->ro_mode) { 5702d262c48SKyungmin Park ubi_err("read-only mode"); 5712d262c48SKyungmin Park return -EROFS; 5722d262c48SKyungmin Park } 5732d262c48SKyungmin Park 574*ff94bc40SHeiko Schocher if (ubi->nor_flash) { 575*ff94bc40SHeiko Schocher err = nor_erase_prepare(ubi, pnum); 576*ff94bc40SHeiko Schocher if (err) 577*ff94bc40SHeiko Schocher return err; 578*ff94bc40SHeiko Schocher } 579*ff94bc40SHeiko Schocher 5802d262c48SKyungmin Park if (torture) { 5812d262c48SKyungmin Park ret = torture_peb(ubi, pnum); 5822d262c48SKyungmin Park if (ret < 0) 5832d262c48SKyungmin Park return ret; 5842d262c48SKyungmin Park } 5852d262c48SKyungmin Park 5862d262c48SKyungmin Park err = do_sync_erase(ubi, pnum); 5872d262c48SKyungmin Park if (err) 5882d262c48SKyungmin Park return err; 5892d262c48SKyungmin Park 5902d262c48SKyungmin Park return ret + 1; 5912d262c48SKyungmin Park } 5922d262c48SKyungmin Park 5932d262c48SKyungmin Park /** 5942d262c48SKyungmin Park * ubi_io_is_bad - check if a physical eraseblock is bad. 5952d262c48SKyungmin Park * @ubi: UBI device description object 5962d262c48SKyungmin Park * @pnum: the physical eraseblock number to check 5972d262c48SKyungmin Park * 5982d262c48SKyungmin Park * This function returns a positive number if the physical eraseblock is bad, 5992d262c48SKyungmin Park * zero if not, and a negative error code if an error occurred. 6002d262c48SKyungmin Park */ 6012d262c48SKyungmin Park int ubi_io_is_bad(const struct ubi_device *ubi, int pnum) 6022d262c48SKyungmin Park { 6032d262c48SKyungmin Park struct mtd_info *mtd = ubi->mtd; 6042d262c48SKyungmin Park 6052d262c48SKyungmin Park ubi_assert(pnum >= 0 && pnum < ubi->peb_count); 6062d262c48SKyungmin Park 6072d262c48SKyungmin Park if (ubi->bad_allowed) { 6082d262c48SKyungmin Park int ret; 6092d262c48SKyungmin Park 610dfe64e2cSSergey Lapin ret = mtd_block_isbad(mtd, (loff_t)pnum * ubi->peb_size); 6112d262c48SKyungmin Park if (ret < 0) 6122d262c48SKyungmin Park ubi_err("error %d while checking if PEB %d is bad", 6132d262c48SKyungmin Park ret, pnum); 6142d262c48SKyungmin Park else if (ret) 6152d262c48SKyungmin Park dbg_io("PEB %d is bad", pnum); 6162d262c48SKyungmin Park return ret; 6172d262c48SKyungmin Park } 6182d262c48SKyungmin Park 6192d262c48SKyungmin Park return 0; 6202d262c48SKyungmin Park } 6212d262c48SKyungmin Park 6222d262c48SKyungmin Park /** 6232d262c48SKyungmin Park * ubi_io_mark_bad - mark a physical eraseblock as bad. 6242d262c48SKyungmin Park * @ubi: UBI device description object 6252d262c48SKyungmin Park * @pnum: the physical eraseblock number to mark 6262d262c48SKyungmin Park * 6272d262c48SKyungmin Park * This function returns zero in case of success and a negative error code in 6282d262c48SKyungmin Park * case of failure. 6292d262c48SKyungmin Park */ 6302d262c48SKyungmin Park int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum) 6312d262c48SKyungmin Park { 6322d262c48SKyungmin Park int err; 6332d262c48SKyungmin Park struct mtd_info *mtd = ubi->mtd; 6342d262c48SKyungmin Park 6352d262c48SKyungmin Park ubi_assert(pnum >= 0 && pnum < ubi->peb_count); 6362d262c48SKyungmin Park 6372d262c48SKyungmin Park if (ubi->ro_mode) { 6382d262c48SKyungmin Park ubi_err("read-only mode"); 6392d262c48SKyungmin Park return -EROFS; 6402d262c48SKyungmin Park } 6412d262c48SKyungmin Park 6422d262c48SKyungmin Park if (!ubi->bad_allowed) 6432d262c48SKyungmin Park return 0; 6442d262c48SKyungmin Park 645dfe64e2cSSergey Lapin err = mtd_block_markbad(mtd, (loff_t)pnum * ubi->peb_size); 6462d262c48SKyungmin Park if (err) 6472d262c48SKyungmin Park ubi_err("cannot mark PEB %d bad, error %d", pnum, err); 6482d262c48SKyungmin Park return err; 6492d262c48SKyungmin Park } 6502d262c48SKyungmin Park 6512d262c48SKyungmin Park /** 6522d262c48SKyungmin Park * validate_ec_hdr - validate an erase counter header. 6532d262c48SKyungmin Park * @ubi: UBI device description object 6542d262c48SKyungmin Park * @ec_hdr: the erase counter header to check 6552d262c48SKyungmin Park * 6562d262c48SKyungmin Park * This function returns zero if the erase counter header is OK, and %1 if 6572d262c48SKyungmin Park * not. 6582d262c48SKyungmin Park */ 6592d262c48SKyungmin Park static int validate_ec_hdr(const struct ubi_device *ubi, 6602d262c48SKyungmin Park const struct ubi_ec_hdr *ec_hdr) 6612d262c48SKyungmin Park { 6622d262c48SKyungmin Park long long ec; 6632d262c48SKyungmin Park int vid_hdr_offset, leb_start; 6642d262c48SKyungmin Park 6652d262c48SKyungmin Park ec = be64_to_cpu(ec_hdr->ec); 6662d262c48SKyungmin Park vid_hdr_offset = be32_to_cpu(ec_hdr->vid_hdr_offset); 6672d262c48SKyungmin Park leb_start = be32_to_cpu(ec_hdr->data_offset); 6682d262c48SKyungmin Park 6692d262c48SKyungmin Park if (ec_hdr->version != UBI_VERSION) { 670*ff94bc40SHeiko Schocher ubi_err("node with incompatible UBI version found: this UBI version is %d, image version is %d", 6712d262c48SKyungmin Park UBI_VERSION, (int)ec_hdr->version); 6722d262c48SKyungmin Park goto bad; 6732d262c48SKyungmin Park } 6742d262c48SKyungmin Park 6752d262c48SKyungmin Park if (vid_hdr_offset != ubi->vid_hdr_offset) { 6762d262c48SKyungmin Park ubi_err("bad VID header offset %d, expected %d", 6772d262c48SKyungmin Park vid_hdr_offset, ubi->vid_hdr_offset); 6782d262c48SKyungmin Park goto bad; 6792d262c48SKyungmin Park } 6802d262c48SKyungmin Park 6812d262c48SKyungmin Park if (leb_start != ubi->leb_start) { 6822d262c48SKyungmin Park ubi_err("bad data offset %d, expected %d", 6832d262c48SKyungmin Park leb_start, ubi->leb_start); 6842d262c48SKyungmin Park goto bad; 6852d262c48SKyungmin Park } 6862d262c48SKyungmin Park 6872d262c48SKyungmin Park if (ec < 0 || ec > UBI_MAX_ERASECOUNTER) { 6882d262c48SKyungmin Park ubi_err("bad erase counter %lld", ec); 6892d262c48SKyungmin Park goto bad; 6902d262c48SKyungmin Park } 6912d262c48SKyungmin Park 6922d262c48SKyungmin Park return 0; 6932d262c48SKyungmin Park 6942d262c48SKyungmin Park bad: 6952d262c48SKyungmin Park ubi_err("bad EC header"); 696*ff94bc40SHeiko Schocher ubi_dump_ec_hdr(ec_hdr); 697*ff94bc40SHeiko Schocher dump_stack(); 6982d262c48SKyungmin Park return 1; 6992d262c48SKyungmin Park } 7002d262c48SKyungmin Park 7012d262c48SKyungmin Park /** 7022d262c48SKyungmin Park * ubi_io_read_ec_hdr - read and check an erase counter header. 7032d262c48SKyungmin Park * @ubi: UBI device description object 7042d262c48SKyungmin Park * @pnum: physical eraseblock to read from 7052d262c48SKyungmin Park * @ec_hdr: a &struct ubi_ec_hdr object where to store the read erase counter 7062d262c48SKyungmin Park * header 7072d262c48SKyungmin Park * @verbose: be verbose if the header is corrupted or was not found 7082d262c48SKyungmin Park * 7092d262c48SKyungmin Park * This function reads erase counter header from physical eraseblock @pnum and 7102d262c48SKyungmin Park * stores it in @ec_hdr. This function also checks CRC checksum of the read 7112d262c48SKyungmin Park * erase counter header. The following codes may be returned: 7122d262c48SKyungmin Park * 7132d262c48SKyungmin Park * o %0 if the CRC checksum is correct and the header was successfully read; 7142d262c48SKyungmin Park * o %UBI_IO_BITFLIPS if the CRC is correct, but bit-flips were detected 7152d262c48SKyungmin Park * and corrected by the flash driver; this is harmless but may indicate that 7162d262c48SKyungmin Park * this eraseblock may become bad soon (but may be not); 717*ff94bc40SHeiko Schocher * o %UBI_IO_BAD_HDR if the erase counter header is corrupted (a CRC error); 718*ff94bc40SHeiko Schocher * o %UBI_IO_BAD_HDR_EBADMSG is the same as %UBI_IO_BAD_HDR, but there also was 719*ff94bc40SHeiko Schocher * a data integrity error (uncorrectable ECC error in case of NAND); 720*ff94bc40SHeiko Schocher * o %UBI_IO_FF if only 0xFF bytes were read (the PEB is supposedly empty) 7212d262c48SKyungmin Park * o a negative error code in case of failure. 7222d262c48SKyungmin Park */ 7232d262c48SKyungmin Park int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum, 7242d262c48SKyungmin Park struct ubi_ec_hdr *ec_hdr, int verbose) 7252d262c48SKyungmin Park { 726*ff94bc40SHeiko Schocher int err, read_err; 7272d262c48SKyungmin Park uint32_t crc, magic, hdr_crc; 7282d262c48SKyungmin Park 7292d262c48SKyungmin Park dbg_io("read EC header from PEB %d", pnum); 7302d262c48SKyungmin Park ubi_assert(pnum >= 0 && pnum < ubi->peb_count); 7312d262c48SKyungmin Park 732*ff94bc40SHeiko Schocher read_err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE); 733*ff94bc40SHeiko Schocher if (read_err) { 734*ff94bc40SHeiko Schocher if (read_err != UBI_IO_BITFLIPS && !mtd_is_eccerr(read_err)) 735*ff94bc40SHeiko Schocher return read_err; 7362d262c48SKyungmin Park 7372d262c48SKyungmin Park /* 7382d262c48SKyungmin Park * We read all the data, but either a correctable bit-flip 739*ff94bc40SHeiko Schocher * occurred, or MTD reported a data integrity error 740*ff94bc40SHeiko Schocher * (uncorrectable ECC error in case of NAND). The former is 741*ff94bc40SHeiko Schocher * harmless, the later may mean that the read data is 742*ff94bc40SHeiko Schocher * corrupted. But we have a CRC check-sum and we will detect 743*ff94bc40SHeiko Schocher * this. If the EC header is still OK, we just report this as 744*ff94bc40SHeiko Schocher * there was a bit-flip, to force scrubbing. 7452d262c48SKyungmin Park */ 7462d262c48SKyungmin Park } 7472d262c48SKyungmin Park 7482d262c48SKyungmin Park magic = be32_to_cpu(ec_hdr->magic); 7492d262c48SKyungmin Park if (magic != UBI_EC_HDR_MAGIC) { 750*ff94bc40SHeiko Schocher if (mtd_is_eccerr(read_err)) 751*ff94bc40SHeiko Schocher return UBI_IO_BAD_HDR_EBADMSG; 752*ff94bc40SHeiko Schocher 7532d262c48SKyungmin Park /* 7542d262c48SKyungmin Park * The magic field is wrong. Let's check if we have read all 7552d262c48SKyungmin Park * 0xFF. If yes, this physical eraseblock is assumed to be 7562d262c48SKyungmin Park * empty. 7572d262c48SKyungmin Park */ 758*ff94bc40SHeiko Schocher if (ubi_check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) { 7592d262c48SKyungmin Park /* The physical eraseblock is supposedly empty */ 7602d262c48SKyungmin Park if (verbose) 761*ff94bc40SHeiko Schocher ubi_warn("no EC header found at PEB %d, only 0xFF bytes", 762*ff94bc40SHeiko Schocher pnum); 763*ff94bc40SHeiko Schocher dbg_bld("no EC header found at PEB %d, only 0xFF bytes", 764*ff94bc40SHeiko Schocher pnum); 765*ff94bc40SHeiko Schocher if (!read_err) 766*ff94bc40SHeiko Schocher return UBI_IO_FF; 767*ff94bc40SHeiko Schocher else 768*ff94bc40SHeiko Schocher return UBI_IO_FF_BITFLIPS; 7692d262c48SKyungmin Park } 7702d262c48SKyungmin Park 7712d262c48SKyungmin Park /* 7722d262c48SKyungmin Park * This is not a valid erase counter header, and these are not 7732d262c48SKyungmin Park * 0xFF bytes. Report that the header is corrupted. 7742d262c48SKyungmin Park */ 7752d262c48SKyungmin Park if (verbose) { 776*ff94bc40SHeiko Schocher ubi_warn("bad magic number at PEB %d: %08x instead of %08x", 777*ff94bc40SHeiko Schocher pnum, magic, UBI_EC_HDR_MAGIC); 778*ff94bc40SHeiko Schocher ubi_dump_ec_hdr(ec_hdr); 7792d262c48SKyungmin Park } 780*ff94bc40SHeiko Schocher dbg_bld("bad magic number at PEB %d: %08x instead of %08x", 781*ff94bc40SHeiko Schocher pnum, magic, UBI_EC_HDR_MAGIC); 782*ff94bc40SHeiko Schocher return UBI_IO_BAD_HDR; 7832d262c48SKyungmin Park } 7842d262c48SKyungmin Park 7852d262c48SKyungmin Park crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC); 7862d262c48SKyungmin Park hdr_crc = be32_to_cpu(ec_hdr->hdr_crc); 7872d262c48SKyungmin Park 7882d262c48SKyungmin Park if (hdr_crc != crc) { 7892d262c48SKyungmin Park if (verbose) { 790*ff94bc40SHeiko Schocher ubi_warn("bad EC header CRC at PEB %d, calculated %#08x, read %#08x", 791*ff94bc40SHeiko Schocher pnum, crc, hdr_crc); 792*ff94bc40SHeiko Schocher ubi_dump_ec_hdr(ec_hdr); 7932d262c48SKyungmin Park } 794*ff94bc40SHeiko Schocher dbg_bld("bad EC header CRC at PEB %d, calculated %#08x, read %#08x", 795*ff94bc40SHeiko Schocher pnum, crc, hdr_crc); 796*ff94bc40SHeiko Schocher 797*ff94bc40SHeiko Schocher if (!read_err) 798*ff94bc40SHeiko Schocher return UBI_IO_BAD_HDR; 799*ff94bc40SHeiko Schocher else 800*ff94bc40SHeiko Schocher return UBI_IO_BAD_HDR_EBADMSG; 8012d262c48SKyungmin Park } 8022d262c48SKyungmin Park 8032d262c48SKyungmin Park /* And of course validate what has just been read from the media */ 8042d262c48SKyungmin Park err = validate_ec_hdr(ubi, ec_hdr); 8052d262c48SKyungmin Park if (err) { 8062d262c48SKyungmin Park ubi_err("validation failed for PEB %d", pnum); 8072d262c48SKyungmin Park return -EINVAL; 8082d262c48SKyungmin Park } 8092d262c48SKyungmin Park 810*ff94bc40SHeiko Schocher /* 811*ff94bc40SHeiko Schocher * If there was %-EBADMSG, but the header CRC is still OK, report about 812*ff94bc40SHeiko Schocher * a bit-flip to force scrubbing on this PEB. 813*ff94bc40SHeiko Schocher */ 8142d262c48SKyungmin Park return read_err ? UBI_IO_BITFLIPS : 0; 8152d262c48SKyungmin Park } 8162d262c48SKyungmin Park 8172d262c48SKyungmin Park /** 8182d262c48SKyungmin Park * ubi_io_write_ec_hdr - write an erase counter header. 8192d262c48SKyungmin Park * @ubi: UBI device description object 8202d262c48SKyungmin Park * @pnum: physical eraseblock to write to 8212d262c48SKyungmin Park * @ec_hdr: the erase counter header to write 8222d262c48SKyungmin Park * 8232d262c48SKyungmin Park * This function writes erase counter header described by @ec_hdr to physical 8242d262c48SKyungmin Park * eraseblock @pnum. It also fills most fields of @ec_hdr before writing, so 8252d262c48SKyungmin Park * the caller do not have to fill them. Callers must only fill the @ec_hdr->ec 8262d262c48SKyungmin Park * field. 8272d262c48SKyungmin Park * 8282d262c48SKyungmin Park * This function returns zero in case of success and a negative error code in 8292d262c48SKyungmin Park * case of failure. If %-EIO is returned, the physical eraseblock most probably 8302d262c48SKyungmin Park * went bad. 8312d262c48SKyungmin Park */ 8322d262c48SKyungmin Park int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum, 8332d262c48SKyungmin Park struct ubi_ec_hdr *ec_hdr) 8342d262c48SKyungmin Park { 8352d262c48SKyungmin Park int err; 8362d262c48SKyungmin Park uint32_t crc; 8372d262c48SKyungmin Park 8382d262c48SKyungmin Park dbg_io("write EC header to PEB %d", pnum); 8392d262c48SKyungmin Park ubi_assert(pnum >= 0 && pnum < ubi->peb_count); 8402d262c48SKyungmin Park 8412d262c48SKyungmin Park ec_hdr->magic = cpu_to_be32(UBI_EC_HDR_MAGIC); 8422d262c48SKyungmin Park ec_hdr->version = UBI_VERSION; 8432d262c48SKyungmin Park ec_hdr->vid_hdr_offset = cpu_to_be32(ubi->vid_hdr_offset); 8442d262c48SKyungmin Park ec_hdr->data_offset = cpu_to_be32(ubi->leb_start); 845*ff94bc40SHeiko Schocher ec_hdr->image_seq = cpu_to_be32(ubi->image_seq); 8462d262c48SKyungmin Park crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC); 8472d262c48SKyungmin Park ec_hdr->hdr_crc = cpu_to_be32(crc); 8482d262c48SKyungmin Park 849*ff94bc40SHeiko Schocher err = self_check_ec_hdr(ubi, pnum, ec_hdr); 8502d262c48SKyungmin Park if (err) 851*ff94bc40SHeiko Schocher return err; 8522d262c48SKyungmin Park 8532d262c48SKyungmin Park err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize); 8542d262c48SKyungmin Park return err; 8552d262c48SKyungmin Park } 8562d262c48SKyungmin Park 8572d262c48SKyungmin Park /** 8582d262c48SKyungmin Park * validate_vid_hdr - validate a volume identifier header. 8592d262c48SKyungmin Park * @ubi: UBI device description object 8602d262c48SKyungmin Park * @vid_hdr: the volume identifier header to check 8612d262c48SKyungmin Park * 8622d262c48SKyungmin Park * This function checks that data stored in the volume identifier header 8632d262c48SKyungmin Park * @vid_hdr. Returns zero if the VID header is OK and %1 if not. 8642d262c48SKyungmin Park */ 8652d262c48SKyungmin Park static int validate_vid_hdr(const struct ubi_device *ubi, 8662d262c48SKyungmin Park const struct ubi_vid_hdr *vid_hdr) 8672d262c48SKyungmin Park { 8682d262c48SKyungmin Park int vol_type = vid_hdr->vol_type; 8692d262c48SKyungmin Park int copy_flag = vid_hdr->copy_flag; 8702d262c48SKyungmin Park int vol_id = be32_to_cpu(vid_hdr->vol_id); 8712d262c48SKyungmin Park int lnum = be32_to_cpu(vid_hdr->lnum); 8722d262c48SKyungmin Park int compat = vid_hdr->compat; 8732d262c48SKyungmin Park int data_size = be32_to_cpu(vid_hdr->data_size); 8742d262c48SKyungmin Park int used_ebs = be32_to_cpu(vid_hdr->used_ebs); 8752d262c48SKyungmin Park int data_pad = be32_to_cpu(vid_hdr->data_pad); 8762d262c48SKyungmin Park int data_crc = be32_to_cpu(vid_hdr->data_crc); 8772d262c48SKyungmin Park int usable_leb_size = ubi->leb_size - data_pad; 8782d262c48SKyungmin Park 8792d262c48SKyungmin Park if (copy_flag != 0 && copy_flag != 1) { 880*ff94bc40SHeiko Schocher ubi_err("bad copy_flag"); 8812d262c48SKyungmin Park goto bad; 8822d262c48SKyungmin Park } 8832d262c48SKyungmin Park 8842d262c48SKyungmin Park if (vol_id < 0 || lnum < 0 || data_size < 0 || used_ebs < 0 || 8852d262c48SKyungmin Park data_pad < 0) { 886*ff94bc40SHeiko Schocher ubi_err("negative values"); 8872d262c48SKyungmin Park goto bad; 8882d262c48SKyungmin Park } 8892d262c48SKyungmin Park 8902d262c48SKyungmin Park if (vol_id >= UBI_MAX_VOLUMES && vol_id < UBI_INTERNAL_VOL_START) { 891*ff94bc40SHeiko Schocher ubi_err("bad vol_id"); 8922d262c48SKyungmin Park goto bad; 8932d262c48SKyungmin Park } 8942d262c48SKyungmin Park 8952d262c48SKyungmin Park if (vol_id < UBI_INTERNAL_VOL_START && compat != 0) { 896*ff94bc40SHeiko Schocher ubi_err("bad compat"); 8972d262c48SKyungmin Park goto bad; 8982d262c48SKyungmin Park } 8992d262c48SKyungmin Park 9002d262c48SKyungmin Park if (vol_id >= UBI_INTERNAL_VOL_START && compat != UBI_COMPAT_DELETE && 9012d262c48SKyungmin Park compat != UBI_COMPAT_RO && compat != UBI_COMPAT_PRESERVE && 9022d262c48SKyungmin Park compat != UBI_COMPAT_REJECT) { 903*ff94bc40SHeiko Schocher ubi_err("bad compat"); 9042d262c48SKyungmin Park goto bad; 9052d262c48SKyungmin Park } 9062d262c48SKyungmin Park 9072d262c48SKyungmin Park if (vol_type != UBI_VID_DYNAMIC && vol_type != UBI_VID_STATIC) { 908*ff94bc40SHeiko Schocher ubi_err("bad vol_type"); 9092d262c48SKyungmin Park goto bad; 9102d262c48SKyungmin Park } 9112d262c48SKyungmin Park 9122d262c48SKyungmin Park if (data_pad >= ubi->leb_size / 2) { 913*ff94bc40SHeiko Schocher ubi_err("bad data_pad"); 9142d262c48SKyungmin Park goto bad; 9152d262c48SKyungmin Park } 9162d262c48SKyungmin Park 9172d262c48SKyungmin Park if (vol_type == UBI_VID_STATIC) { 9182d262c48SKyungmin Park /* 9192d262c48SKyungmin Park * Although from high-level point of view static volumes may 9202d262c48SKyungmin Park * contain zero bytes of data, but no VID headers can contain 9212d262c48SKyungmin Park * zero at these fields, because they empty volumes do not have 9222d262c48SKyungmin Park * mapped logical eraseblocks. 9232d262c48SKyungmin Park */ 9242d262c48SKyungmin Park if (used_ebs == 0) { 925*ff94bc40SHeiko Schocher ubi_err("zero used_ebs"); 9262d262c48SKyungmin Park goto bad; 9272d262c48SKyungmin Park } 9282d262c48SKyungmin Park if (data_size == 0) { 929*ff94bc40SHeiko Schocher ubi_err("zero data_size"); 9302d262c48SKyungmin Park goto bad; 9312d262c48SKyungmin Park } 9322d262c48SKyungmin Park if (lnum < used_ebs - 1) { 9332d262c48SKyungmin Park if (data_size != usable_leb_size) { 934*ff94bc40SHeiko Schocher ubi_err("bad data_size"); 9352d262c48SKyungmin Park goto bad; 9362d262c48SKyungmin Park } 9372d262c48SKyungmin Park } else if (lnum == used_ebs - 1) { 9382d262c48SKyungmin Park if (data_size == 0) { 939*ff94bc40SHeiko Schocher ubi_err("bad data_size at last LEB"); 9402d262c48SKyungmin Park goto bad; 9412d262c48SKyungmin Park } 9422d262c48SKyungmin Park } else { 943*ff94bc40SHeiko Schocher ubi_err("too high lnum"); 9442d262c48SKyungmin Park goto bad; 9452d262c48SKyungmin Park } 9462d262c48SKyungmin Park } else { 9472d262c48SKyungmin Park if (copy_flag == 0) { 9482d262c48SKyungmin Park if (data_crc != 0) { 949*ff94bc40SHeiko Schocher ubi_err("non-zero data CRC"); 9502d262c48SKyungmin Park goto bad; 9512d262c48SKyungmin Park } 9522d262c48SKyungmin Park if (data_size != 0) { 953*ff94bc40SHeiko Schocher ubi_err("non-zero data_size"); 9542d262c48SKyungmin Park goto bad; 9552d262c48SKyungmin Park } 9562d262c48SKyungmin Park } else { 9572d262c48SKyungmin Park if (data_size == 0) { 958*ff94bc40SHeiko Schocher ubi_err("zero data_size of copy"); 9592d262c48SKyungmin Park goto bad; 9602d262c48SKyungmin Park } 9612d262c48SKyungmin Park } 9622d262c48SKyungmin Park if (used_ebs != 0) { 963*ff94bc40SHeiko Schocher ubi_err("bad used_ebs"); 9642d262c48SKyungmin Park goto bad; 9652d262c48SKyungmin Park } 9662d262c48SKyungmin Park } 9672d262c48SKyungmin Park 9682d262c48SKyungmin Park return 0; 9692d262c48SKyungmin Park 9702d262c48SKyungmin Park bad: 9712d262c48SKyungmin Park ubi_err("bad VID header"); 972*ff94bc40SHeiko Schocher ubi_dump_vid_hdr(vid_hdr); 973*ff94bc40SHeiko Schocher dump_stack(); 9742d262c48SKyungmin Park return 1; 9752d262c48SKyungmin Park } 9762d262c48SKyungmin Park 9772d262c48SKyungmin Park /** 9782d262c48SKyungmin Park * ubi_io_read_vid_hdr - read and check a volume identifier header. 9792d262c48SKyungmin Park * @ubi: UBI device description object 9802d262c48SKyungmin Park * @pnum: physical eraseblock number to read from 9812d262c48SKyungmin Park * @vid_hdr: &struct ubi_vid_hdr object where to store the read volume 9822d262c48SKyungmin Park * identifier header 9832d262c48SKyungmin Park * @verbose: be verbose if the header is corrupted or wasn't found 9842d262c48SKyungmin Park * 9852d262c48SKyungmin Park * This function reads the volume identifier header from physical eraseblock 9862d262c48SKyungmin Park * @pnum and stores it in @vid_hdr. It also checks CRC checksum of the read 987*ff94bc40SHeiko Schocher * volume identifier header. The error codes are the same as in 988*ff94bc40SHeiko Schocher * 'ubi_io_read_ec_hdr()'. 9892d262c48SKyungmin Park * 990*ff94bc40SHeiko Schocher * Note, the implementation of this function is also very similar to 991*ff94bc40SHeiko Schocher * 'ubi_io_read_ec_hdr()', so refer commentaries in 'ubi_io_read_ec_hdr()'. 9922d262c48SKyungmin Park */ 9932d262c48SKyungmin Park int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum, 9942d262c48SKyungmin Park struct ubi_vid_hdr *vid_hdr, int verbose) 9952d262c48SKyungmin Park { 996*ff94bc40SHeiko Schocher int err, read_err; 9972d262c48SKyungmin Park uint32_t crc, magic, hdr_crc; 9982d262c48SKyungmin Park void *p; 9992d262c48SKyungmin Park 10002d262c48SKyungmin Park dbg_io("read VID header from PEB %d", pnum); 10012d262c48SKyungmin Park ubi_assert(pnum >= 0 && pnum < ubi->peb_count); 10022d262c48SKyungmin Park 10032d262c48SKyungmin Park p = (char *)vid_hdr - ubi->vid_hdr_shift; 1004*ff94bc40SHeiko Schocher read_err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset, 10052d262c48SKyungmin Park ubi->vid_hdr_alsize); 1006*ff94bc40SHeiko Schocher if (read_err && read_err != UBI_IO_BITFLIPS && !mtd_is_eccerr(read_err)) 1007*ff94bc40SHeiko Schocher return read_err; 10082d262c48SKyungmin Park 10092d262c48SKyungmin Park magic = be32_to_cpu(vid_hdr->magic); 10102d262c48SKyungmin Park if (magic != UBI_VID_HDR_MAGIC) { 1011*ff94bc40SHeiko Schocher if (mtd_is_eccerr(read_err)) 1012*ff94bc40SHeiko Schocher return UBI_IO_BAD_HDR_EBADMSG; 10132d262c48SKyungmin Park 1014*ff94bc40SHeiko Schocher if (ubi_check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) { 10152d262c48SKyungmin Park if (verbose) 1016*ff94bc40SHeiko Schocher ubi_warn("no VID header found at PEB %d, only 0xFF bytes", 1017*ff94bc40SHeiko Schocher pnum); 1018*ff94bc40SHeiko Schocher dbg_bld("no VID header found at PEB %d, only 0xFF bytes", 1019*ff94bc40SHeiko Schocher pnum); 1020*ff94bc40SHeiko Schocher if (!read_err) 1021*ff94bc40SHeiko Schocher return UBI_IO_FF; 1022*ff94bc40SHeiko Schocher else 1023*ff94bc40SHeiko Schocher return UBI_IO_FF_BITFLIPS; 10242d262c48SKyungmin Park } 10252d262c48SKyungmin Park 10262d262c48SKyungmin Park if (verbose) { 1027*ff94bc40SHeiko Schocher ubi_warn("bad magic number at PEB %d: %08x instead of %08x", 1028*ff94bc40SHeiko Schocher pnum, magic, UBI_VID_HDR_MAGIC); 1029*ff94bc40SHeiko Schocher ubi_dump_vid_hdr(vid_hdr); 10302d262c48SKyungmin Park } 1031*ff94bc40SHeiko Schocher dbg_bld("bad magic number at PEB %d: %08x instead of %08x", 1032*ff94bc40SHeiko Schocher pnum, magic, UBI_VID_HDR_MAGIC); 1033*ff94bc40SHeiko Schocher return UBI_IO_BAD_HDR; 10342d262c48SKyungmin Park } 10352d262c48SKyungmin Park 10362d262c48SKyungmin Park crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC); 10372d262c48SKyungmin Park hdr_crc = be32_to_cpu(vid_hdr->hdr_crc); 10382d262c48SKyungmin Park 10392d262c48SKyungmin Park if (hdr_crc != crc) { 10402d262c48SKyungmin Park if (verbose) { 1041*ff94bc40SHeiko Schocher ubi_warn("bad CRC at PEB %d, calculated %#08x, read %#08x", 1042*ff94bc40SHeiko Schocher pnum, crc, hdr_crc); 1043*ff94bc40SHeiko Schocher ubi_dump_vid_hdr(vid_hdr); 10442d262c48SKyungmin Park } 1045*ff94bc40SHeiko Schocher dbg_bld("bad CRC at PEB %d, calculated %#08x, read %#08x", 1046*ff94bc40SHeiko Schocher pnum, crc, hdr_crc); 1047*ff94bc40SHeiko Schocher if (!read_err) 1048*ff94bc40SHeiko Schocher return UBI_IO_BAD_HDR; 1049*ff94bc40SHeiko Schocher else 1050*ff94bc40SHeiko Schocher return UBI_IO_BAD_HDR_EBADMSG; 10512d262c48SKyungmin Park } 10522d262c48SKyungmin Park 10532d262c48SKyungmin Park err = validate_vid_hdr(ubi, vid_hdr); 10542d262c48SKyungmin Park if (err) { 10552d262c48SKyungmin Park ubi_err("validation failed for PEB %d", pnum); 10562d262c48SKyungmin Park return -EINVAL; 10572d262c48SKyungmin Park } 10582d262c48SKyungmin Park 10592d262c48SKyungmin Park return read_err ? UBI_IO_BITFLIPS : 0; 10602d262c48SKyungmin Park } 10612d262c48SKyungmin Park 10622d262c48SKyungmin Park /** 10632d262c48SKyungmin Park * ubi_io_write_vid_hdr - write a volume identifier header. 10642d262c48SKyungmin Park * @ubi: UBI device description object 10652d262c48SKyungmin Park * @pnum: the physical eraseblock number to write to 10662d262c48SKyungmin Park * @vid_hdr: the volume identifier header to write 10672d262c48SKyungmin Park * 10682d262c48SKyungmin Park * This function writes the volume identifier header described by @vid_hdr to 10692d262c48SKyungmin Park * physical eraseblock @pnum. This function automatically fills the 10702d262c48SKyungmin Park * @vid_hdr->magic and the @vid_hdr->version fields, as well as calculates 10712d262c48SKyungmin Park * header CRC checksum and stores it at vid_hdr->hdr_crc. 10722d262c48SKyungmin Park * 10732d262c48SKyungmin Park * This function returns zero in case of success and a negative error code in 10742d262c48SKyungmin Park * case of failure. If %-EIO is returned, the physical eraseblock probably went 10752d262c48SKyungmin Park * bad. 10762d262c48SKyungmin Park */ 10772d262c48SKyungmin Park int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum, 10782d262c48SKyungmin Park struct ubi_vid_hdr *vid_hdr) 10792d262c48SKyungmin Park { 10802d262c48SKyungmin Park int err; 10812d262c48SKyungmin Park uint32_t crc; 10822d262c48SKyungmin Park void *p; 10832d262c48SKyungmin Park 10842d262c48SKyungmin Park dbg_io("write VID header to PEB %d", pnum); 10852d262c48SKyungmin Park ubi_assert(pnum >= 0 && pnum < ubi->peb_count); 10862d262c48SKyungmin Park 1087*ff94bc40SHeiko Schocher err = self_check_peb_ec_hdr(ubi, pnum); 10882d262c48SKyungmin Park if (err) 1089*ff94bc40SHeiko Schocher return err; 10902d262c48SKyungmin Park 10912d262c48SKyungmin Park vid_hdr->magic = cpu_to_be32(UBI_VID_HDR_MAGIC); 10922d262c48SKyungmin Park vid_hdr->version = UBI_VERSION; 10932d262c48SKyungmin Park crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC); 10942d262c48SKyungmin Park vid_hdr->hdr_crc = cpu_to_be32(crc); 10952d262c48SKyungmin Park 1096*ff94bc40SHeiko Schocher err = self_check_vid_hdr(ubi, pnum, vid_hdr); 10972d262c48SKyungmin Park if (err) 1098*ff94bc40SHeiko Schocher return err; 10992d262c48SKyungmin Park 11002d262c48SKyungmin Park p = (char *)vid_hdr - ubi->vid_hdr_shift; 11012d262c48SKyungmin Park err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset, 11022d262c48SKyungmin Park ubi->vid_hdr_alsize); 11032d262c48SKyungmin Park return err; 11042d262c48SKyungmin Park } 11052d262c48SKyungmin Park 11062d262c48SKyungmin Park /** 1107*ff94bc40SHeiko Schocher * self_check_not_bad - ensure that a physical eraseblock is not bad. 11082d262c48SKyungmin Park * @ubi: UBI device description object 11092d262c48SKyungmin Park * @pnum: physical eraseblock number to check 11102d262c48SKyungmin Park * 1111*ff94bc40SHeiko Schocher * This function returns zero if the physical eraseblock is good, %-EINVAL if 1112*ff94bc40SHeiko Schocher * it is bad and a negative error code if an error occurred. 11132d262c48SKyungmin Park */ 1114*ff94bc40SHeiko Schocher static int self_check_not_bad(const struct ubi_device *ubi, int pnum) 11152d262c48SKyungmin Park { 11162d262c48SKyungmin Park int err; 11172d262c48SKyungmin Park 1118*ff94bc40SHeiko Schocher if (!ubi_dbg_chk_io(ubi)) 1119*ff94bc40SHeiko Schocher return 0; 1120*ff94bc40SHeiko Schocher 11212d262c48SKyungmin Park err = ubi_io_is_bad(ubi, pnum); 11222d262c48SKyungmin Park if (!err) 11232d262c48SKyungmin Park return err; 11242d262c48SKyungmin Park 1125*ff94bc40SHeiko Schocher ubi_err("self-check failed for PEB %d", pnum); 1126*ff94bc40SHeiko Schocher dump_stack(); 1127*ff94bc40SHeiko Schocher return err > 0 ? -EINVAL : err; 11282d262c48SKyungmin Park } 11292d262c48SKyungmin Park 11302d262c48SKyungmin Park /** 1131*ff94bc40SHeiko Schocher * self_check_ec_hdr - check if an erase counter header is all right. 11322d262c48SKyungmin Park * @ubi: UBI device description object 11332d262c48SKyungmin Park * @pnum: physical eraseblock number the erase counter header belongs to 11342d262c48SKyungmin Park * @ec_hdr: the erase counter header to check 11352d262c48SKyungmin Park * 11362d262c48SKyungmin Park * This function returns zero if the erase counter header contains valid 1137*ff94bc40SHeiko Schocher * values, and %-EINVAL if not. 11382d262c48SKyungmin Park */ 1139*ff94bc40SHeiko Schocher static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum, 11402d262c48SKyungmin Park const struct ubi_ec_hdr *ec_hdr) 11412d262c48SKyungmin Park { 11422d262c48SKyungmin Park int err; 11432d262c48SKyungmin Park uint32_t magic; 11442d262c48SKyungmin Park 1145*ff94bc40SHeiko Schocher if (!ubi_dbg_chk_io(ubi)) 1146*ff94bc40SHeiko Schocher return 0; 1147*ff94bc40SHeiko Schocher 11482d262c48SKyungmin Park magic = be32_to_cpu(ec_hdr->magic); 11492d262c48SKyungmin Park if (magic != UBI_EC_HDR_MAGIC) { 11502d262c48SKyungmin Park ubi_err("bad magic %#08x, must be %#08x", 11512d262c48SKyungmin Park magic, UBI_EC_HDR_MAGIC); 11522d262c48SKyungmin Park goto fail; 11532d262c48SKyungmin Park } 11542d262c48SKyungmin Park 11552d262c48SKyungmin Park err = validate_ec_hdr(ubi, ec_hdr); 11562d262c48SKyungmin Park if (err) { 1157*ff94bc40SHeiko Schocher ubi_err("self-check failed for PEB %d", pnum); 11582d262c48SKyungmin Park goto fail; 11592d262c48SKyungmin Park } 11602d262c48SKyungmin Park 11612d262c48SKyungmin Park return 0; 11622d262c48SKyungmin Park 11632d262c48SKyungmin Park fail: 1164*ff94bc40SHeiko Schocher ubi_dump_ec_hdr(ec_hdr); 1165*ff94bc40SHeiko Schocher dump_stack(); 1166*ff94bc40SHeiko Schocher return -EINVAL; 11672d262c48SKyungmin Park } 11682d262c48SKyungmin Park 11692d262c48SKyungmin Park /** 1170*ff94bc40SHeiko Schocher * self_check_peb_ec_hdr - check erase counter header. 11712d262c48SKyungmin Park * @ubi: UBI device description object 11722d262c48SKyungmin Park * @pnum: the physical eraseblock number to check 11732d262c48SKyungmin Park * 1174*ff94bc40SHeiko Schocher * This function returns zero if the erase counter header is all right and and 1175*ff94bc40SHeiko Schocher * a negative error code if not or if an error occurred. 11762d262c48SKyungmin Park */ 1177*ff94bc40SHeiko Schocher static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum) 11782d262c48SKyungmin Park { 11792d262c48SKyungmin Park int err; 11802d262c48SKyungmin Park uint32_t crc, hdr_crc; 11812d262c48SKyungmin Park struct ubi_ec_hdr *ec_hdr; 11822d262c48SKyungmin Park 1183*ff94bc40SHeiko Schocher if (!ubi_dbg_chk_io(ubi)) 1184*ff94bc40SHeiko Schocher return 0; 1185*ff94bc40SHeiko Schocher 11862d262c48SKyungmin Park ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS); 11872d262c48SKyungmin Park if (!ec_hdr) 11882d262c48SKyungmin Park return -ENOMEM; 11892d262c48SKyungmin Park 11902d262c48SKyungmin Park err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE); 1191*ff94bc40SHeiko Schocher if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err)) 11922d262c48SKyungmin Park goto exit; 11932d262c48SKyungmin Park 11942d262c48SKyungmin Park crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC); 11952d262c48SKyungmin Park hdr_crc = be32_to_cpu(ec_hdr->hdr_crc); 11962d262c48SKyungmin Park if (hdr_crc != crc) { 11972d262c48SKyungmin Park ubi_err("bad CRC, calculated %#08x, read %#08x", crc, hdr_crc); 1198*ff94bc40SHeiko Schocher ubi_err("self-check failed for PEB %d", pnum); 1199*ff94bc40SHeiko Schocher ubi_dump_ec_hdr(ec_hdr); 1200*ff94bc40SHeiko Schocher dump_stack(); 1201*ff94bc40SHeiko Schocher err = -EINVAL; 12022d262c48SKyungmin Park goto exit; 12032d262c48SKyungmin Park } 12042d262c48SKyungmin Park 1205*ff94bc40SHeiko Schocher err = self_check_ec_hdr(ubi, pnum, ec_hdr); 12062d262c48SKyungmin Park 12072d262c48SKyungmin Park exit: 12082d262c48SKyungmin Park kfree(ec_hdr); 12092d262c48SKyungmin Park return err; 12102d262c48SKyungmin Park } 12112d262c48SKyungmin Park 12122d262c48SKyungmin Park /** 1213*ff94bc40SHeiko Schocher * self_check_vid_hdr - check that a volume identifier header is all right. 12142d262c48SKyungmin Park * @ubi: UBI device description object 12152d262c48SKyungmin Park * @pnum: physical eraseblock number the volume identifier header belongs to 12162d262c48SKyungmin Park * @vid_hdr: the volume identifier header to check 12172d262c48SKyungmin Park * 12182d262c48SKyungmin Park * This function returns zero if the volume identifier header is all right, and 1219*ff94bc40SHeiko Schocher * %-EINVAL if not. 12202d262c48SKyungmin Park */ 1221*ff94bc40SHeiko Schocher static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum, 12222d262c48SKyungmin Park const struct ubi_vid_hdr *vid_hdr) 12232d262c48SKyungmin Park { 12242d262c48SKyungmin Park int err; 12252d262c48SKyungmin Park uint32_t magic; 12262d262c48SKyungmin Park 1227*ff94bc40SHeiko Schocher if (!ubi_dbg_chk_io(ubi)) 1228*ff94bc40SHeiko Schocher return 0; 1229*ff94bc40SHeiko Schocher 12302d262c48SKyungmin Park magic = be32_to_cpu(vid_hdr->magic); 12312d262c48SKyungmin Park if (magic != UBI_VID_HDR_MAGIC) { 12322d262c48SKyungmin Park ubi_err("bad VID header magic %#08x at PEB %d, must be %#08x", 12332d262c48SKyungmin Park magic, pnum, UBI_VID_HDR_MAGIC); 12342d262c48SKyungmin Park goto fail; 12352d262c48SKyungmin Park } 12362d262c48SKyungmin Park 12372d262c48SKyungmin Park err = validate_vid_hdr(ubi, vid_hdr); 12382d262c48SKyungmin Park if (err) { 1239*ff94bc40SHeiko Schocher ubi_err("self-check failed for PEB %d", pnum); 12402d262c48SKyungmin Park goto fail; 12412d262c48SKyungmin Park } 12422d262c48SKyungmin Park 12432d262c48SKyungmin Park return err; 12442d262c48SKyungmin Park 12452d262c48SKyungmin Park fail: 1246*ff94bc40SHeiko Schocher ubi_err("self-check failed for PEB %d", pnum); 1247*ff94bc40SHeiko Schocher ubi_dump_vid_hdr(vid_hdr); 1248*ff94bc40SHeiko Schocher dump_stack(); 1249*ff94bc40SHeiko Schocher return -EINVAL; 12502d262c48SKyungmin Park 12512d262c48SKyungmin Park } 12522d262c48SKyungmin Park 12532d262c48SKyungmin Park /** 1254*ff94bc40SHeiko Schocher * self_check_peb_vid_hdr - check volume identifier header. 12552d262c48SKyungmin Park * @ubi: UBI device description object 12562d262c48SKyungmin Park * @pnum: the physical eraseblock number to check 12572d262c48SKyungmin Park * 12582d262c48SKyungmin Park * This function returns zero if the volume identifier header is all right, 1259*ff94bc40SHeiko Schocher * and a negative error code if not or if an error occurred. 12602d262c48SKyungmin Park */ 1261*ff94bc40SHeiko Schocher static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum) 12622d262c48SKyungmin Park { 12632d262c48SKyungmin Park int err; 12642d262c48SKyungmin Park uint32_t crc, hdr_crc; 12652d262c48SKyungmin Park struct ubi_vid_hdr *vid_hdr; 12662d262c48SKyungmin Park void *p; 12672d262c48SKyungmin Park 1268*ff94bc40SHeiko Schocher if (!ubi_dbg_chk_io(ubi)) 1269*ff94bc40SHeiko Schocher return 0; 1270*ff94bc40SHeiko Schocher 12712d262c48SKyungmin Park vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS); 12722d262c48SKyungmin Park if (!vid_hdr) 12732d262c48SKyungmin Park return -ENOMEM; 12742d262c48SKyungmin Park 12752d262c48SKyungmin Park p = (char *)vid_hdr - ubi->vid_hdr_shift; 12762d262c48SKyungmin Park err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset, 12772d262c48SKyungmin Park ubi->vid_hdr_alsize); 1278*ff94bc40SHeiko Schocher if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err)) 12792d262c48SKyungmin Park goto exit; 12802d262c48SKyungmin Park 12812d262c48SKyungmin Park crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_EC_HDR_SIZE_CRC); 12822d262c48SKyungmin Park hdr_crc = be32_to_cpu(vid_hdr->hdr_crc); 12832d262c48SKyungmin Park if (hdr_crc != crc) { 1284*ff94bc40SHeiko Schocher ubi_err("bad VID header CRC at PEB %d, calculated %#08x, read %#08x", 1285*ff94bc40SHeiko Schocher pnum, crc, hdr_crc); 1286*ff94bc40SHeiko Schocher ubi_err("self-check failed for PEB %d", pnum); 1287*ff94bc40SHeiko Schocher ubi_dump_vid_hdr(vid_hdr); 1288*ff94bc40SHeiko Schocher dump_stack(); 1289*ff94bc40SHeiko Schocher err = -EINVAL; 12902d262c48SKyungmin Park goto exit; 12912d262c48SKyungmin Park } 12922d262c48SKyungmin Park 1293*ff94bc40SHeiko Schocher err = self_check_vid_hdr(ubi, pnum, vid_hdr); 12942d262c48SKyungmin Park 12952d262c48SKyungmin Park exit: 12962d262c48SKyungmin Park ubi_free_vid_hdr(ubi, vid_hdr); 12972d262c48SKyungmin Park return err; 12982d262c48SKyungmin Park } 12992d262c48SKyungmin Park 13002d262c48SKyungmin Park /** 1301*ff94bc40SHeiko Schocher * self_check_write - make sure write succeeded. 1302*ff94bc40SHeiko Schocher * @ubi: UBI device description object 1303*ff94bc40SHeiko Schocher * @buf: buffer with data which were written 1304*ff94bc40SHeiko Schocher * @pnum: physical eraseblock number the data were written to 1305*ff94bc40SHeiko Schocher * @offset: offset within the physical eraseblock the data were written to 1306*ff94bc40SHeiko Schocher * @len: how many bytes were written 1307*ff94bc40SHeiko Schocher * 1308*ff94bc40SHeiko Schocher * This functions reads data which were recently written and compares it with 1309*ff94bc40SHeiko Schocher * the original data buffer - the data have to match. Returns zero if the data 1310*ff94bc40SHeiko Schocher * match and a negative error code if not or in case of failure. 1311*ff94bc40SHeiko Schocher */ 1312*ff94bc40SHeiko Schocher static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum, 1313*ff94bc40SHeiko Schocher int offset, int len) 1314*ff94bc40SHeiko Schocher { 1315*ff94bc40SHeiko Schocher int err, i; 1316*ff94bc40SHeiko Schocher size_t read; 1317*ff94bc40SHeiko Schocher void *buf1; 1318*ff94bc40SHeiko Schocher loff_t addr = (loff_t)pnum * ubi->peb_size + offset; 1319*ff94bc40SHeiko Schocher 1320*ff94bc40SHeiko Schocher if (!ubi_dbg_chk_io(ubi)) 1321*ff94bc40SHeiko Schocher return 0; 1322*ff94bc40SHeiko Schocher 1323*ff94bc40SHeiko Schocher buf1 = __vmalloc(len, GFP_NOFS, PAGE_KERNEL); 1324*ff94bc40SHeiko Schocher if (!buf1) { 1325*ff94bc40SHeiko Schocher ubi_err("cannot allocate memory to check writes"); 1326*ff94bc40SHeiko Schocher return 0; 1327*ff94bc40SHeiko Schocher } 1328*ff94bc40SHeiko Schocher 1329*ff94bc40SHeiko Schocher err = mtd_read(ubi->mtd, addr, len, &read, buf1); 1330*ff94bc40SHeiko Schocher if (err && !mtd_is_bitflip(err)) 1331*ff94bc40SHeiko Schocher goto out_free; 1332*ff94bc40SHeiko Schocher 1333*ff94bc40SHeiko Schocher for (i = 0; i < len; i++) { 1334*ff94bc40SHeiko Schocher uint8_t c = ((uint8_t *)buf)[i]; 1335*ff94bc40SHeiko Schocher uint8_t c1 = ((uint8_t *)buf1)[i]; 1336*ff94bc40SHeiko Schocher #if !defined(CONFIG_UBI_SILENCE_MSG) 1337*ff94bc40SHeiko Schocher int dump_len = max_t(int, 128, len - i); 1338*ff94bc40SHeiko Schocher #endif 1339*ff94bc40SHeiko Schocher 1340*ff94bc40SHeiko Schocher if (c == c1) 1341*ff94bc40SHeiko Schocher continue; 1342*ff94bc40SHeiko Schocher 1343*ff94bc40SHeiko Schocher ubi_err("self-check failed for PEB %d:%d, len %d", 1344*ff94bc40SHeiko Schocher pnum, offset, len); 1345*ff94bc40SHeiko Schocher ubi_msg("data differ at position %d", i); 1346*ff94bc40SHeiko Schocher ubi_msg("hex dump of the original buffer from %d to %d", 1347*ff94bc40SHeiko Schocher i, i + dump_len); 1348*ff94bc40SHeiko Schocher print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, 1349*ff94bc40SHeiko Schocher buf + i, dump_len, 1); 1350*ff94bc40SHeiko Schocher ubi_msg("hex dump of the read buffer from %d to %d", 1351*ff94bc40SHeiko Schocher i, i + dump_len); 1352*ff94bc40SHeiko Schocher print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, 1353*ff94bc40SHeiko Schocher buf1 + i, dump_len, 1); 1354*ff94bc40SHeiko Schocher dump_stack(); 1355*ff94bc40SHeiko Schocher err = -EINVAL; 1356*ff94bc40SHeiko Schocher goto out_free; 1357*ff94bc40SHeiko Schocher } 1358*ff94bc40SHeiko Schocher 1359*ff94bc40SHeiko Schocher vfree(buf1); 1360*ff94bc40SHeiko Schocher return 0; 1361*ff94bc40SHeiko Schocher 1362*ff94bc40SHeiko Schocher out_free: 1363*ff94bc40SHeiko Schocher vfree(buf1); 1364*ff94bc40SHeiko Schocher return err; 1365*ff94bc40SHeiko Schocher } 1366*ff94bc40SHeiko Schocher 1367*ff94bc40SHeiko Schocher /** 1368*ff94bc40SHeiko Schocher * ubi_self_check_all_ff - check that a region of flash is empty. 13692d262c48SKyungmin Park * @ubi: UBI device description object 13702d262c48SKyungmin Park * @pnum: the physical eraseblock number to check 13712d262c48SKyungmin Park * @offset: the starting offset within the physical eraseblock to check 13722d262c48SKyungmin Park * @len: the length of the region to check 13732d262c48SKyungmin Park * 13742d262c48SKyungmin Park * This function returns zero if only 0xFF bytes are present at offset 1375*ff94bc40SHeiko Schocher * @offset of the physical eraseblock @pnum, and a negative error code if not 1376*ff94bc40SHeiko Schocher * or if an error occurred. 13772d262c48SKyungmin Park */ 1378*ff94bc40SHeiko Schocher int ubi_self_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len) 13792d262c48SKyungmin Park { 13802d262c48SKyungmin Park size_t read; 13812d262c48SKyungmin Park int err; 1382*ff94bc40SHeiko Schocher void *buf; 13832d262c48SKyungmin Park loff_t addr = (loff_t)pnum * ubi->peb_size + offset; 13842d262c48SKyungmin Park 1385*ff94bc40SHeiko Schocher if (!ubi_dbg_chk_io(ubi)) 1386*ff94bc40SHeiko Schocher return 0; 1387*ff94bc40SHeiko Schocher 1388*ff94bc40SHeiko Schocher buf = __vmalloc(len, GFP_NOFS, PAGE_KERNEL); 1389*ff94bc40SHeiko Schocher if (!buf) { 1390*ff94bc40SHeiko Schocher ubi_err("cannot allocate memory to check for 0xFFs"); 1391*ff94bc40SHeiko Schocher return 0; 1392*ff94bc40SHeiko Schocher } 1393*ff94bc40SHeiko Schocher 1394*ff94bc40SHeiko Schocher err = mtd_read(ubi->mtd, addr, len, &read, buf); 1395*ff94bc40SHeiko Schocher if (err && !mtd_is_bitflip(err)) { 1396*ff94bc40SHeiko Schocher ubi_err("error %d while reading %d bytes from PEB %d:%d, read %zd bytes", 1397*ff94bc40SHeiko Schocher err, len, pnum, offset, read); 13982d262c48SKyungmin Park goto error; 13992d262c48SKyungmin Park } 14002d262c48SKyungmin Park 1401*ff94bc40SHeiko Schocher err = ubi_check_pattern(buf, 0xFF, len); 14022d262c48SKyungmin Park if (err == 0) { 1403*ff94bc40SHeiko Schocher ubi_err("flash region at PEB %d:%d, length %d does not contain all 0xFF bytes", 1404*ff94bc40SHeiko Schocher pnum, offset, len); 14052d262c48SKyungmin Park goto fail; 14062d262c48SKyungmin Park } 14072d262c48SKyungmin Park 1408*ff94bc40SHeiko Schocher vfree(buf); 14092d262c48SKyungmin Park return 0; 14102d262c48SKyungmin Park 14112d262c48SKyungmin Park fail: 1412*ff94bc40SHeiko Schocher ubi_err("self-check failed for PEB %d", pnum); 1413*ff94bc40SHeiko Schocher ubi_msg("hex dump of the %d-%d region", offset, offset + len); 1414*ff94bc40SHeiko Schocher print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, buf, len, 1); 1415*ff94bc40SHeiko Schocher err = -EINVAL; 14162d262c48SKyungmin Park error: 1417*ff94bc40SHeiko Schocher dump_stack(); 1418*ff94bc40SHeiko Schocher vfree(buf); 14192d262c48SKyungmin Park return err; 14202d262c48SKyungmin Park } 1421