nand/raw/meson_nand.c

98 /* nand flash controller delay 3 ns */
121 	struct nand_chip nand;
253 static struct meson_nfc_nand_chip *to_meson_nand(struct nand_chip *nand)
255 	return container_of(nand, struct meson_nfc_nand_chip, nand);
258 static void meson_nfc_select_chip(struct nand_chip *nand, int chip)
260 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
261 	struct meson_nfc *nfc = nand_get_controller_data(nand);
301 static void meson_nfc_cmd_access(struct nand_chip *nand, int raw, bool dir,
304 	struct mtd_info *mtd = nand_to_mtd(nand);
306 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
310 	pagesize = nand->ecc.size;
319 	pages = len / nand->ecc.size;
367 static u8 *meson_nfc_oob_ptr(struct nand_chip *nand, int i)
369 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
372 	len = nand->ecc.size * (i + 1) + (nand->ecc.bytes + 2) * i;
377 static u8 *meson_nfc_data_ptr(struct nand_chip *nand, int i)
379 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
382 	temp = nand->ecc.size + nand->ecc.bytes;
388 static void meson_nfc_get_data_oob(struct nand_chip *nand,
394 	oob_len = nand->ecc.bytes + 2;
395 	for (i = 0; i < nand->ecc.steps; i++) {
397 			dsrc = meson_nfc_data_ptr(nand, i);
398 			memcpy(buf, dsrc, nand->ecc.size);
399 			buf += nand->ecc.size;
401 		osrc = meson_nfc_oob_ptr(nand, i);
407 static void meson_nfc_set_data_oob(struct nand_chip *nand,
413 	oob_len = nand->ecc.bytes + 2;
414 	for (i = 0; i < nand->ecc.steps; i++) {
416 			dsrc = meson_nfc_data_ptr(nand, i);
417 			memcpy(dsrc, buf, nand->ecc.size);
418 			buf += nand->ecc.size;
420 		osrc = meson_nfc_oob_ptr(nand, i);
426 static int meson_nfc_wait_no_rb_pin(struct nand_chip *nand, int timeout_ms,
429 	struct meson_nfc *nfc = nand_get_controller_data(nand);
441 	nand_status_op(nand, NULL);
452 		nand_exit_status_op(nand);
485 static int meson_nfc_queue_rb(struct nand_chip *nand, int timeout_ms,
488 	struct meson_nfc *nfc = nand_get_controller_data(nand);
501 		return meson_nfc_wait_no_rb_pin(nand, timeout_ms,
508 static void meson_nfc_set_user_byte(struct nand_chip *nand, u8 *oob_buf)
510 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
514 	for (i = 0, count = 0; i < nand->ecc.steps; i++, count += (2 + nand->ecc.bytes)) {
521 static void meson_nfc_get_user_byte(struct nand_chip *nand, u8 *oob_buf)
523 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
527 	for (i = 0, count = 0; i < nand->ecc.steps; i++, count += (2 + nand->ecc.bytes)) {
534 static int meson_nfc_ecc_correct(struct nand_chip *nand, u32 *bitflips,
537 	struct mtd_info *mtd = nand_to_mtd(nand);
538 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
542 	for (i = 0; i < nand->ecc.steps; i++) {
550 		if ((nand->options & NAND_NEED_SCRAMBLING) &&
551 		    ECC_ZERO_CNT(*info) < nand->ecc.strength) {
563 static int meson_nfc_dma_buffer_setup(struct nand_chip *nand, void *databuf,
567 	struct meson_nfc *nfc = nand_get_controller_data(nand);
603 static void meson_nfc_dma_buffer_release(struct nand_chip *nand,
607 	struct meson_nfc *nfc = nand_get_controller_data(nand);
616 static int meson_nfc_read_buf(struct nand_chip *nand, u8 *buf, int len)
618 	struct meson_nfc *nfc = nand_get_controller_data(nand);
627 	ret = meson_nfc_dma_buffer_setup(nand, buf, len, info,
637 	meson_nfc_dma_buffer_release(nand, len, PER_INFO_BYTE, DMA_FROM_DEVICE);
645 static int meson_nfc_write_buf(struct nand_chip *nand, u8 *buf, int len)
647 	struct meson_nfc *nfc = nand_get_controller_data(nand);
651 	ret = meson_nfc_dma_buffer_setup(nand, buf, len, NULL,
661 	meson_nfc_dma_buffer_release(nand, len, 0, DMA_TO_DEVICE);
666 static int meson_nfc_rw_cmd_prepare_and_execute(struct nand_chip *nand,
670 		nand_get_sdr_timings(nand_get_interface_config(nand));
671 	struct mtd_info *mtd = nand_to_mtd(nand);
672 	struct meson_nfc *nfc = nand_get_controller_data(nand);
695 	if (nand->options & NAND_ROW_ADDR_3)
711 		meson_nfc_queue_rb(nand, PSEC_TO_MSEC(sdr->tR_max), true);
719 static int meson_nfc_write_page_sub(struct nand_chip *nand,
723 		nand_get_sdr_timings(nand_get_interface_config(nand));
724 	struct mtd_info *mtd = nand_to_mtd(nand);
725 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
726 	struct meson_nfc *nfc = nand_get_controller_data(nand);
731 	meson_nfc_select_chip(nand, nand->cur_cs);
734 	info_len = nand->ecc.steps * PER_INFO_BYTE;
736 	ret = meson_nfc_rw_cmd_prepare_and_execute(nand, page, DIRWRITE);
740 	ret = meson_nfc_dma_buffer_setup(nand, meson_chip->data_buf,
746 	if (nand->options & NAND_NEED_SCRAMBLING) {
748 		meson_nfc_cmd_access(nand, raw, DIRWRITE,
751 		meson_nfc_cmd_access(nand, raw, DIRWRITE,
757 	meson_nfc_queue_rb(nand, PSEC_TO_MSEC(sdr->tPROG_max), false);
759 	meson_nfc_dma_buffer_release(nand, data_len, info_len, DMA_TO_DEVICE);
764 static int meson_nfc_write_page_raw(struct nand_chip *nand, const u8 *buf,
767 	u8 *oob_buf = nand->oob_poi;
769 	meson_nfc_set_data_oob(nand, buf, oob_buf);
771 	return meson_nfc_write_page_sub(nand, page, 1);
774 static int meson_nfc_write_page_hwecc(struct nand_chip *nand,
777 	struct mtd_info *mtd = nand_to_mtd(nand);
778 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
779 	u8 *oob_buf = nand->oob_poi;
782 	memset(meson_chip->info_buf, 0, nand->ecc.steps * PER_INFO_BYTE);
783 	meson_nfc_set_user_byte(nand, oob_buf);
785 	return meson_nfc_write_page_sub(nand, page, 0);
789 					    struct nand_chip *nand, int raw)
791 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
796 	neccpages = raw ? 1 : nand->ecc.steps;
808 static int meson_nfc_read_page_sub(struct nand_chip *nand,
811 	struct mtd_info *mtd = nand_to_mtd(nand);
812 	struct meson_nfc *nfc = nand_get_controller_data(nand);
813 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
817 	meson_nfc_select_chip(nand, nand->cur_cs);
820 	info_len = nand->ecc.steps * PER_INFO_BYTE;
822 	ret = meson_nfc_rw_cmd_prepare_and_execute(nand, page, DIRREAD);
826 	ret = meson_nfc_dma_buffer_setup(nand, meson_chip->data_buf,
832 	if (nand->options & NAND_NEED_SCRAMBLING) {
834 		meson_nfc_cmd_access(nand, raw, DIRREAD,
837 		meson_nfc_cmd_access(nand, raw, DIRREAD,
842 	meson_nfc_check_ecc_pages_valid(nfc, nand, raw);
844 	meson_nfc_dma_buffer_release(nand, data_len, info_len, DMA_FROM_DEVICE);
849 static int meson_nfc_read_page_raw(struct nand_chip *nand, u8 *buf,
852 	u8 *oob_buf = nand->oob_poi;
855 	ret = meson_nfc_read_page_sub(nand, page, 1);
859 	meson_nfc_get_data_oob(nand, buf, oob_buf);
864 static int meson_nfc_read_page_hwecc(struct nand_chip *nand, u8 *buf,
867 	struct mtd_info *mtd = nand_to_mtd(nand);
868 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
869 	struct nand_ecc_ctrl *ecc = &nand->ecc;
872 	u8 *oob_buf = nand->oob_poi;
875 	ret = meson_nfc_read_page_sub(nand, page, 0);
879 	meson_nfc_get_user_byte(nand, oob_buf);
880 	ret = meson_nfc_ecc_correct(nand, &bitflips, &correct_bitmap);
886 		if ((nand->options & NAND_NEED_SCRAMBLING) || !buf) {
890 		ret  = meson_nfc_read_page_raw(nand, buf, 0, page);
894 		for (i = 0; i < nand->ecc.steps ; i++) {
896 			u8 *oob = nand->oob_poi + i * (ecc->bytes + 2);
918 static int meson_nfc_read_oob_raw(struct nand_chip *nand, int page)
920 	return meson_nfc_read_page_raw(nand, NULL, 1, page);
923 static int meson_nfc_read_oob(struct nand_chip *nand, int page)
925 	return meson_nfc_read_page_hwecc(nand, NULL, 1, page);
1015 static int meson_nfc_exec_op(struct nand_chip *nand,
1018 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
1019 	struct meson_nfc *nfc = nand_get_controller_data(nand);
1026 	err = meson_nfc_check_op(nand, op);
1033 	meson_nfc_select_chip(nand, op->cs);
1060 			meson_nfc_read_buf(nand, buf, instr->ctx.data.len);
1068 			meson_nfc_write_buf(nand, buf, instr->ctx.data.len);
1073 			meson_nfc_queue_rb(nand, instr->ctx.waitrdy.timeout_ms,
1087 	struct nand_chip *nand = mtd_to_nand(mtd);
1089 	if (section >= nand->ecc.steps)
1092 	oobregion->offset =  2 + (section * (2 + nand->ecc.bytes));
1093 	oobregion->length = nand->ecc.bytes;
1101 	struct nand_chip *nand = mtd_to_nand(mtd);
1103 	if (section >= nand->ecc.steps)
1106 	oobregion->offset = section * (2 + nand->ecc.bytes);
1202 static void meson_nfc_free_buffer(struct nand_chip *nand)
1204 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
1210 static int meson_chip_buffer_init(struct nand_chip *nand)
1212 	struct mtd_info *mtd = nand_to_mtd(nand);
1213 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
1216 	nsectors = mtd->writesize / nand->ecc.size;
1235 int meson_nfc_setup_interface(struct nand_chip *nand, int csline,
1238 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
1277 static int meson_nand_bch_mode(struct nand_chip *nand)
1279 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
1282 	if (nand->ecc.strength > 60 || nand->ecc.strength < 8)
1286 		if (meson_ecc[i].strength == nand->ecc.strength &&
1287 		    meson_ecc[i].size == nand->ecc.size) {
1296 static void meson_nand_detach_chip(struct nand_chip *nand)
1298 	meson_nfc_free_buffer(nand);
1301 static int meson_nand_attach_chip(struct nand_chip *nand)
1303 	struct meson_nfc *nfc = nand_get_controller_data(nand);
1304 	struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
1305 	struct mtd_info *mtd = nand_to_mtd(nand);
1311 					   "%s:nand%d",
1325 	if (nand->bbt_options & NAND_BBT_USE_FLASH)
1326 		nand->bbt_options |= NAND_BBT_NO_OOB;
1328 	nand->options |= NAND_NO_SUBPAGE_WRITE;
1330 	ret = nand_ecc_choose_conf(nand, nfc->data->ecc_caps,
1339 	ret = meson_nand_bch_mode(nand);
1343 	nand->ecc.engine_type = NAND_ECC_ENGINE_TYPE_ON_HOST;
1344 	nand->ecc.write_page_raw = meson_nfc_write_page_raw;
1345 	nand->ecc.write_page = meson_nfc_write_page_hwecc;
1346 	nand->ecc.write_oob_raw = nand_write_oob_std;
1347 	nand->ecc.write_oob = nand_write_oob_std;
1349 	nand->ecc.read_page_raw = meson_nfc_read_page_raw;
1350 	nand->ecc.read_page = meson_nfc_read_page_hwecc;
1351 	nand->ecc.read_oob_raw = meson_nfc_read_oob_raw;
1352 	nand->ecc.read_oob = meson_nfc_read_oob;
1354 	if (nand->options & NAND_BUSWIDTH_16) {
1358 	ret = meson_chip_buffer_init(nand);
1377 	struct nand_chip *nand;
1410 	nand = &meson_chip->nand;
1411 	nand->controller = &nfc->controller;
1412 	nand->controller->ops = &meson_nand_controller_ops;
1413 	nand_set_flash_node(nand, np);
1414 	nand_set_controller_data(nand, nfc);
1416 	nand->options |= NAND_USES_DMA;
1417 	mtd = nand_to_mtd(nand);
1421 	ret = of_property_read_u32(np, "nand-rb", &nand_rb_val);
1430 	ret = nand_scan(nand, nsels);
1437 		nand_cleanup(nand);
1454 		mtd = nand_to_mtd(&meson_chip->nand);
1457 		nand_cleanup(&meson_chip->nand);
1596 		.name  = "meson-nand",