nand_write_skip_bad分析

/**
 * nand_write_skip_bad:
 *
 * Write image to NAND flash.
 * Blocks that are marked bad are skipped and the is written to the next
 * block instead as long as the image is short enough to fit even after
 * skipping the bad blocks. Due to bad blocks we may not be able to
 * perform the requested write. In the case where the write would
 * extend beyond the end of the NAND device, both length and actual (if
 * not NULL) are set to 0. In the case where the write would extend
 * beyond the limit we are passed, length is set to 0 and actual is set
 * to the required length.
 *
 * @param nand      NAND device
 * @param offset    offset in flash
 * @param length    buffer length
 * @param actual    set to size required to write length worth of
 *            buffer or 0 on error, if not NULL
 * @param lim        maximum size that actual may be in order to not
 *            exceed the buffer
 * @param buffer        buffer to read from
 * @param flags        flags modifying the behaviour of the write to NAND
 * @return        0 in case of success
 */

int nand_write_skip_bad(nand_info_t *nand, loff_t offset, size_t *length,
        size_t *actual, loff_t lim, u_char *buffer, int flags)
{
    int rval = 0, blocksize;
    size_t left_to_write = *length;
    size_t used_for_write = 0;
    u_char *p_buffer = buffer;
    int need_skip;

    if (actual)
        *actual = 0;

#ifdef CONFIG_CMD_NAND_YAFFS
    if (flags & WITH_YAFFS_OOB) {
        if (flags & ~WITH_YAFFS_OOB)//if yaffs,disable other flag
            return -EINVAL;

        int pages;
        pages = nand->erasesize / nand->writesize;
        blocksize = (pages * nand->oobsize) + nand->erasesize;//块长度 = oob + erasesize
        if (*length % (nand->writesize + nand->oobsize)) {    //长度非块长度整数倍，提示将写入不完全的页
            printf("Attempt to write incomplete page"
                " in yaffs mode\n");
            return -EINVAL;
        }
    }
#endif


    /*
     * nand_write() handles unaligned, partial page writes.
     *
     * We allow length to be unaligned, for convenience in
     * using the $filesize variable.
     *
     * However, starting at an unaligned offset makes the
     * semantics of bad block skipping ambiguous (really,
     * you should only start a block skipping access at a
     * partition boundary). So don't try to handle that.
     */
    if ((offset & (nand->writesize - 1)) != 0) {
        printf("Attempt to write non page-aligned data\n");//页不对齐，出错误返回
        *length = 0;
        return -EINVAL;
    }

    need_skip = check_skip_len(nand, offset, *length, &used_for_write);//计算含坏块后的写总长度，用used_for_write返回

    if (actual)
        *actual = used_for_write;

    if (need_skip < 0) {//超出边界
        printf("Attempt to write outside the flash area\n");
        *length = 0;
        return -EINVAL;
    }

    if (used_for_write > lim) {//超出写入限制
        puts("Size of write exceeds partition or device limit\n");
        *length = 0;
        return -EFBIG;
    }

    if (!need_skip && !(flags & WITH_DROP_FFS)) {//没有坏块并且flag不是WITH_DROP_FFS参数,直接按length长度写入。此处有bug，还需排除WITH_YAFFS_OOB
        rval = nand_write(nand, offset, length, buffer);
        if (rval == 0)
            return 0;

        *length = 0;
        printf("NAND write to offset %llx failed %d\n",
            offset, rval);
        return rval;
    }

    while (left_to_write > 0) {
        size_t block_offset = offset & (nand->erasesize - 1);//获取块内偏移
        size_t write_size, truncated_write_size;

        WATCHDOG_RESET();

        if (nand_block_isbad(nand, offset & ~(nand->erasesize - 1))) {//跳过一个坏块
            printf("Skip bad block 0x%08llx\n",
                offset & ~(nand->erasesize - 1));
            offset += nand->erasesize - block_offset;//如果offset是块对齐的bock_offset = 0，跳过一个坏块
            continue;
        }

        if (left_to_write < (blocksize - block_offset))//写入长度不足一个块，
            write_size = left_to_write;
        else
            write_size = blocksize - block_offset;//写入长度=块长度-块偏移，当第二次写数据时就能块对齐了

#ifdef CONFIG_CMD_NAND_YAFFS
        if (flags & WITH_YAFFS_OOB) {
            int page, pages;
            size_t pagesize = nand->writesize;
            size_t pagesize_oob = pagesize + nand->oobsize;
            struct mtd_oob_ops ops;

            ops.len = pagesize;
            ops.ooblen = nand->oobsize;
            ops.mode = MTD_OPS_AUTO_OOB;
            ops.ooboffs = 0;

            pages = write_size / pagesize_oob;
            for (page = 0; page < pages; page++) {
                WATCHDOG_RESET();

                ops.datbuf = p_buffer;
                ops.oobbuf = ops.datbuf + pagesize;

                rval = mtd_write_oob(nand, offset, &ops);
                if (rval != 0)
                    break;

                offset += pagesize;
                p_buffer += pagesize_oob;
            }
        }
        else
#endif
        {//不是YAFFS格式，执行以下代码
            truncated_write_size = write_size;
#ifdef CONFIG_CMD_NAND_TRIMFFS
            if (flags & WITH_DROP_FFS)
                truncated_write_size = drop_ffs(nand, p_buffer,
                        &write_size);
#endif

            rval = nand_write(nand, offset, &truncated_write_size,
                    p_buffer);
            offset += write_size;
            p_buffer += write_size;
        }
        if (rval != 0) {
            printf("NAND write to offset %llx failed %d\n",
                offset, rval);
            *length -= left_to_write;
            return rval;
        }

        left_to_write -= write_size;
    }

    return 0;
}