20160802_jeffrey - silenceuncrio/diary GitHub Wiki

int main(int argc, char **argv)
{
	argc--;
	argv++;

	if (strcmp(argv[0], "init") == 0)
		return init_main(argc, argv);
}

int init_main(int argc, char **argv)
{
	int i, j, r;
	struct mtd_data *md;
	int flags, image;
	char *infile = NULL;
	FILE *infp;
	loff_t ofs;
	int padding = 0;
	struct mtd_config cfg;
	uint8_t key[16];
	char ascii[20 * 2 + 1];
	uint8_t *keyp;

	memset(key, 0, sizeof(key));

	/* copy defaults */
	memcpy(&cfg, &default_mtd_config, sizeof(cfg));

	/* first parse kobs */
	mtd_parse_kobs(&cfg, ".kobs", false);

	/* then the arguments */
	mtd_parse_args(&cfg, argc, argv);

	image = 0;	/* first image */
	flags = 0;
	j = 0;
	for (i = 1; i < argc; i++) {

		if (argv[i][0] != '-') {
			if (infile == NULL)
				infile = argv[i];
			continue;
		}

		switch (argv[i][1]) {
			case 'x':
				padding = 1;
				break;
			case 'v':
				flags |= F_VERBOSE;
				break;
		}
	}

	if (flags & F_VERBOSE)
		mtd_cfg_dump(&cfg);

	/*
	 * We are using the kernel 3.5.7 now.
	 * The latest uboot does not have the 1k-padding in the head.
	 * So we have to add the 1k-padding ourselves.
	 * Note: We only burn the uboot to nand in the kernel 3.5.7.
	 */
	if (padding) {
		infile = padding_1k_in_head(infile);

		if (flags & F_VERBOSE)
			printf("\t -- We add the 1k-padding to the uboot.\n");
	}

	infp = fopen(infile, "rb");

	keyp = key;

	if (flags & F_VERBOSE)
		printf("%s: verifying using key '%s'\n", infile,
			vec_ascii(keyp, ascii));

	r = bootstream_verify(flags, infp, keyp, NULL);

	if (flags & F_VERBOSE)
		printf("%s: is %s bootstream for key '%s'\n", infile,
			r == 0 ? "a valid" : "an INVALID",
			vec_ascii(keyp, ascii));

	md = mtd_open(&cfg, flags);

	/* keep the file name in the private. */
	md->private = infile;

	r = plat_config_data->rom_mtd_init(md, infp);

	if (flags & F_VERBOSE)
		mtd_dump_structure(md);

	r = plat_config_data->rom_mtd_commit_structures(md, infp, UPDATE_ALL);

	fclose(infp);

	/* delete the temporary file. */
	if (padding)
		remove(infile);
	return 0;
}

	if (padding) {
		infile = padding_1k_in_head(infile);

		if (flags & F_VERBOSE)
			printf("\t -- We add the 1k-padding to the uboot.\n");
	}

static char *padding_1k_in_head(char *file_name)
{
	int to, from;
	int ret;
	int sz = getpagesize();

	from = open(file_name, O_RDONLY, S_IRUSR | S_IWUSR);
	to = open(tmp_file, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);

	/* Padding 1k in the head. */
	lseek(to, 1024, SEEK_SET);

	do {
		/* copy a page each time. */
		ret = sendfile(to, from, NULL, sz);
	} while (ret > 0);

	close(to);
	close(from);

	/* change to the temporary file. */
	return tmp_file;
}

static platform_config mx6ul_boot_config = {
	.m_u32RomVer = ROM_Version_5,
	.m_u32EnDISBBM = 0,
	.m_u32EnBootStreamVerify = 0,
	.m_u32UseNfcGeo = 0,
	.m_u32UseMultiBootArea = 0,
	.m_u32UseSinglePageStride = 0,
	.m_u32DBBT_FingerPrint = DBBT_FINGERPRINT2,
	.m_u32MaxEccStrength = 40,
	.rom_mtd_init = v4_rom_mtd_init,
	.rom_mtd_commit_structures = v6_rom_mtd_commit_structures,
};

int v4_rom_mtd_init(struct mtd_data *md, FILE *fp)
{
	int ret;

	ret = fill_fcb(md, fp);
	if (ret)
		return ret;
	return fill_dbbt(md);
}

