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);
546 err = nor_erase_prepare(ubi, pnum);
552 ret = torture_peb(ubi, pnum);
557 err = do_sync_erase(ubi, pnum);
567 * @pnum: the physical eraseblock number to check
572 int ubi_io_is_bad(const struct ubi_device *ubi, int pnum)
576 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
581 ret = mtd_block_isbad(mtd, (loff_t)pnum * ubi->peb_size);
584 ret, pnum);
586 dbg_io("PEB %d is bad", pnum);
596 * @pnum: the physical eraseblock number to mark
601 int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum)
606 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
616 err = mtd_block_markbad(mtd, (loff_t)pnum * ubi->peb_size);
618 ubi_err(ubi, "cannot mark PEB %d bad, error %d", pnum, err);
675 * @pnum: physical eraseblock to read from
680 * This function reads erase counter header from physical eraseblock @pnum and
694 int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
700 dbg_io("read EC header from PEB %d", pnum);
701 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
703 read_err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
733 pnum);
735 pnum);
748 pnum, magic, UBI_EC_HDR_MAGIC);
752 pnum, magic, UBI_EC_HDR_MAGIC);
762 pnum, crc, hdr_crc);
766 pnum, crc, hdr_crc);
777 ubi_err(ubi, "validation failed for PEB %d", pnum);
791 * @pnum: physical eraseblock to write to
795 * eraseblock @pnum. It also fills most fields of @ec_hdr before writing, so
803 int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,
809 dbg_io("write EC header to PEB %d", pnum);
810 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
820 err = self_check_ec_hdr(ubi, pnum, ec_hdr);
827 err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize);
954 * @pnum: physical eraseblock number to read from
959 * @pnum and stores it in @vidb. It also checks CRC checksum of the read
966 int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
974 dbg_io("read VID header from PEB %d", pnum);
975 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
977 read_err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
990 pnum);
992 pnum);
1001 pnum, magic, UBI_VID_HDR_MAGIC);
1005 pnum, magic, UBI_VID_HDR_MAGIC);
1015 pnum, crc, hdr_crc);
1019 pnum, crc, hdr_crc);
1028 ubi_err(ubi, "validation failed for PEB %d", pnum);
1038 * @pnum: the physical eraseblock number to write to
1042 * physical eraseblock @pnum. This function automatically fills the
1050 int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
1058 dbg_io("write VID header to PEB %d", pnum);
1059 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
1061 err = self_check_peb_ec_hdr(ubi, pnum);
1070 err = self_check_vid_hdr(ubi, pnum, vid_hdr);
1077 err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset,
1085 * @pnum: physical eraseblock number to check
1090 static int self_check_not_bad(const struct ubi_device *ubi, int pnum)
1097 err = ubi_io_is_bad(ubi, pnum);
1101 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1109 * @pnum: physical eraseblock number the erase counter header belongs to
1115 static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum,
1133 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1148 * @pnum: the physical eraseblock number to check
1153 static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum)
1166 err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
1175 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1182 err = self_check_ec_hdr(ubi, pnum, ec_hdr);
1192 * @pnum: physical eraseblock number the volume identifier header belongs to
1198 static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum,
1210 magic, pnum, UBI_VID_HDR_MAGIC);
1216 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1223 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1233 * @pnum: the physical eraseblock number to check
1238 static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum)
1255 err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
1264 pnum, crc, hdr_crc);
1265 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1272 err = self_check_vid_hdr(ubi, pnum, vid_hdr);
1283 * @pnum: physical eraseblock number the data were written to
1291 static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum,
1297 loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1321 pnum, offset, len);
1348 * @pnum: the physical eraseblock number to check
1353 * @offset of the physical eraseblock @pnum, and a negative error code if not
1356 int ubi_self_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len)
1361 loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1375 err, len, pnum, offset, read);
1382 pnum, offset, len);
1390 ubi_err(ubi, "self-check failed for PEB %d", pnum);