Lines Matching defs:pnum
81 static int self_check_not_bad(const struct ubi_device *ubi, int pnum);
82 static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum);
83 static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum,
85 static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum);
86 static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum,
88 static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum,
95 * @pnum: physical eraseblock number to read from
99 * This function reads data from offset @offset of physical eraseblock @pnum
113 int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset,
120 dbg_io("read %d bytes from PEB %d:%d", len, pnum, offset);
122 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
126 err = self_check_not_bad(ubi, pnum);
152 addr = (loff_t)pnum * ubi->peb_size + offset;
168 pnum);
175 err, errstr, len, pnum, offset, read);
181 err, errstr, len, pnum, offset, read);
209 * @pnum: physical eraseblock number to write to
214 * of physical eraseblock @pnum. If all the data were successfully written,
222 int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
229 dbg_io("write %d bytes to PEB %d:%d", len, pnum, offset);
231 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
241 err = self_check_not_bad(ubi, pnum);
246 err = ubi_self_check_all_ff(ubi, pnum, offset, len);
255 err = self_check_peb_ec_hdr(ubi, pnum);
258 err = self_check_peb_vid_hdr(ubi, pnum);
265 len, pnum, offset);
270 addr = (loff_t)pnum * ubi->peb_size + offset;
274 err, len, pnum, offset, written);
276 ubi_dump_flash(ubi, pnum, offset, len);
281 err = self_check_write(ubi, buf, pnum, offset, len);
292 err = ubi_self_check_all_ff(ubi, pnum, offset, len);
301 * @pnum: the physical eraseblock number to erase
303 * This function synchronously erases physical eraseblock @pnum and returns
307 static int do_sync_erase(struct ubi_device *ubi, int pnum)
312 dbg_io("erase PEB %d", pnum);
313 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
323 ei.addr = (loff_t)pnum * ubi->peb_size;
330 err, pnum);
334 ubi_err(ubi, "cannot erase PEB %d, error %d", pnum, err);
339 err = ubi_self_check_all_ff(ubi, pnum, 0, ubi->peb_size);
344 ubi_err(ubi, "cannot erase PEB %d (emulated)", pnum);
357 * @pnum: the physical eraseblock number to test
363 static int torture_peb(struct ubi_device *ubi, int pnum)
367 ubi_msg(ubi, "run torture test for PEB %d", pnum);
373 err = do_sync_erase(ubi, pnum);
378 err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
385 pnum);
392 err = ubi_io_write(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
397 err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
405 patterns[i], pnum);
412 ubi_msg(ubi, "PEB %d passed torture test, do not mark it as bad", pnum);
423 pnum);
432 * @pnum: physical eraseblock number to prepare
449 static int nor_erase_prepare(struct ubi_device *ubi, int pnum)
474 addr = (loff_t)pnum * ubi->peb_size;
475 err = ubi_io_read_ec_hdr(ubi, pnum, &ec_hdr, 0);
486 err = ubi_io_read_vid_hdr(ubi, pnum, &vidb, 0);
502 ubi_err(ubi, "cannot invalidate PEB %d, write returned %d", pnum, err);
503 ubi_dump_flash(ubi, pnum, 0, ubi->peb_size);
510 * @pnum: physical eraseblock number to erase
513 * This function synchronously erases physical eraseblock @pnum. If @torture
523 int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture)
527 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
529 err = self_check_not_bad(ubi, pnum);
539 err = nor_erase_prepare(ubi, pnum);
545 ret = torture_peb(ubi, pnum);
550 err = do_sync_erase(ubi, pnum);
560 * @pnum: the physical eraseblock number to check
565 int ubi_io_is_bad(const struct ubi_device *ubi, int pnum)
569 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
574 ret = mtd_block_isbad(mtd, (loff_t)pnum * ubi->peb_size);
577 ret, pnum);
579 dbg_io("PEB %d is bad", pnum);
589 * @pnum: the physical eraseblock number to mark
594 int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum)
599 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
609 err = mtd_block_markbad(mtd, (loff_t)pnum * ubi->peb_size);
611 ubi_err(ubi, "cannot mark PEB %d bad, error %d", pnum, err);
668 * @pnum: physical eraseblock to read from
673 * This function reads erase counter header from physical eraseblock @pnum and
687 int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
693 dbg_io("read EC header from PEB %d", pnum);
694 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
696 read_err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
726 pnum);
728 pnum);
741 pnum, magic, UBI_EC_HDR_MAGIC);
745 pnum, magic, UBI_EC_HDR_MAGIC);
755 pnum, crc, hdr_crc);
759 pnum, crc, hdr_crc);
770 ubi_err(ubi, "validation failed for PEB %d", pnum);
784 * @pnum: physical eraseblock to write to
788 * eraseblock @pnum. It also fills most fields of @ec_hdr before writing, so
796 int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,
802 dbg_io("write EC header to PEB %d", pnum);
803 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
813 err = self_check_ec_hdr(ubi, pnum, ec_hdr);
820 err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize);
952 * @pnum: physical eraseblock number to read from
957 * @pnum and stores it in @vidb. It also checks CRC checksum of the read
964 int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
972 dbg_io("read VID header from PEB %d", pnum);
973 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
975 read_err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
988 pnum);
990 pnum);
999 pnum, magic, UBI_VID_HDR_MAGIC);
1003 pnum, magic, UBI_VID_HDR_MAGIC);
1013 pnum, crc, hdr_crc);
1017 pnum, crc, hdr_crc);
1026 ubi_err(ubi, "validation failed for PEB %d", pnum);
1036 * @pnum: the physical eraseblock number to write to
1040 * physical eraseblock @pnum. This function automatically fills the
1048 int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
1056 dbg_io("write VID header to PEB %d", pnum);
1057 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
1059 err = self_check_peb_ec_hdr(ubi, pnum);
1068 err = self_check_vid_hdr(ubi, pnum, vid_hdr);
1075 err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset,
1083 * @pnum: physical eraseblock number to check
1088 static int self_check_not_bad(const struct ubi_device *ubi, int pnum)
1095 err = ubi_io_is_bad(ubi, pnum);
1099 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1107 * @pnum: physical eraseblock number the erase counter header belongs to
1113 static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum,
1131 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1146 * @pnum: the physical eraseblock number to check
1151 static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum)
1164 err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
1173 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1180 err = self_check_ec_hdr(ubi, pnum, ec_hdr);
1190 * @pnum: physical eraseblock number the volume identifier header belongs to
1196 static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum,
1208 magic, pnum, UBI_VID_HDR_MAGIC);
1214 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1221 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1231 * @pnum: the physical eraseblock number to check
1236 static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum)
1253 err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
1262 pnum, crc, hdr_crc);
1263 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1270 err = self_check_vid_hdr(ubi, pnum, vid_hdr);
1281 * @pnum: physical eraseblock number the data were written to
1289 static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum,
1295 loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1319 pnum, offset, len);
1346 * @pnum: the physical eraseblock number to check
1351 * @offset of the physical eraseblock @pnum, and a negative error code if not
1354 int ubi_self_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len)
1359 loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1373 err, len, pnum, offset, read);
1380 pnum, offset, len);
1388 ubi_err(ubi, "self-check failed for PEB %d", pnum);