Lines Matching refs:pnum
87 static int self_check_not_bad(const struct ubi_device *ubi, int pnum);
88 static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum);
89 static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum,
91 static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum);
92 static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum,
94 static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum,
101 * @pnum: physical eraseblock number to read from
105 * This function reads data from offset @offset of physical eraseblock @pnum
119 int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset,
126 dbg_io("read %d bytes from PEB %d:%d", len, pnum, offset);
128 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
132 err = self_check_not_bad(ubi, pnum);
158 addr = (loff_t)pnum * ubi->peb_size + offset;
174 pnum);
181 err, errstr, len, pnum, offset, read);
187 err, errstr, len, pnum, offset, read);
215 * @pnum: physical eraseblock number to write to
220 * of physical eraseblock @pnum. If all the data were successfully written,
228 int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
235 dbg_io("write %d bytes to PEB %d:%d", len, pnum, offset);
237 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
247 err = self_check_not_bad(ubi, pnum);
252 err = ubi_self_check_all_ff(ubi, pnum, offset, len);
261 err = self_check_peb_ec_hdr(ubi, pnum);
264 err = self_check_peb_vid_hdr(ubi, pnum);
271 len, pnum, offset);
276 addr = (loff_t)pnum * ubi->peb_size + offset;
280 err, len, pnum, offset, written);
282 ubi_dump_flash(ubi, pnum, offset, len);
287 err = self_check_write(ubi, buf, pnum, offset, len);
298 err = ubi_self_check_all_ff(ubi, pnum, offset, len);
319 * @pnum: the physical eraseblock number to erase
321 * This function synchronously erases physical eraseblock @pnum and returns
325 static int do_sync_erase(struct ubi_device *ubi, int pnum)
331 dbg_io("erase PEB %d", pnum);
332 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
344 ei.addr = (loff_t)pnum * ubi->peb_size;
353 err, pnum);
357 ubi_err(ubi, "cannot erase PEB %d, error %d", pnum, err);
365 ubi_err(ubi, "interrupted PEB %d erasure", pnum);
372 pnum);
376 ubi_err(ubi, "cannot erase PEB %d", pnum);
381 err = ubi_self_check_all_ff(ubi, pnum, 0, ubi->peb_size);
386 ubi_err(ubi, "cannot erase PEB %d (emulated)", pnum);
399 * @pnum: the physical eraseblock number to test
405 static int torture_peb(struct ubi_device *ubi, int pnum)
409 ubi_msg(ubi, "run torture test for PEB %d", pnum);
415 err = do_sync_erase(ubi, pnum);
420 err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
427 pnum);
434 err = ubi_io_write(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
439 err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
447 patterns[i], pnum);
454 ubi_msg(ubi, "PEB %d passed torture test, do not mark it as bad", pnum);
465 pnum);
474 * @pnum: physical eraseblock number to prepare
491 static int nor_erase_prepare(struct ubi_device *ubi, int pnum)
515 addr = (loff_t)pnum * ubi->peb_size;
516 err = ubi_io_read_ec_hdr(ubi, pnum, &ec_hdr, 0);
524 err = ubi_io_read_vid_hdr(ubi, pnum, &vid_hdr, 0);
540 ubi_err(ubi, "cannot invalidate PEB %d, write returned %d", pnum, err);
541 ubi_dump_flash(ubi, pnum, 0, ubi->peb_size);
548 * @pnum: physical eraseblock number to erase
551 * This function synchronously erases physical eraseblock @pnum. If @torture
561 int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture)
565 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
567 err = self_check_not_bad(ubi, pnum);
577 err = nor_erase_prepare(ubi, pnum);
583 ret = torture_peb(ubi, pnum);
588 err = do_sync_erase(ubi, pnum);
598 * @pnum: the physical eraseblock number to check
603 int ubi_io_is_bad(const struct ubi_device *ubi, int pnum)
607 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
612 ret = mtd_block_isbad(mtd, (loff_t)pnum * ubi->peb_size);
615 ret, pnum);
617 dbg_io("PEB %d is bad", pnum);
627 * @pnum: the physical eraseblock number to mark
632 int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum)
637 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
647 err = mtd_block_markbad(mtd, (loff_t)pnum * ubi->peb_size);
649 ubi_err(ubi, "cannot mark PEB %d bad, error %d", pnum, err);
706 * @pnum: physical eraseblock to read from
711 * This function reads erase counter header from physical eraseblock @pnum and
725 int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
731 dbg_io("read EC header from PEB %d", pnum);
732 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
734 read_err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
764 pnum);
766 pnum);
779 pnum, magic, UBI_EC_HDR_MAGIC);
783 pnum, magic, UBI_EC_HDR_MAGIC);
793 pnum, crc, hdr_crc);
797 pnum, crc, hdr_crc);
808 ubi_err(ubi, "validation failed for PEB %d", pnum);
822 * @pnum: physical eraseblock to write to
826 * eraseblock @pnum. It also fills most fields of @ec_hdr before writing, so
834 int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,
840 dbg_io("write EC header to PEB %d", pnum);
841 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
851 err = self_check_ec_hdr(ubi, pnum, ec_hdr);
858 err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize);
985 * @pnum: physical eraseblock number to read from
991 * @pnum and stores it in @vid_hdr. It also checks CRC checksum of the read
998 int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
1005 dbg_io("read VID header from PEB %d", pnum);
1006 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
1009 read_err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
1022 pnum);
1024 pnum);
1033 pnum, magic, UBI_VID_HDR_MAGIC);
1037 pnum, magic, UBI_VID_HDR_MAGIC);
1047 pnum, crc, hdr_crc);
1051 pnum, crc, hdr_crc);
1060 ubi_err(ubi, "validation failed for PEB %d", pnum);
1070 * @pnum: the physical eraseblock number to write to
1074 * physical eraseblock @pnum. This function automatically fills the
1082 int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
1089 dbg_io("write VID header to PEB %d", pnum);
1090 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
1092 err = self_check_peb_ec_hdr(ubi, pnum);
1101 err = self_check_vid_hdr(ubi, pnum, vid_hdr);
1109 err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset,
1117 * @pnum: physical eraseblock number to check
1122 static int self_check_not_bad(const struct ubi_device *ubi, int pnum)
1129 err = ubi_io_is_bad(ubi, pnum);
1133 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1141 * @pnum: physical eraseblock number the erase counter header belongs to
1147 static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum,
1165 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1180 * @pnum: the physical eraseblock number to check
1185 static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum)
1198 err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
1207 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1214 err = self_check_ec_hdr(ubi, pnum, ec_hdr);
1224 * @pnum: physical eraseblock number the volume identifier header belongs to
1230 static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum,
1242 magic, pnum, UBI_VID_HDR_MAGIC);
1248 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1255 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1265 * @pnum: the physical eraseblock number to check
1270 static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum)
1285 err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
1294 pnum, crc, hdr_crc);
1295 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1302 err = self_check_vid_hdr(ubi, pnum, vid_hdr);
1313 * @pnum: physical eraseblock number the data were written to
1321 static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum,
1327 loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1353 pnum, offset, len);
1379 * @pnum: the physical eraseblock number to check
1384 * @offset of the physical eraseblock @pnum, and a negative error code if not
1387 int ubi_self_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len)
1392 loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1406 err, len, pnum, offset, read);
1413 pnum, offset, len);
1421 ubi_err(ubi, "self-check failed for PEB %d", pnum);