int v6_rom_mtd_commit_structures(struct mtd_data *md, FILE *fp, int flags)
{
	int size, i, r, chip = 0;
	loff_t ofs;
	struct mtd_config *cfg = &md->cfg;

	/* [1] Write the FCB search area. */
	size = mtd_writesize(md) + mtd_oobsize(md);
	memset(md->buf, 0, size);
	r = fcb_encrypt(&md->fcb, md->buf, size, 3);
	if (r < 0)
		return r;

	mtd_commit_bcb(md, "FCB", 0, 0, 0, 1, size, false);

	/* [2] Write the DBBT search area. */
	memset(md->buf, 0, mtd_writesize(md));
	memcpy(md->buf, &(md->dbbt50), sizeof(md->dbbt50));
	mtd_commit_bcb(md, "DBBT", 1, 1, 1, 1, mtd_writesize(md), true);

	/* Write the DBBT table area. */
	memset(md->buf, 0, mtd_writesize(md));
	if (md->dbbt50.DBBT_Block.v3.m_u32DBBTNumOfPages > 0 && md->bbtn[0] != NULL) {
		memcpy(md->buf, md->bbtn[0], sizeof(*md->bbtn[0]));

		ofs = cfg->search_area_size_in_bytes;

		for (i = 0; i < 4; i++, ofs += cfg->stride_size_in_bytes) {
			vp(md, "mtd: PUTTING down DBBT%d BBTN%d @0x%llx (0x%x)\n",
				i, 0, ofs + 4 * mtd_writesize(md), mtd_writesize(md));

			r = mtd_write_page(md, chip, ofs + 4 * mtd_writesize(md), 1);
			if (r != mtd_writesize(md)) {
				fprintf(stderr, "mtd: Failed to write BBTN @0x%llx (%d)\n", ofs, r);
			}
		}
	}

	/* [3] Write the two boot streams. */
	return write_boot_stream(md, fp);
}

int write_boot_stream(struct mtd_data *md, FILE *fp)
{
	int startpage, start, size;
	loff_t ofs, end;
	int i, r, chunk;
	int chip = 0;
	struct fcb_block *fcb = &md->fcb.FCB_Block;

	vp(md, "---------- Start to write the [ %s ]----\n", (char*)md->private);
	for (i = 0; i < 2; i++) {
		if (fp == NULL)
			continue;

		if (i == 0) {
			startpage = fcb->m_u32Firmware1_startingPage;
			size      = fcb->m_u32PagesInFirmware1;
			end       = fcb->m_u32Firmware2_startingPage;
		} else {
			startpage = fcb->m_u32Firmware2_startingPage;
			size      = fcb->m_u32PagesInFirmware2;
			end       = mtd_size(md) / mtd_writesize(md);
		}

		start = startpage * mtd_writesize(md);
		size  = size      * mtd_writesize(md);
		end   = end       * mtd_writesize(md);

		vp(md, "mtd: Writting %s: #%d @%d: 0x%08x - 0x%08x\n",
			(char*)md->private, i, chip, start, start + size);

		/* Begin to write the image. */
		rewind(fp);
		ofs = start;
		while (ofs < end && size > 0) {
			while (mtd_isbad(md, chip, ofs) == 1) {
				vp(md, "mtd: Skipping bad block at 0x%llx\n", ofs);
				ofs += mtd_erasesize(md);
			}

			chunk = size;

			/*
			 * Check if we've entered a new block and, if so, erase
			 * it before beginning to write it.
			 */
			if ((ofs % mtd_erasesize(md)) == 0) {
				r = mtd_erase_block(md, chip, ofs);
				if (r < 0) {
					fprintf(stderr, "mtd: Failed to erase block"
						       "@0x%llx\n", ofs);
					ofs += mtd_erasesize(md);
					continue;
				}
			}

			if (chunk > mtd_writesize(md))
				chunk = mtd_writesize(md);

			r = fread(md->buf, 1, chunk, fp);
			if (r < 0) {
				fprintf(stderr, "mtd: Failed %d (fread %d)\n", r, chunk);
				return -1;
			}
			if (r < chunk) {
				memset(md->buf + r, 0, chunk - r);
				vp(md, "mtd: The last page is not full : %d\n", r);
			}

			/* write page */
			r = mtd_write_page(md, chip, ofs, 1);
			if (r != mtd_writesize(md))
				fprintf(stderr, "mtd: Failed to write BS @0x%llx (%d)\n",
					ofs, r);

			ofs += mtd_writesize(md);
			size -= chunk;
		}

		/*
		 * Write one safe guard page:
		 *  The Image_len of uboot is bigger then the real size of
		 *  uboot by 1K. The ROM will get all 0xff error in this case.
		 *  So we write one more page for safe guard.
		 */
		memset(md->buf, 0, mtd_writesize(md));
		r = mtd_write_page(md, chip, ofs, 1);
		if (r != mtd_writesize(md))
			fprintf(stderr, "Failed to write safe page\n");
		vp(md, "mtd: We write one page for save guard. *\n");

		if (ofs >= end) {
			fprintf(stderr, "mtd: Failed to write BS#%d\n", i);
			return -1;
		}
	}
	return 0;
}