7  *	http://www.linux-mtd.infradead.org/doc/nand.html
10  *		  2002-2006 Thomas Gleixner (tglx@linutronix.de)
20  *	Check, if mtd->ecctype should be set to MTD_ECC_HW
113 	if (ofs & ((1ULL << chip->phys_erase_shift) - 1)) {  in check_offs_len()
115 		ret = -EINVAL;  in check_offs_len()
119 	if (len & ((1ULL << chip->phys_erase_shift) - 1)) {  in check_offs_len()
121 		ret = -EINVAL;  in check_offs_len()
128  * nand_release_device - [GENERIC] release chip
131  * Release chip lock and wake up anyone waiting on the device.
137 	/* De-select the NAND device */  in nand_release_device()
138 	chip->select_chip(mtd, -1);  in nand_release_device()
142  * nand_read_byte - [DEFAULT] read one byte from the chip
150 	return readb(chip->IO_ADDR_R);  in nand_read_byte()
154  * nand_read_byte16 - [DEFAULT] read one byte endianness aware from the chip
163 	return (uint8_t) cpu_to_le16(readw(chip->IO_ADDR_R));  in nand_read_byte16()
167  * nand_read_word - [DEFAULT] read one word from the chip
175 	return readw(chip->IO_ADDR_R);  in nand_read_word()
179  * nand_select_chip - [DEFAULT] control CE line
181  * @chipnr: chipnumber to select, -1 for deselect
190 	case -1:  in nand_select_chip()
191 		chip->cmd_ctrl(mtd, NAND_CMD_NONE, 0 | NAND_CTRL_CHANGE);  in nand_select_chip()
202  * nand_write_byte - [DEFAULT] write single byte to chip
212 	chip->write_buf(mtd, &byte, 1);  in nand_write_byte()
216  * nand_write_byte16 - [DEFAULT] write single byte to a chip with width 16
220  * Default function to write a byte to I/O[7:0] on a 16-bit wide chip.
229 	 * a byte. The ONFi spec (Revision 3.1; 2012-09-19, Section 2.16) reads:  in nand_write_byte16()
231 	 *    When the host supports a 16-bit bus width, only data is  in nand_write_byte16()
232 	 *    transferred at the 16-bit width. All address and command line  in nand_write_byte16()
233 	 *    transfers shall use only the lower 8-bits of the data bus. During  in nand_write_byte16()
235 	 *    8-bits of the data bus. During address transfers, the host shall  in nand_write_byte16()
236 	 *    set the upper 8-bits of the data bus to 00h.  in nand_write_byte16()
243 	chip->write_buf(mtd, (uint8_t *)&word, 2);  in nand_write_byte16()
280  * nand_write_buf - [DEFAULT] write buffer to chip
291 	iowrite8_rep(chip->IO_ADDR_W, buf, len);  in nand_write_buf()
295  * nand_read_buf - [DEFAULT] read chip data into buffer
306 	ioread8_rep(chip->IO_ADDR_R, buf, len);  in nand_read_buf()
310  * nand_write_buf16 - [DEFAULT] write buffer to chip
322 	iowrite16_rep(chip->IO_ADDR_W, p, len >> 1);  in nand_write_buf16()
326  * nand_read_buf16 - [DEFAULT] read chip data into buffer
338 	ioread16_rep(chip->IO_ADDR_R, p, len >> 1);  in nand_read_buf16()
342  * nand_block_bad - [DEFAULT] Read bad block marker from the chip
354 	if (chip->bbt_options & NAND_BBT_SCANLASTPAGE)  in nand_block_bad()
355 		ofs += mtd->erasesize - mtd->writesize;  in nand_block_bad()
357 	page = (int)(ofs >> chip->page_shift) & chip->pagemask;  in nand_block_bad()
360 		if (chip->options & NAND_BUSWIDTH_16) {  in nand_block_bad()
361 			chip->cmdfunc(mtd, NAND_CMD_READOOB,  in nand_block_bad()
362 					chip->badblockpos & 0xFE, page);  in nand_block_bad()
363 			bad = cpu_to_le16(chip->read_word(mtd));  in nand_block_bad()
364 			if (chip->badblockpos & 0x1)  in nand_block_bad()
369 			chip->cmdfunc(mtd, NAND_CMD_READOOB, chip->badblockpos,  in nand_block_bad()
371 			bad = chip->read_byte(mtd);  in nand_block_bad()
374 		if (likely(chip->badblockbits == 8))  in nand_block_bad()
377 			res = hweight8(bad) < chip->badblockbits;  in nand_block_bad()
378 		ofs += mtd->writesize;  in nand_block_bad()
379 		page = (int)(ofs >> chip->page_shift) & chip->pagemask;  in nand_block_bad()
381 	} while (!res && i < 2 && (chip->bbt_options & NAND_BBT_SCAN2NDPAGE));  in nand_block_bad()
387  * nand_default_block_markbad - [DEFAULT] mark a block bad via bad block marker
404 	ops.ooboffs = chip->badblockpos;  in nand_default_block_markbad()
405 	if (chip->options & NAND_BUSWIDTH_16) {  in nand_default_block_markbad()
414 	if (chip->bbt_options & NAND_BBT_SCANLASTPAGE)  in nand_default_block_markbad()
415 		ofs += mtd->erasesize - mtd->writesize;  in nand_default_block_markbad()
422 		ofs += mtd->writesize;  in nand_default_block_markbad()
423 	} while ((chip->bbt_options & NAND_BBT_SCAN2NDPAGE) && i < 2);  in nand_default_block_markbad()
429  * nand_block_markbad_lowlevel - mark a block bad
435  * specify how to write bad block markers to OOB (chip->block_markbad).
450 	if (!(chip->bbt_options & NAND_BBT_NO_OOB_BBM)) {  in nand_block_markbad_lowlevel()
457 		einfo.len = 1ULL << chip->phys_erase_shift;  in nand_block_markbad_lowlevel()
462 		ret = chip->block_markbad(mtd, ofs);  in nand_block_markbad_lowlevel()
467 	if (chip->bbt) {  in nand_block_markbad_lowlevel()
474 		mtd->ecc_stats.badblocks++;  in nand_block_markbad_lowlevel()
480  * nand_check_wp - [GENERIC] check if the chip is write protected
493 	if (chip->options & NAND_BROKEN_XD)  in nand_check_wp()
505  * nand_block_isreserved - [GENERIC] Check if a block is marked reserved.
515 	if (!chip->bbt)  in nand_block_isreserved()
522  * nand_block_checkbad - [GENERIC] Check if a block is marked bad
534 	if (!(chip->options & NAND_SKIP_BBTSCAN) &&  in nand_block_checkbad()
535 	    !(chip->options & NAND_BBT_SCANNED)) {  in nand_block_checkbad()
536 		chip->options |= NAND_BBT_SCANNED;  in nand_block_checkbad()
537 		chip->scan_bbt(mtd);  in nand_block_checkbad()
540 	if (!chip->bbt)  in nand_block_checkbad()
541 		return chip->block_bad(mtd, ofs);  in nand_block_checkbad()
548  * nand_wait_ready - [GENERIC] Wait for the ready pin after commands.
562 		if (chip->dev_ready)  in nand_wait_ready()
563 			if (chip->dev_ready(mtd))  in nand_wait_ready()
567 	if (!chip->dev_ready(mtd))  in nand_wait_ready()
573  * nand_wait_status_ready - [GENERIC] Wait for the ready status after commands.
601  * nand_command - [DEFAULT] Send command to NAND device
604  * @column: the column address for this command, -1 if none
605  * @page_addr: the page address for this command, -1 if none
620 		if (column >= mtd->writesize) {  in nand_command()
622 			column -= mtd->writesize;  in nand_command()
625 			/* First 256 bytes --> READ0 */  in nand_command()
628 			column -= 256;  in nand_command()
631 		chip->cmd_ctrl(mtd, readcmd, ctrl);  in nand_command()
634 	chip->cmd_ctrl(mtd, command, ctrl);  in nand_command()
639 	if (column != -1) {  in nand_command()
641 		if (chip->options & NAND_BUSWIDTH_16 &&  in nand_command()
644 		chip->cmd_ctrl(mtd, column, ctrl);  in nand_command()
647 	if (page_addr != -1) {  in nand_command()
648 		chip->cmd_ctrl(mtd, page_addr, ctrl);  in nand_command()
650 		chip->cmd_ctrl(mtd, page_addr >> 8, ctrl);  in nand_command()
651 		if (chip->options & NAND_ROW_ADDR_3)  in nand_command()
652 			chip->cmd_ctrl(mtd, page_addr >> 16, ctrl);  in nand_command()
654 	chip->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);  in nand_command()
672 		if (chip->dev_ready)  in nand_command()
674 		udelay(chip->chip_delay);  in nand_command()
675 		chip->cmd_ctrl(mtd, NAND_CMD_STATUS,  in nand_command()
677 		chip->cmd_ctrl(mtd,  in nand_command()
679 		/* EZ-NAND can take upto 250ms as per ONFi v4.0 */  in nand_command()
689 		if (!chip->dev_ready) {  in nand_command()
690 			udelay(chip->chip_delay);  in nand_command()
704  * nand_command_lp - [DEFAULT] Send command to NAND large page device
707  * @column: the column address for this command, -1 if none
708  * @page_addr: the page address for this command, -1 if none
721 		column += mtd->writesize;  in nand_command_lp()
726 	chip->cmd_ctrl(mtd, command, NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);  in nand_command_lp()
728 	if (column != -1 || page_addr != -1) {  in nand_command_lp()
732 		if (column != -1) {  in nand_command_lp()
734 			if (chip->options & NAND_BUSWIDTH_16 &&  in nand_command_lp()
737 			chip->cmd_ctrl(mtd, column, ctrl);  in nand_command_lp()
739 			chip->cmd_ctrl(mtd, column >> 8, ctrl);  in nand_command_lp()
741 		if (page_addr != -1) {  in nand_command_lp()
742 			chip->cmd_ctrl(mtd, page_addr, ctrl);  in nand_command_lp()
743 			chip->cmd_ctrl(mtd, page_addr >> 8,  in nand_command_lp()
745 			if (chip->options & NAND_ROW_ADDR_3)  in nand_command_lp()
746 				chip->cmd_ctrl(mtd, page_addr >> 16,  in nand_command_lp()
750 	chip->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);  in nand_command_lp()
770 		if (chip->dev_ready)  in nand_command_lp()
772 		udelay(chip->chip_delay);  in nand_command_lp()
773 		chip->cmd_ctrl(mtd, NAND_CMD_STATUS,  in nand_command_lp()
775 		chip->cmd_ctrl(mtd, NAND_CMD_NONE,  in nand_command_lp()
777 		/* EZ-NAND can take upto 250ms as per ONFi v4.0 */  in nand_command_lp()
783 		chip->cmd_ctrl(mtd, NAND_CMD_RNDOUTSTART,  in nand_command_lp()
785 		chip->cmd_ctrl(mtd, NAND_CMD_NONE,  in nand_command_lp()
790 		chip->cmd_ctrl(mtd, NAND_CMD_READSTART,  in nand_command_lp()
792 		chip->cmd_ctrl(mtd, NAND_CMD_NONE,  in nand_command_lp()
801 		if (!chip->dev_ready) {  in nand_command_lp()
802 			udelay(chip->chip_delay);  in nand_command_lp()
817  * panic_nand_get_device - [GENERIC] Get chip for selected access
828 	chip->controller->active = chip;  in panic_nand_get_device()
829 	chip->state = new_state;  in panic_nand_get_device()
833  * nand_get_device - [GENERIC] Get chip for selected access
843 	chip->state = new_state;  in nand_get_device()
848  * panic_nand_wait - [GENERIC] wait until the command is done
862 		if (chip->dev_ready) {  in panic_nand_wait()
863 			if (chip->dev_ready(mtd))  in panic_nand_wait()
882  * nand_wait - [DEFAULT] wait until the command is done
911 		if (chip->dev_ready) {  in nand_wait()
912 			if (chip->dev_ready(mtd))  in nand_wait()
936  * nand_reset_data_interface - Reset data interface and timings
950 	if (!chip->setup_data_interface)  in nand_reset_data_interface()
956 	 * To transition from NV-DDR or NV-DDR2 to the SDR data  in nand_reset_data_interface()
968 	ret = chip->setup_data_interface(mtd, chipnr, conf);  in nand_reset_data_interface()
976  * nand_setup_data_interface - Setup the best data interface and timings
984  * ->onfi_timing_mode_default specified in the nand_ids table.
993 	if (!chip->setup_data_interface || !chip->data_interface)  in nand_setup_data_interface()
1000 	if (chip->onfi_version) {  in nand_setup_data_interface()
1002 			chip->onfi_timing_mode_default,  in nand_setup_data_interface()
1005 		ret = chip->onfi_set_features(mtd, chip,  in nand_setup_data_interface()
1012 	ret = chip->setup_data_interface(mtd, chipnr, chip->data_interface);  in nand_setup_data_interface()
1018  * nand_init_data_interface - find the best data interface and timings
1025  * ->onfi_timing_mode_default specified in the nand_ids table. After this
1026  * function nand_chip->data_interface is initialized with the best timing mode
1036 	if (!chip->setup_data_interface)  in nand_init_data_interface()
1046 		if (!chip->onfi_timing_mode_default)  in nand_init_data_interface()
1049 		modes = GENMASK(chip->onfi_timing_mode_default, 0);  in nand_init_data_interface()
1052 	chip->data_interface = kzalloc(sizeof(*chip->data_interface),  in nand_init_data_interface()
1054 	if (!chip->data_interface)  in nand_init_data_interface()
1055 		return -ENOMEM;  in nand_init_data_interface()
1057 	for (mode = fls(modes) - 1; mode >= 0; mode--) {  in nand_init_data_interface()
1058 		ret = onfi_init_data_interface(chip, chip->data_interface,  in nand_init_data_interface()
1063 		/* Pass -1 to only */  in nand_init_data_interface()
1064 		ret = chip->setup_data_interface(mtd,  in nand_init_data_interface()
1066 						 chip->data_interface);  in nand_init_data_interface()
1068 			chip->onfi_timing_mode_default = mode;  in nand_init_data_interface()
1078 	kfree(chip->data_interface);  in nand_release_data_interface()
1082  * nand_read_page_op - Do a READ PAGE operation
1100 		return -EINVAL;  in nand_read_page_op()
1102 	if (offset_in_page + len > mtd->writesize + mtd->oobsize)  in nand_read_page_op()
1103 		return -EINVAL;  in nand_read_page_op()
1105 	chip->cmdfunc(mtd, NAND_CMD_READ0, offset_in_page, page);  in nand_read_page_op()
1107 		chip->read_buf(mtd, buf, len);  in nand_read_page_op()
1114  * nand_read_param_page_op - Do a READ PARAMETER PAGE operation
1133 		return -EINVAL;  in nand_read_param_page_op()
1135 	chip->cmdfunc(mtd, NAND_CMD_PARAM, page, -1);  in nand_read_param_page_op()
1137 		p[i] = chip->read_byte(mtd);  in nand_read_param_page_op()
1143  * nand_change_read_column_op - Do a CHANGE READ COLUMN operation
1148  * @force_8bit: force 8-bit bus access
1162 		return -EINVAL;  in nand_change_read_column_op()
1164 	if (offset_in_page + len > mtd->writesize + mtd->oobsize)  in nand_change_read_column_op()
1165 		return -EINVAL;  in nand_change_read_column_op()
1167 	chip->cmdfunc(mtd, NAND_CMD_RNDOUT, offset_in_page, -1);  in nand_change_read_column_op()
1169 		chip->read_buf(mtd, buf, len);  in nand_change_read_column_op()
1176  * nand_read_oob_op - Do a READ OOB operation
1194 		return -EINVAL;  in nand_read_oob_op()
1196 	if (offset_in_oob + len > mtd->oobsize)  in nand_read_oob_op()
1197 		return -EINVAL;  in nand_read_oob_op()
1199 	chip->cmdfunc(mtd, NAND_CMD_READOOB, offset_in_oob, page);  in nand_read_oob_op()
1201 		chip->read_buf(mtd, buf, len);  in nand_read_oob_op()
1208  * nand_prog_page_begin_op - starts a PROG PAGE operation
1227 		return -EINVAL;  in nand_prog_page_begin_op()
1229 	if (offset_in_page + len > mtd->writesize + mtd->oobsize)  in nand_prog_page_begin_op()
1230 		return -EINVAL;  in nand_prog_page_begin_op()
1232 	chip->cmdfunc(mtd, NAND_CMD_SEQIN, offset_in_page, page);  in nand_prog_page_begin_op()
1235 		chip->write_buf(mtd, buf, len);  in nand_prog_page_begin_op()
1242  * nand_prog_page_end_op - ends a PROG PAGE operation
1255 	chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);  in nand_prog_page_end_op()
1257 	status = chip->waitfunc(mtd, chip);  in nand_prog_page_end_op()
1259 		return -EIO;  in nand_prog_page_end_op()
1266  * nand_prog_page_op - Do a full PROG PAGE operation
1286 		return -EINVAL;  in nand_prog_page_op()
1288 	if (offset_in_page + len > mtd->writesize + mtd->oobsize)  in nand_prog_page_op()
1289 		return -EINVAL;  in nand_prog_page_op()
1291 	chip->cmdfunc(mtd, NAND_CMD_SEQIN, offset_in_page, page);  in nand_prog_page_op()
1292 	chip->write_buf(mtd, buf, len);  in nand_prog_page_op()
1293 	chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);  in nand_prog_page_op()
1295 	status = chip->waitfunc(mtd, chip);  in nand_prog_page_op()
1297 		return -EIO;  in nand_prog_page_op()
1304  * nand_change_write_column_op - Do a CHANGE WRITE COLUMN operation
1309  * @force_8bit: force 8-bit bus access
1324 		return -EINVAL;  in nand_change_write_column_op()
1326 	if (offset_in_page + len > mtd->writesize + mtd->oobsize)  in nand_change_write_column_op()
1327 		return -EINVAL;  in nand_change_write_column_op()
1329 	chip->cmdfunc(mtd, NAND_CMD_RNDIN, offset_in_page, -1);  in nand_change_write_column_op()
1331 		chip->write_buf(mtd, buf, len);  in nand_change_write_column_op()
1338  * nand_readid_op - Do a READID operation
1358 		return -EINVAL;  in nand_readid_op()
1360 	chip->cmdfunc(mtd, NAND_CMD_READID, addr, -1);  in nand_readid_op()
1363 		id[i] = chip->read_byte(mtd);  in nand_readid_op()
1370  * nand_status_op - Do a STATUS operation
1384 	chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);  in nand_status_op()
1386 		*status = chip->read_byte(mtd);  in nand_status_op()
1393  * nand_exit_status_op - Exit a STATUS operation
1407 	chip->cmdfunc(mtd, NAND_CMD_READ0, -1, -1);  in nand_exit_status_op()
1414  * nand_erase_op - Do an erase operation
1428 			    (chip->phys_erase_shift - chip->page_shift);  in nand_erase_op()
1431 	chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);  in nand_erase_op()
1432 	chip->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);  in nand_erase_op()
1434 	status = chip->waitfunc(mtd, chip);  in nand_erase_op()
1439 		return -EIO;  in nand_erase_op()
1446  * nand_set_features_op - Do a SET FEATURES operation
1464 	chip->cmdfunc(mtd, NAND_CMD_SET_FEATURES, feature, -1);  in nand_set_features_op()
1466 		chip->write_byte(mtd, params[i]);  in nand_set_features_op()
1468 	status = chip->waitfunc(mtd, chip);  in nand_set_features_op()
1470 		return -EIO;  in nand_set_features_op()
1476  * nand_get_features_op - Do a GET FEATURES operation
1494 	chip->cmdfunc(mtd, NAND_CMD_GET_FEATURES, feature, -1);  in nand_get_features_op()
1496 		params[i] = chip->read_byte(mtd);  in nand_get_features_op()
1502  * nand_reset_op - Do a reset operation
1515 	chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);  in nand_reset_op()
1522  * nand_read_data_op - Read data from the NAND
1526  * @force_8bit: force 8-bit bus access
1540 		return -EINVAL;  in nand_read_data_op()
1547 			p[i] = chip->read_byte(mtd);  in nand_read_data_op()
1549 		chip->read_buf(mtd, buf, len);  in nand_read_data_op()
1557  * nand_write_data_op - Write data from the NAND
1561  * @force_8bit: force 8-bit bus access
1575 		return -EINVAL;  in nand_write_data_op()
1582 			chip->write_byte(mtd, p[i]);  in nand_write_data_op()
1584 		chip->write_buf(mtd, buf, len);  in nand_write_data_op()
1592  * nand_reset - Reset and initialize a NAND device
1609 	 * interface settings, hence this weird ->select_chip() dance.  in nand_reset()
1611 	chip->select_chip(mtd, chipnr);  in nand_reset()
1613 	chip->select_chip(mtd, -1);  in nand_reset()
1617 	chip->select_chip(mtd, chipnr);  in nand_reset()
1619 	chip->select_chip(mtd, -1);  in nand_reset()
1627  * nand_check_erased_buf - check if a buffer contains (almost) only 0xff data
1642  * bitflips_threshold, or -ERROR_CODE for bitflips in excess of the
1652 	     len--, bitmap++) {  in nand_check_erased_buf()
1654 		bitflips += BITS_PER_BYTE - weight;  in nand_check_erased_buf()
1656 			return -EBADMSG;  in nand_check_erased_buf()
1659 	for (; len >= 4; len -= 4, bitmap += 4) {  in nand_check_erased_buf()
1661 		bitflips += 32 - weight;  in nand_check_erased_buf()
1663 			return -EBADMSG;  in nand_check_erased_buf()
1666 	for (; len > 0; len--, bitmap++) {  in nand_check_erased_buf()
1668 		bitflips += BITS_PER_BYTE - weight;  in nand_check_erased_buf()
1670 			return -EBADMSG;  in nand_check_erased_buf()
1677  * nand_check_erased_ecc_chunk - check if an ECC chunk contains (almost) only
1694  * 1/ ECC algorithms are working on pre-defined block sizes which are usually
1712  * bitflips_threshold, or -ERROR_CODE for bitflips in excess of the
1727 	bitflips_threshold -= data_bitflips;  in nand_check_erased_ecc_chunk()
1733 	bitflips_threshold -= ecc_bitflips;  in nand_check_erased_ecc_chunk()
1754  * nand_read_page_raw - [INTERN] read raw page data without ecc
1758  * @oob_required: caller requires OOB data read to chip->oob_poi
1768 	ret = nand_read_data_op(chip, buf, mtd->writesize, false);  in nand_read_page_raw()
1773 		ret = nand_read_data_op(chip, chip->oob_poi, mtd->oobsize,  in nand_read_page_raw()
1783  * nand_read_page_raw_syndrome - [INTERN] read raw page data without ecc
1787  * @oob_required: caller requires OOB data read to chip->oob_poi
1796 	int eccsize = chip->ecc.size;  in nand_read_page_raw_syndrome()
1797 	int eccbytes = chip->ecc.bytes;  in nand_read_page_raw_syndrome()
1798 	uint8_t *oob = chip->oob_poi;  in nand_read_page_raw_syndrome()
1801 	for (steps = chip->ecc.steps; steps > 0; steps--) {  in nand_read_page_raw_syndrome()
1808 		if (chip->ecc.prepad) {  in nand_read_page_raw_syndrome()
1809 			ret = nand_read_data_op(chip, oob, chip->ecc.prepad,  in nand_read_page_raw_syndrome()
1814 			oob += chip->ecc.prepad;  in nand_read_page_raw_syndrome()
1823 		if (chip->ecc.postpad) {  in nand_read_page_raw_syndrome()
1824 			ret = nand_read_data_op(chip, oob, chip->ecc.postpad,  in nand_read_page_raw_syndrome()
1829 			oob += chip->ecc.postpad;  in nand_read_page_raw_syndrome()
1833 	size = mtd->oobsize - (oob - chip->oob_poi);  in nand_read_page_raw_syndrome()
1844  * nand_read_page_swecc - [REPLACEABLE] software ECC based page read function
1848  * @oob_required: caller requires OOB data read to chip->oob_poi
1854 	int i, eccsize = chip->ecc.size;  in nand_read_page_swecc()
1855 	int eccbytes = chip->ecc.bytes;  in nand_read_page_swecc()
1856 	int eccsteps = chip->ecc.steps;  in nand_read_page_swecc()
1858 	uint8_t *ecc_calc = chip->buffers->ecccalc;  in nand_read_page_swecc()
1859 	uint8_t *ecc_code = chip->buffers->ecccode;  in nand_read_page_swecc()
1860 	uint32_t *eccpos = chip->ecc.layout->eccpos;  in nand_read_page_swecc()
1863 	chip->ecc.read_page_raw(mtd, chip, buf, 1, page);  in nand_read_page_swecc()
1865 	for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize)  in nand_read_page_swecc()
1866 		chip->ecc.calculate(mtd, p, &ecc_calc[i]);  in nand_read_page_swecc()
1868 	for (i = 0; i < chip->ecc.total; i++)  in nand_read_page_swecc()
1869 		ecc_code[i] = chip->oob_poi[eccpos[i]];  in nand_read_page_swecc()
1871 	eccsteps = chip->ecc.steps;  in nand_read_page_swecc()
1874 	for (i = 0 ; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {  in nand_read_page_swecc()
1877 		stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]);  in nand_read_page_swecc()
1879 			mtd->ecc_stats.failed++;  in nand_read_page_swecc()
1881 			mtd->ecc_stats.corrected += stat;  in nand_read_page_swecc()
1889  * nand_read_subpage - [REPLACEABLE] ECC based sub-page read function
1902 	uint32_t *eccpos = chip->ecc.layout->eccpos;  in nand_read_subpage()
1906 	int busw = (chip->options & NAND_BUSWIDTH_16) ? 2 : 1;  in nand_read_subpage()
1912 	start_step = data_offs / chip->ecc.size;  in nand_read_subpage()
1913 	end_step = (data_offs + readlen - 1) / chip->ecc.size;  in nand_read_subpage()
1914 	num_steps = end_step - start_step + 1;  in nand_read_subpage()
1915 	index = start_step * chip->ecc.bytes;  in nand_read_subpage()
1918 	datafrag_len = num_steps * chip->ecc.size;  in nand_read_subpage()
1919 	eccfrag_len = num_steps * chip->ecc.bytes;  in nand_read_subpage()
1921 	data_col_addr = start_step * chip->ecc.size;  in nand_read_subpage()
1924 		chip->cmdfunc(mtd, NAND_CMD_RNDOUT, data_col_addr, -1);  in nand_read_subpage()
1932 	for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size)  in nand_read_subpage()
1933 		chip->ecc.calculate(mtd, p, &chip->buffers->ecccalc[i]);  in nand_read_subpage()
1939 	for (i = 0; i < eccfrag_len - 1; i++) {  in nand_read_subpage()
1946 		ret = nand_change_read_column_op(chip, mtd->writesize,  in nand_read_subpage()
1947 						 chip->oob_poi, mtd->oobsize,  in nand_read_subpage()
1956 		aligned_pos = eccpos[index] & ~(busw - 1);  in nand_read_subpage()
1958 		if (eccpos[index] & (busw - 1))  in nand_read_subpage()
1960 		if (eccpos[index + (num_steps * chip->ecc.bytes)] & (busw - 1))  in nand_read_subpage()
1964 						 mtd->writesize + aligned_pos,  in nand_read_subpage()
1965 						 &chip->oob_poi[aligned_pos],  in nand_read_subpage()
1972 		chip->buffers->ecccode[i] = chip->oob_poi[eccpos[i + index]];  in nand_read_subpage()
1975 	for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size) {  in nand_read_subpage()
1978 		stat = chip->ecc.correct(mtd, p,  in nand_read_subpage()
1979 			&chip->buffers->ecccode[i], &chip->buffers->ecccalc[i]);  in nand_read_subpage()
1980 		if (stat == -EBADMSG &&  in nand_read_subpage()
1981 		    (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {  in nand_read_subpage()
1983 			stat = nand_check_erased_ecc_chunk(p, chip->ecc.size,  in nand_read_subpage()
1984 						&chip->buffers->ecccode[i],  in nand_read_subpage()
1985 						chip->ecc.bytes,  in nand_read_subpage()
1987 						chip->ecc.strength);  in nand_read_subpage()
1991 			mtd->ecc_stats.failed++;  in nand_read_subpage()
1993 			mtd->ecc_stats.corrected += stat;  in nand_read_subpage()
2001  * nand_read_page_hwecc - [REPLACEABLE] hardware ECC based page read function
2005  * @oob_required: caller requires OOB data read to chip->oob_poi
2013 	int i, eccsize = chip->ecc.size;  in nand_read_page_hwecc()
2014 	int eccbytes = chip->ecc.bytes;  in nand_read_page_hwecc()
2015 	int eccsteps = chip->ecc.steps;  in nand_read_page_hwecc()
2017 	uint8_t *ecc_calc = chip->buffers->ecccalc;  in nand_read_page_hwecc()
2018 	uint8_t *ecc_code = chip->buffers->ecccode;  in nand_read_page_hwecc()
2019 	uint32_t *eccpos = chip->ecc.layout->eccpos;  in nand_read_page_hwecc()
2023 	for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {  in nand_read_page_hwecc()
2024 		chip->ecc.hwctl(mtd, NAND_ECC_READ);  in nand_read_page_hwecc()
2030 		chip->ecc.calculate(mtd, p, &ecc_calc[i]);  in nand_read_page_hwecc()
2033 	ret = nand_read_data_op(chip, chip->oob_poi, mtd->oobsize, false);  in nand_read_page_hwecc()
2037 	for (i = 0; i < chip->ecc.total; i++)  in nand_read_page_hwecc()
2038 		ecc_code[i] = chip->oob_poi[eccpos[i]];  in nand_read_page_hwecc()
2040 	eccsteps = chip->ecc.steps;  in nand_read_page_hwecc()
2043 	for (i = 0 ; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {  in nand_read_page_hwecc()
2046 		stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]);  in nand_read_page_hwecc()
2047 		if (stat == -EBADMSG &&  in nand_read_page_hwecc()
2048 		    (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {  in nand_read_page_hwecc()
2053 						chip->ecc.strength);  in nand_read_page_hwecc()
2057 			mtd->ecc_stats.failed++;  in nand_read_page_hwecc()
2059 			mtd->ecc_stats.corrected += stat;  in nand_read_page_hwecc()
2067  * nand_read_page_hwecc_oob_first - [REPLACEABLE] hw ecc, read oob first
2071  * @oob_required: caller requires OOB data read to chip->oob_poi
2075  * ECC mode, the write_page method is re-used from ECC_HW. These methods
2083 	int i, eccsize = chip->ecc.size;  in nand_read_page_hwecc_oob_first()
2084 	int eccbytes = chip->ecc.bytes;  in nand_read_page_hwecc_oob_first()
2085 	int eccsteps = chip->ecc.steps;  in nand_read_page_hwecc_oob_first()
2087 	uint8_t *ecc_code = chip->buffers->ecccode;  in nand_read_page_hwecc_oob_first()
2088 	uint32_t *eccpos = chip->ecc.layout->eccpos;  in nand_read_page_hwecc_oob_first()
2089 	uint8_t *ecc_calc = chip->buffers->ecccalc;  in nand_read_page_hwecc_oob_first()
2094 	ret = nand_read_oob_op(chip, page, 0, chip->oob_poi, mtd->oobsize);  in nand_read_page_hwecc_oob_first()
2102 	for (i = 0; i < chip->ecc.total; i++)  in nand_read_page_hwecc_oob_first()
2103 		ecc_code[i] = chip->oob_poi[eccpos[i]];  in nand_read_page_hwecc_oob_first()
2105 	for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {  in nand_read_page_hwecc_oob_first()
2108 		chip->ecc.hwctl(mtd, NAND_ECC_READ);  in nand_read_page_hwecc_oob_first()
2114 		chip->ecc.calculate(mtd, p, &ecc_calc[i]);  in nand_read_page_hwecc_oob_first()
2116 		stat = chip->ecc.correct(mtd, p, &ecc_code[i], NULL);  in nand_read_page_hwecc_oob_first()
2117 		if (stat == -EBADMSG &&  in nand_read_page_hwecc_oob_first()
2118 		    (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {  in nand_read_page_hwecc_oob_first()
2123 						chip->ecc.strength);  in nand_read_page_hwecc_oob_first()
2127 			mtd->ecc_stats.failed++;  in nand_read_page_hwecc_oob_first()
2129 			mtd->ecc_stats.corrected += stat;  in nand_read_page_hwecc_oob_first()
2137  * nand_read_page_syndrome - [REPLACEABLE] hardware ECC syndrome based page read
2141  * @oob_required: caller requires OOB data read to chip->oob_poi
2150 	int ret, i, eccsize = chip->ecc.size;  in nand_read_page_syndrome()
2151 	int eccbytes = chip->ecc.bytes;  in nand_read_page_syndrome()
2152 	int eccsteps = chip->ecc.steps;  in nand_read_page_syndrome()
2153 	int eccpadbytes = eccbytes + chip->ecc.prepad + chip->ecc.postpad;  in nand_read_page_syndrome()
2155 	uint8_t *oob = chip->oob_poi;  in nand_read_page_syndrome()
2158 	for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {  in nand_read_page_syndrome()
2161 		chip->ecc.hwctl(mtd, NAND_ECC_READ);  in nand_read_page_syndrome()
2167 		if (chip->ecc.prepad) {  in nand_read_page_syndrome()
2168 			ret = nand_read_data_op(chip, oob, chip->ecc.prepad,  in nand_read_page_syndrome()
2173 			oob += chip->ecc.prepad;  in nand_read_page_syndrome()
2176 		chip->ecc.hwctl(mtd, NAND_ECC_READSYN);  in nand_read_page_syndrome()
2182 		stat = chip->ecc.correct(mtd, p, oob, NULL);  in nand_read_page_syndrome()
2186 		if (chip->ecc.postpad) {  in nand_read_page_syndrome()
2187 			ret = nand_read_data_op(chip, oob, chip->ecc.postpad,  in nand_read_page_syndrome()
2192 			oob += chip->ecc.postpad;  in nand_read_page_syndrome()
2195 		if (stat == -EBADMSG &&  in nand_read_page_syndrome()
2196 		    (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {  in nand_read_page_syndrome()
2198 			stat = nand_check_erased_ecc_chunk(p, chip->ecc.size,  in nand_read_page_syndrome()
2199 							   oob - eccpadbytes,  in nand_read_page_syndrome()
2202 							   chip->ecc.strength);  in nand_read_page_syndrome()
2206 			mtd->ecc_stats.failed++;  in nand_read_page_syndrome()
2208 			mtd->ecc_stats.corrected += stat;  in nand_read_page_syndrome()
2214 	i = mtd->oobsize - (oob - chip->oob_poi);  in nand_read_page_syndrome()
2225  * nand_transfer_oob - [INTERN] Transfer oob to client buffer
2234 	switch (ops->mode) {  in nand_transfer_oob()
2238 		memcpy(oob, chip->oob_poi + ops->ooboffs, len);  in nand_transfer_oob()
2242 		struct nand_oobfree *free = chip->ecc.layout->oobfree;  in nand_transfer_oob()
2243 		uint32_t boffs = 0, roffs = ops->ooboffs;  in nand_transfer_oob()
2246 		for (; free->length && len; free++, len -= bytes) {  in nand_transfer_oob()
2249 				if (roffs >= free->length) {  in nand_transfer_oob()
2250 					roffs -= free->length;  in nand_transfer_oob()
2253 				boffs = free->offset + roffs;  in nand_transfer_oob()
2255 					      (free->length - roffs));  in nand_transfer_oob()
2258 				bytes = min_t(size_t, len, free->length);  in nand_transfer_oob()
2259 				boffs = free->offset;  in nand_transfer_oob()
2261 			memcpy(oob, chip->oob_poi + boffs, bytes);  in nand_transfer_oob()
2273  * nand_setup_read_retry - [INTERN] Set the READ RETRY mode
2287 	if (retry_mode >= chip->read_retries)  in nand_setup_read_retry()
2288 		return -EINVAL;  in nand_setup_read_retry()
2290 	if (!chip->setup_read_retry)  in nand_setup_read_retry()
2291 		return -EOPNOTSUPP;  in nand_setup_read_retry()
2293 	return chip->setup_read_retry(mtd, retry_mode);  in nand_setup_read_retry()
2297  * nand_do_read_ops - [INTERN] Read data with ECC
2310 	uint32_t readlen = ops->len;  in nand_do_read_ops()
2311 	uint32_t oobreadlen = ops->ooblen;  in nand_do_read_ops()
2320 	chipnr = (int)(from >> chip->chip_shift);  in nand_do_read_ops()
2321 	chip->select_chip(mtd, chipnr);  in nand_do_read_ops()
2323 	realpage = (int)(from >> chip->page_shift);  in nand_do_read_ops()
2324 	page = realpage & chip->pagemask;  in nand_do_read_ops()
2326 	col = (int)(from & (mtd->writesize - 1));  in nand_do_read_ops()
2328 	buf = ops->datbuf;  in nand_do_read_ops()
2329 	oob = ops->oobbuf;  in nand_do_read_ops()
2333 		unsigned int ecc_failures = mtd->ecc_stats.failed;  in nand_do_read_ops()
2336 		bytes = min(mtd->writesize - col, readlen);  in nand_do_read_ops()
2337 		aligned = (bytes == mtd->writesize);  in nand_do_read_ops()
2341 		else if (chip->options & NAND_USE_BOUNCE_BUFFER)  in nand_do_read_ops()
2343 						 chip->buf_align);  in nand_do_read_ops()
2348 		if (realpage != chip->pagebuf || oob) {  in nand_do_read_ops()
2349 			bufpoi = use_bufpoi ? chip->buffers->databuf : buf;  in nand_do_read_ops()
2356 			if (nand_standard_page_accessors(&chip->ecc)) {  in nand_do_read_ops()
2366 			if (unlikely(ops->mode == MTD_OPS_RAW))  in nand_do_read_ops()
2367 				ret = chip->ecc.read_page_raw(mtd, chip, bufpoi,  in nand_do_read_ops()
2372 				ret = chip->ecc.read_subpage(mtd, chip,  in nand_do_read_ops()
2376 				ret = chip->ecc.read_page(mtd, chip, bufpoi,  in nand_do_read_ops()
2381 					chip->pagebuf = -1;  in nand_do_read_ops()
2390 				    !(mtd->ecc_stats.failed - ecc_failures) &&  in nand_do_read_ops()
2391 				    (ops->mode != MTD_OPS_RAW)) {  in nand_do_read_ops()
2392 					chip->pagebuf = realpage;  in nand_do_read_ops()
2393 					chip->pagebuf_bitflips = ret;  in nand_do_read_ops()
2396 					chip->pagebuf = -1;  in nand_do_read_ops()
2398 				memcpy(buf, chip->buffers->databuf + col, bytes);  in nand_do_read_ops()
2407 					oobreadlen -= toread;  in nand_do_read_ops()
2411 			if (chip->options & NAND_NEED_READRDY) {  in nand_do_read_ops()
2413 				if (!chip->dev_ready)  in nand_do_read_ops()
2414 					udelay(chip->chip_delay);  in nand_do_read_ops()
2419 			if (mtd->ecc_stats.failed - ecc_failures) {  in nand_do_read_ops()
2420 				if (retry_mode + 1 < chip->read_retries) {  in nand_do_read_ops()
2428 					mtd->ecc_stats.failed = ecc_failures;  in nand_do_read_ops()
2438 			memcpy(buf, chip->buffers->databuf + col, bytes);  in nand_do_read_ops()
2441 					     chip->pagebuf_bitflips);  in nand_do_read_ops()
2444 		readlen -= bytes;  in nand_do_read_ops()
2462 		page = realpage & chip->pagemask;  in nand_do_read_ops()
2466 			chip->select_chip(mtd, -1);  in nand_do_read_ops()
2467 			chip->select_chip(mtd, chipnr);  in nand_do_read_ops()
2470 	chip->select_chip(mtd, -1);  in nand_do_read_ops()
2472 	ops->retlen = ops->len - (size_t) readlen;  in nand_do_read_ops()
2474 		ops->oobretlen = ops->ooblen - oobreadlen;  in nand_do_read_ops()
2480 		return -EBADMSG;  in nand_do_read_ops()
2486  * nand_read_oob_std - [REPLACEABLE] the most common OOB data read function
2494 	return nand_read_oob_op(chip, page, 0, chip->oob_poi, mtd->oobsize);  in nand_read_oob_std()
2498  * nand_read_oob_syndrome - [REPLACEABLE] OOB data read function for HW ECC
2507 	int length = mtd->oobsize;  in nand_read_oob_syndrome()
2508 	int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;  in nand_read_oob_syndrome()
2509 	int eccsize = chip->ecc.size;  in nand_read_oob_syndrome()
2510 	uint8_t *bufpoi = chip->oob_poi;  in nand_read_oob_syndrome()
2513 	ret = nand_read_page_op(chip, page, chip->ecc.size, NULL, 0);  in nand_read_oob_syndrome()
2517 	for (i = 0; i < chip->ecc.steps; i++) {  in nand_read_oob_syndrome()
2522 			if (mtd->writesize > 512)  in nand_read_oob_syndrome()
2541 		length -= toread;  in nand_read_oob_syndrome()
2553  * nand_write_oob_std - [REPLACEABLE] the most common OOB data write function
2561 	return nand_prog_page_op(chip, page, mtd->writesize, chip->oob_poi,  in nand_write_oob_std()
2562 				 mtd->oobsize);  in nand_write_oob_std()
2566  * nand_write_oob_syndrome - [REPLACEABLE] OOB data write function for HW ECC
2567  *			     with syndrome - only for large page flash
2575 	int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;  in nand_write_oob_syndrome()
2576 	int eccsize = chip->ecc.size, length = mtd->oobsize;  in nand_write_oob_syndrome()
2577 	int ret, i, len, pos, sndcmd = 0, steps = chip->ecc.steps;  in nand_write_oob_syndrome()
2578 	const uint8_t *bufpoi = chip->oob_poi;  in nand_write_oob_syndrome()
2581 	 * data-ecc-data-ecc ... ecc-oob  in nand_write_oob_syndrome()
2583 	 * data-pad-ecc-pad-data-pad .... ecc-pad-oob  in nand_write_oob_syndrome()
2585 	if (!chip->ecc.prepad && !chip->ecc.postpad) {  in nand_write_oob_syndrome()
2597 			if (mtd->writesize <= 512) {  in nand_write_oob_syndrome()
2609 					len -= num;  in nand_write_oob_syndrome()
2628 		length -= len;  in nand_write_oob_syndrome()
2640  * nand_do_read_oob - [INTERN] NAND read out-of-band
2645  * NAND read out-of-band data from the spare area.
2653 	int readlen = ops->ooblen;  in nand_do_read_oob()
2655 	uint8_t *buf = ops->oobbuf;  in nand_do_read_oob()
2661 	stats = mtd->ecc_stats;  in nand_do_read_oob()
2665 	if (unlikely(ops->ooboffs >= len)) {  in nand_do_read_oob()
2668 		return -EINVAL;  in nand_do_read_oob()
2672 	if (unlikely(from >= mtd->size ||  in nand_do_read_oob()
2673 		     ops->ooboffs + readlen > ((mtd->size >> chip->page_shift) -  in nand_do_read_oob()
2674 					(from >> chip->page_shift)) * len)) {  in nand_do_read_oob()
2677 		return -EINVAL;  in nand_do_read_oob()
2680 	chipnr = (int)(from >> chip->chip_shift);  in nand_do_read_oob()
2681 	chip->select_chip(mtd, chipnr);  in nand_do_read_oob()
2684 	realpage = (int)(from >> chip->page_shift);  in nand_do_read_oob()
2685 	page = realpage & chip->pagemask;  in nand_do_read_oob()
2690 		if (ops->mode == MTD_OPS_RAW)  in nand_do_read_oob()
2691 			ret = chip->ecc.read_oob_raw(mtd, chip, page);  in nand_do_read_oob()
2693 			ret = chip->ecc.read_oob(mtd, chip, page);  in nand_do_read_oob()
2701 		if (chip->options & NAND_NEED_READRDY) {  in nand_do_read_oob()
2703 			if (!chip->dev_ready)  in nand_do_read_oob()
2704 				udelay(chip->chip_delay);  in nand_do_read_oob()
2709 		readlen -= len;  in nand_do_read_oob()
2716 		page = realpage & chip->pagemask;  in nand_do_read_oob()
2720 			chip->select_chip(mtd, -1);  in nand_do_read_oob()
2721 			chip->select_chip(mtd, chipnr);  in nand_do_read_oob()
2724 	chip->select_chip(mtd, -1);  in nand_do_read_oob()
2726 	ops->oobretlen = ops->ooblen - readlen;  in nand_do_read_oob()
2731 	if (mtd->ecc_stats.failed - stats.failed)  in nand_do_read_oob()
2732 		return -EBADMSG;  in nand_do_read_oob()
2734 	return  mtd->ecc_stats.corrected - stats.corrected ? -EUCLEAN : 0;  in nand_do_read_oob()
2738  * nand_read_oob - [MTD Interface] NAND read data and/or out-of-band
2743  * NAND read data and/or out-of-band data.
2748 	int ret = -ENOTSUPP;  in nand_read_oob()
2750 	ops->retlen = 0;  in nand_read_oob()
2753 	if (ops->datbuf && (from + ops->len) > mtd->size) {  in nand_read_oob()
2756 		return -EINVAL;  in nand_read_oob()
2761 	switch (ops->mode) {  in nand_read_oob()
2771 	if (!ops->datbuf)  in nand_read_oob()
2783  * nand_write_page_raw - [INTERN] raw page write function
2787  * @oob_required: must write chip->oob_poi to OOB
2797 	ret = nand_write_data_op(chip, buf, mtd->writesize, false);  in nand_write_page_raw()
2802 		ret = nand_write_data_op(chip, chip->oob_poi, mtd->oobsize,  in nand_write_page_raw()
2812  * nand_write_page_raw_syndrome - [INTERN] raw page write function
2816  * @oob_required: must write chip->oob_poi to OOB
2826 	int eccsize = chip->ecc.size;  in nand_write_page_raw_syndrome()
2827 	int eccbytes = chip->ecc.bytes;  in nand_write_page_raw_syndrome()
2828 	uint8_t *oob = chip->oob_poi;  in nand_write_page_raw_syndrome()
2831 	for (steps = chip->ecc.steps; steps > 0; steps--) {  in nand_write_page_raw_syndrome()
2838 		if (chip->ecc.prepad) {  in nand_write_page_raw_syndrome()
2839 			ret = nand_write_data_op(chip, oob, chip->ecc.prepad,  in nand_write_page_raw_syndrome()
2844 			oob += chip->ecc.prepad;  in nand_write_page_raw_syndrome()
2853 		if (chip->ecc.postpad) {  in nand_write_page_raw_syndrome()
2854 			ret = nand_write_data_op(chip, oob, chip->ecc.postpad,  in nand_write_page_raw_syndrome()
2859 			oob += chip->ecc.postpad;  in nand_write_page_raw_syndrome()
2863 	size = mtd->oobsize - (oob - chip->oob_poi);  in nand_write_page_raw_syndrome()
2873  * nand_write_page_swecc - [REPLACEABLE] software ECC based page write function
2877  * @oob_required: must write chip->oob_poi to OOB
2884 	int i, eccsize = chip->ecc.size;  in nand_write_page_swecc()
2885 	int eccbytes = chip->ecc.bytes;  in nand_write_page_swecc()
2886 	int eccsteps = chip->ecc.steps;  in nand_write_page_swecc()
2887 	uint8_t *ecc_calc = chip->buffers->ecccalc;  in nand_write_page_swecc()
2889 	uint32_t *eccpos = chip->ecc.layout->eccpos;  in nand_write_page_swecc()
2892 	for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize)  in nand_write_page_swecc()
2893 		chip->ecc.calculate(mtd, p, &ecc_calc[i]);  in nand_write_page_swecc()
2895 	for (i = 0; i < chip->ecc.total; i++)  in nand_write_page_swecc()
2896 		chip->oob_poi[eccpos[i]] = ecc_calc[i];  in nand_write_page_swecc()
2898 	return chip->ecc.write_page_raw(mtd, chip, buf, 1, page);  in nand_write_page_swecc()
2902  * nand_write_page_hwecc - [REPLACEABLE] hardware ECC based page write function
2906  * @oob_required: must write chip->oob_poi to OOB
2913 	int i, eccsize = chip->ecc.size;  in nand_write_page_hwecc()
2914 	int eccbytes = chip->ecc.bytes;  in nand_write_page_hwecc()
2915 	int eccsteps = chip->ecc.steps;  in nand_write_page_hwecc()
2916 	uint8_t *ecc_calc = chip->buffers->ecccalc;  in nand_write_page_hwecc()
2918 	uint32_t *eccpos = chip->ecc.layout->eccpos;  in nand_write_page_hwecc()
2921 	for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {  in nand_write_page_hwecc()
2922 		chip->ecc.hwctl(mtd, NAND_ECC_WRITE);  in nand_write_page_hwecc()
2928 		chip->ecc.calculate(mtd, p, &ecc_calc[i]);  in nand_write_page_hwecc()
2931 	for (i = 0; i < chip->ecc.total; i++)  in nand_write_page_hwecc()
2932 		chip->oob_poi[eccpos[i]] = ecc_calc[i];  in nand_write_page_hwecc()
2934 	ret = nand_write_data_op(chip, chip->oob_poi, mtd->oobsize, false);  in nand_write_page_hwecc()
2943  * nand_write_subpage_hwecc - [REPLACEABLE] hardware ECC based subpage write
2949  * @oob_required: must write chip->oob_poi to OOB
2957 	uint8_t *oob_buf  = chip->oob_poi;  in nand_write_subpage_hwecc()
2958 	uint8_t *ecc_calc = chip->buffers->ecccalc;  in nand_write_subpage_hwecc()
2959 	int ecc_size      = chip->ecc.size;  in nand_write_subpage_hwecc()
2960 	int ecc_bytes     = chip->ecc.bytes;  in nand_write_subpage_hwecc()
2961 	int ecc_steps     = chip->ecc.steps;  in nand_write_subpage_hwecc()
2962 	uint32_t *eccpos  = chip->ecc.layout->eccpos;  in nand_write_subpage_hwecc()
2964 	uint32_t end_step   = (offset + data_len - 1) / ecc_size;  in nand_write_subpage_hwecc()
2965 	int oob_bytes       = mtd->oobsize / ecc_steps;  in nand_write_subpage_hwecc()
2971 		chip->ecc.hwctl(mtd, NAND_ECC_WRITE);  in nand_write_subpage_hwecc()
2978 		/* mask ECC of un-touched subpages by padding 0xFF */  in nand_write_subpage_hwecc()
2982 			chip->ecc.calculate(mtd, buf, ecc_calc);  in nand_write_subpage_hwecc()
2984 		/* mask OOB of un-touched subpages by padding 0xFF */  in nand_write_subpage_hwecc()
2994 	/* copy calculated ECC for whole page to chip->buffer->oob */  in nand_write_subpage_hwecc()
2995 	/* this include masked-value(0xFF) for unwritten subpages */  in nand_write_subpage_hwecc()
2996 	ecc_calc = chip->buffers->ecccalc;  in nand_write_subpage_hwecc()
2997 	for (i = 0; i < chip->ecc.total; i++)  in nand_write_subpage_hwecc()
2998 		chip->oob_poi[eccpos[i]] = ecc_calc[i];  in nand_write_subpage_hwecc()
3001 	ret = nand_write_data_op(chip, chip->oob_poi, mtd->oobsize, false);  in nand_write_subpage_hwecc()
3010  * nand_write_page_syndrome - [REPLACEABLE] hardware ECC syndrome based page write
3014  * @oob_required: must write chip->oob_poi to OOB
3025 	int i, eccsize = chip->ecc.size;  in nand_write_page_syndrome()
3026 	int eccbytes = chip->ecc.bytes;  in nand_write_page_syndrome()
3027 	int eccsteps = chip->ecc.steps;  in nand_write_page_syndrome()
3029 	uint8_t *oob = chip->oob_poi;  in nand_write_page_syndrome()
3032 	for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {  in nand_write_page_syndrome()
3033 		chip->ecc.hwctl(mtd, NAND_ECC_WRITE);  in nand_write_page_syndrome()
3039 		if (chip->ecc.prepad) {  in nand_write_page_syndrome()
3040 			ret = nand_write_data_op(chip, oob, chip->ecc.prepad,  in nand_write_page_syndrome()
3045 			oob += chip->ecc.prepad;  in nand_write_page_syndrome()
3048 		chip->ecc.calculate(mtd, p, oob);  in nand_write_page_syndrome()
3056 		if (chip->ecc.postpad) {  in nand_write_page_syndrome()
3057 			ret = nand_write_data_op(chip, oob, chip->ecc.postpad,  in nand_write_page_syndrome()
3062 			oob += chip->ecc.postpad;  in nand_write_page_syndrome()
3067 	i = mtd->oobsize - (oob - chip->oob_poi);  in nand_write_page_syndrome()
3078  * nand_write_page - [REPLACEABLE] write one page
3084  * @oob_required: must write chip->oob_poi to OOB
3094 	if (!(chip->options & NAND_NO_SUBPAGE_WRITE) &&  in nand_write_page()
3095 		chip->ecc.write_subpage)  in nand_write_page()
3096 		subpage = offset || (data_len < mtd->writesize);  in nand_write_page()
3100 	if (nand_standard_page_accessors(&chip->ecc)) {  in nand_write_page()
3107 		status = chip->ecc.write_page_raw(mtd, chip, buf,  in nand_write_page()
3110 		status = chip->ecc.write_subpage(mtd, chip, offset, data_len,  in nand_write_page()
3113 		status = chip->ecc.write_page(mtd, chip, buf, oob_required,  in nand_write_page()
3119 	if (nand_standard_page_accessors(&chip->ecc))  in nand_write_page()
3126  * nand_fill_oob - [INTERN] Transfer client buffer to oob
3141 	memset(chip->oob_poi, 0xff, mtd->oobsize);  in nand_fill_oob()
3143 	switch (ops->mode) {  in nand_fill_oob()
3147 		memcpy(chip->oob_poi + ops->ooboffs, oob, len);  in nand_fill_oob()
3151 		struct nand_oobfree *free = chip->ecc.layout->oobfree;  in nand_fill_oob()
3152 		uint32_t boffs = 0, woffs = ops->ooboffs;  in nand_fill_oob()
3155 		for (; free->length && len; free++, len -= bytes) {  in nand_fill_oob()
3158 				if (woffs >= free->length) {  in nand_fill_oob()
3159 					woffs -= free->length;  in nand_fill_oob()
3162 				boffs = free->offset + woffs;  in nand_fill_oob()
3164 					      (free->length - woffs));  in nand_fill_oob()
3167 				bytes = min_t(size_t, len, free->length);  in nand_fill_oob()
3168 				boffs = free->offset;  in nand_fill_oob()
3170 			memcpy(chip->oob_poi + boffs, oob, bytes);  in nand_fill_oob()
3181 #define NOTALIGNED(x)	((x & (chip->subpagesize - 1)) != 0)
3184  * nand_do_write_ops - [INTERN] NAND write with ECC
3196 	uint32_t writelen = ops->len;  in nand_do_write_ops()
3198 	uint32_t oobwritelen = ops->ooblen;  in nand_do_write_ops()
3201 	uint8_t *oob = ops->oobbuf;  in nand_do_write_ops()
3202 	uint8_t *buf = ops->datbuf;  in nand_do_write_ops()
3206 	ops->retlen = 0;  in nand_do_write_ops()
3214 		return -EINVAL;  in nand_do_write_ops()
3217 	column = to & (mtd->writesize - 1);  in nand_do_write_ops()
3219 	chipnr = (int)(to >> chip->chip_shift);  in nand_do_write_ops()
3220 	chip->select_chip(mtd, chipnr);  in nand_do_write_ops()
3224 		ret = -EIO;  in nand_do_write_ops()
3228 	realpage = (int)(to >> chip->page_shift);  in nand_do_write_ops()
3229 	page = realpage & chip->pagemask;  in nand_do_write_ops()
3232 	if (to <= ((loff_t)chip->pagebuf << chip->page_shift) &&  in nand_do_write_ops()
3233 	    ((loff_t)chip->pagebuf << chip->page_shift) < (to + ops->len))  in nand_do_write_ops()
3234 		chip->pagebuf = -1;  in nand_do_write_ops()
3237 	if (oob && ops->ooboffs && (ops->ooboffs + ops->ooblen > oobmaxlen)) {  in nand_do_write_ops()
3238 		ret = -EINVAL;  in nand_do_write_ops()
3243 		int bytes = mtd->writesize;  in nand_do_write_ops()
3246 		int part_pagewr = (column || writelen < mtd->writesize);  in nand_do_write_ops()
3250 		else if (chip->options & NAND_USE_BOUNCE_BUFFER)  in nand_do_write_ops()
3252 						 chip->buf_align);  in nand_do_write_ops()
3262 				bytes = min_t(int, bytes - column, writelen);  in nand_do_write_ops()
3263 			chip->pagebuf = -1;  in nand_do_write_ops()
3264 			memset(chip->buffers->databuf, 0xff, mtd->writesize);  in nand_do_write_ops()
3265 			memcpy(&chip->buffers->databuf[column], buf, bytes);  in nand_do_write_ops()
3266 			wbuf = chip->buffers->databuf;  in nand_do_write_ops()
3272 			oobwritelen -= len;  in nand_do_write_ops()
3275 			memset(chip->oob_poi, 0xff, mtd->oobsize);  in nand_do_write_ops()
3277 		ret = chip->write_page(mtd, chip, column, bytes, wbuf,  in nand_do_write_ops()
3279 					(ops->mode == MTD_OPS_RAW));  in nand_do_write_ops()
3283 		writelen -= bytes;  in nand_do_write_ops()
3291 		page = realpage & chip->pagemask;  in nand_do_write_ops()
3295 			chip->select_chip(mtd, -1);  in nand_do_write_ops()
3296 			chip->select_chip(mtd, chipnr);  in nand_do_write_ops()
3300 	ops->retlen = ops->len - writelen;  in nand_do_write_ops()
3302 		ops->oobretlen = ops->ooblen;  in nand_do_write_ops()
3305 	chip->select_chip(mtd, -1);  in nand_do_write_ops()
3310  * panic_nand_write - [MTD Interface] NAND write with ECC
3345  * nand_do_write_oob - [MTD Interface] NAND write out-of-band
3350  * NAND write out-of-band.
3359 			 __func__, (unsigned int)to, (int)ops->ooblen);  in nand_do_write_oob()
3364 	if ((ops->ooboffs + ops->ooblen) > len) {  in nand_do_write_oob()
3367 		return -EINVAL;  in nand_do_write_oob()
3370 	if (unlikely(ops->ooboffs >= len)) {  in nand_do_write_oob()
3373 		return -EINVAL;  in nand_do_write_oob()
3377 	if (unlikely(to >= mtd->size ||  in nand_do_write_oob()
3378 		     ops->ooboffs + ops->ooblen >  in nand_do_write_oob()
3379 			((mtd->size >> chip->page_shift) -  in nand_do_write_oob()
3380 			 (to >> chip->page_shift)) * len)) {  in nand_do_write_oob()
3383 		return -EINVAL;  in nand_do_write_oob()
3386 	chipnr = (int)(to >> chip->chip_shift);  in nand_do_write_oob()
3396 	chip->select_chip(mtd, chipnr);  in nand_do_write_oob()
3399 	page = (int)(to >> chip->page_shift);  in nand_do_write_oob()
3403 		chip->select_chip(mtd, -1);  in nand_do_write_oob()
3404 		return -EROFS;  in nand_do_write_oob()
3408 	if (page == chip->pagebuf)  in nand_do_write_oob()
3409 		chip->pagebuf = -1;  in nand_do_write_oob()
3411 	nand_fill_oob(mtd, ops->oobbuf, ops->ooblen, ops);  in nand_do_write_oob()
3413 	if (ops->mode == MTD_OPS_RAW)  in nand_do_write_oob()
3414 		status = chip->ecc.write_oob_raw(mtd, chip, page & chip->pagemask);  in nand_do_write_oob()
3416 		status = chip->ecc.write_oob(mtd, chip, page & chip->pagemask);  in nand_do_write_oob()
3418 	chip->select_chip(mtd, -1);  in nand_do_write_oob()
3423 	ops->oobretlen = ops->ooblen;  in nand_do_write_oob()
3429  * nand_write_oob - [MTD Interface] NAND write data and/or out-of-band
3437 	int ret = -ENOTSUPP;  in nand_write_oob()
3439 	ops->retlen = 0;  in nand_write_oob()
3442 	if (ops->datbuf && (to + ops->len) > mtd->size) {  in nand_write_oob()
3445 		return -EINVAL;  in nand_write_oob()
3450 	switch (ops->mode) {  in nand_write_oob()
3460 	if (!ops->datbuf)  in nand_write_oob()
3471  * single_erase - [GENERIC] NAND standard block erase command function
3483 	eraseblock = page >> (chip->phys_erase_shift - chip->page_shift);  in single_erase()
3489  * nand_erase - [MTD Interface] erase block(s)
3501  * nand_erase_nand - [INTERN] erase block(s)
3516 			__func__, (unsigned long long)instr->addr,  in nand_erase_nand()
3517 			(unsigned long long)instr->len);  in nand_erase_nand()
3519 	if (check_offs_len(mtd, instr->addr, instr->len))  in nand_erase_nand()
3520 		return -EINVAL;  in nand_erase_nand()
3526 	page = (int)(instr->addr >> chip->page_shift);  in nand_erase_nand()
3527 	chipnr = (int)(instr->addr >> chip->chip_shift);  in nand_erase_nand()
3530 	pages_per_block = 1 << (chip->phys_erase_shift - chip->page_shift);  in nand_erase_nand()
3533 	chip->select_chip(mtd, chipnr);  in nand_erase_nand()
3539 		instr->state = MTD_ERASE_FAILED;  in nand_erase_nand()
3544 	len = instr->len;  in nand_erase_nand()
3546 	instr->state = MTD_ERASING;  in nand_erase_nand()
3552 		if (!instr->scrub && nand_block_checkbad(mtd, ((loff_t) page) <<  in nand_erase_nand()
3553 					chip->page_shift, allowbbt)) {  in nand_erase_nand()
3556 			instr->state = MTD_ERASE_FAILED;  in nand_erase_nand()
3564 		if (page <= chip->pagebuf && chip->pagebuf <  in nand_erase_nand()
3566 			chip->pagebuf = -1;  in nand_erase_nand()
3568 		status = chip->erase(mtd, page & chip->pagemask);  in nand_erase_nand()
3574 			instr->state = MTD_ERASE_FAILED;  in nand_erase_nand()
3575 			instr->fail_addr =  in nand_erase_nand()
3576 				((loff_t)page << chip->page_shift);  in nand_erase_nand()
3581 		len -= (1ULL << chip->phys_erase_shift);  in nand_erase_nand()
3585 		if (len && !(page & chip->pagemask)) {  in nand_erase_nand()
3587 			chip->select_chip(mtd, -1);  in nand_erase_nand()
3588 			chip->select_chip(mtd, chipnr);  in nand_erase_nand()
3591 	instr->state = MTD_ERASE_DONE;  in nand_erase_nand()
3595 	ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;  in nand_erase_nand()
3598 	chip->select_chip(mtd, -1);  in nand_erase_nand()
3610  * nand_sync - [MTD Interface] sync
3621 	/* Release it and go back */  in nand_sync()
3626  * nand_block_isbad - [MTD Interface] Check if block at offset is bad
3633 	int chipnr = (int)(offs >> chip->chip_shift);  in nand_block_isbad()
3638 	chip->select_chip(mtd, chipnr);  in nand_block_isbad()
3642 	chip->select_chip(mtd, -1);  in nand_block_isbad()
3649  * nand_block_markbad - [MTD Interface] Mark block at the given offset as bad
3669  * nand_onfi_set_features- [REPLACEABLE] set features for ONFI nand
3679 	if (!chip->onfi_version ||  in nand_onfi_set_features()
3680 	    !(le16_to_cpu(chip->onfi_params.opt_cmd)  in nand_onfi_set_features()
3682 		return -ENOTSUPP;  in nand_onfi_set_features()
3689  * nand_onfi_get_features- [REPLACEABLE] get features for ONFI nand
3699 	if (!chip->onfi_version ||  in nand_onfi_get_features()
3700 	    !(le16_to_cpu(chip->onfi_params.opt_cmd)  in nand_onfi_get_features()
3702 		return -ENOTSUPP;  in nand_onfi_get_features()
3712 	if (!chip->chip_delay)  in nand_set_defaults()
3713 		chip->chip_delay = 20;  in nand_set_defaults()
3716 	if (chip->cmdfunc == NULL)  in nand_set_defaults()
3717 		chip->cmdfunc = nand_command;  in nand_set_defaults()
3720 	if (chip->waitfunc == NULL)  in nand_set_defaults()
3721 		chip->waitfunc = nand_wait;  in nand_set_defaults()
3723 	if (!chip->select_chip)  in nand_set_defaults()
3724 		chip->select_chip = nand_select_chip;  in nand_set_defaults()
3727 	if (!chip->onfi_set_features)  in nand_set_defaults()
3728 		chip->onfi_set_features = nand_onfi_set_features;  in nand_set_defaults()
3729 	if (!chip->onfi_get_features)  in nand_set_defaults()
3730 		chip->onfi_get_features = nand_onfi_get_features;  in nand_set_defaults()
3733 	if (!chip->read_byte || chip->read_byte == nand_read_byte)  in nand_set_defaults()
3734 		chip->read_byte = busw ? nand_read_byte16 : nand_read_byte;  in nand_set_defaults()
3735 	if (!chip->read_word)  in nand_set_defaults()
3736 		chip->read_word = nand_read_word;  in nand_set_defaults()
3737 	if (!chip->block_bad)  in nand_set_defaults()
3738 		chip->block_bad = nand_block_bad;  in nand_set_defaults()
3739 	if (!chip->block_markbad)  in nand_set_defaults()
3740 		chip->block_markbad = nand_default_block_markbad;  in nand_set_defaults()
3741 	if (!chip->write_buf || chip->write_buf == nand_write_buf)  in nand_set_defaults()
3742 		chip->write_buf = busw ? nand_write_buf16 : nand_write_buf;  in nand_set_defaults()
3743 	if (!chip->write_byte || chip->write_byte == nand_write_byte)  in nand_set_defaults()
3744 		chip->write_byte = busw ? nand_write_byte16 : nand_write_byte;  in nand_set_defaults()
3745 	if (!chip->read_buf || chip->read_buf == nand_read_buf)  in nand_set_defaults()
3746 		chip->read_buf = busw ? nand_read_buf16 : nand_read_buf;  in nand_set_defaults()
3747 	if (!chip->scan_bbt)  in nand_set_defaults()
3748 		chip->scan_bbt = nand_default_bbt;  in nand_set_defaults()
3750 	if (!chip->controller) {  in nand_set_defaults()
3751 		chip->controller = &chip->hwcontrol;  in nand_set_defaults()
3752 		spin_lock_init(&chip->controller->lock);  in nand_set_defaults()
3753 		init_waitqueue_head(&chip->controller->wq);  in nand_set_defaults()
3756 	if (!chip->buf_align)  in nand_set_defaults()
3757 		chip->buf_align = 1;  in nand_set_defaults()
3766 	s[len - 1] = 0;  in sanitize_string()
3769 	for (i = 0; i < len - 1; i++) {  in sanitize_string()
3781 	while (len--) {  in onfi_crc16()
3803 	len = le16_to_cpu(p->ext_param_page_length) * 16;  in nand_flash_detect_ext_param_page()
3806 		return -ENOMEM;  in nand_flash_detect_ext_param_page()
3815 					 sizeof(*p) * p->num_of_param_pages,  in nand_flash_detect_ext_param_page()
3820 	ret = -EINVAL;  in nand_flash_detect_ext_param_page()
3821 	if ((onfi_crc16(ONFI_CRC_BASE, ((uint8_t *)ep) + 2, len - 2)  in nand_flash_detect_ext_param_page()
3822 		!= le16_to_cpu(ep->crc))) {  in nand_flash_detect_ext_param_page()
3831 	if (strncmp((char *)ep->sig, "EPPS", 4)) {  in nand_flash_detect_ext_param_page()
3839 		s = ep->sections + i;  in nand_flash_detect_ext_param_page()
3840 		if (s->type == ONFI_SECTION_TYPE_2)  in nand_flash_detect_ext_param_page()
3842 		cursor += s->length * 16;  in nand_flash_detect_ext_param_page()
3852 	if (!ecc->codeword_size) {  in nand_flash_detect_ext_param_page()
3857 	chip->ecc_strength_ds = ecc->ecc_bits;  in nand_flash_detect_ext_param_page()
3858 	chip->ecc_step_ds = 1 << ecc->codeword_size;  in nand_flash_detect_ext_param_page()
3871 	return chip->onfi_set_features(mtd, chip, ONFI_FEATURE_ADDR_READ_RETRY,  in nand_setup_read_retry_micron()
3876  * Configure chip properties from Micron vendor-specific ONFI table
3881 	struct nand_onfi_vendor_micron *micron = (void *)p->vendor;  in nand_onfi_detect_micron()
3883 	if (le16_to_cpu(p->vendor_revision) < 1)  in nand_onfi_detect_micron()
3886 	chip->read_retries = micron->read_retry_options;  in nand_onfi_detect_micron()
3887 	chip->setup_read_retry = nand_setup_read_retry_micron;  in nand_onfi_detect_micron()
3896 	struct nand_onfi_params *p = &chip->onfi_params;  in nand_flash_detect_onfi()
3915 				le16_to_cpu(p->crc)) {  in nand_flash_detect_onfi()
3926 	val = le16_to_cpu(p->revision);  in nand_flash_detect_onfi()
3928 		chip->onfi_version = 23;  in nand_flash_detect_onfi()
3930 		chip->onfi_version = 22;  in nand_flash_detect_onfi()
3932 		chip->onfi_version = 21;  in nand_flash_detect_onfi()
3934 		chip->onfi_version = 20;  in nand_flash_detect_onfi()
3936 		chip->onfi_version = 10;  in nand_flash_detect_onfi()
3938 	if (!chip->onfi_version) {  in nand_flash_detect_onfi()
3943 	sanitize_string(p->manufacturer, sizeof(p->manufacturer));  in nand_flash_detect_onfi()
3944 	sanitize_string(p->model, sizeof(p->model));  in nand_flash_detect_onfi()
3945 	if (!mtd->name)  in nand_flash_detect_onfi()
3946 		mtd->name = p->model;  in nand_flash_detect_onfi()
3948 	mtd->writesize = le32_to_cpu(p->byte_per_page);  in nand_flash_detect_onfi()
3951 	 * pages_per_block and blocks_per_lun may not be a power-of-2 size  in nand_flash_detect_onfi()
3953 	 * dimensions will be power-of-2, so just truncate the remaining area.  in nand_flash_detect_onfi()
3955 	mtd->erasesize = 1 << (fls(le32_to_cpu(p->pages_per_block)) - 1);  in nand_flash_detect_onfi()
3956 	mtd->erasesize *= mtd->writesize;  in nand_flash_detect_onfi()
3958 	mtd->oobsize = le16_to_cpu(p->spare_bytes_per_page);  in nand_flash_detect_onfi()
3961 	chip->chipsize = 1 << (fls(le32_to_cpu(p->blocks_per_lun)) - 1);  in nand_flash_detect_onfi()
3962 	chip->chipsize *= (uint64_t)mtd->erasesize * p->lun_count;  in nand_flash_detect_onfi()
3963 	chip->bits_per_cell = p->bits_per_cell;  in nand_flash_detect_onfi()
3970 	if (p->ecc_bits != 0xff) {  in nand_flash_detect_onfi()
3971 		chip->ecc_strength_ds = p->ecc_bits;  in nand_flash_detect_onfi()
3972 		chip->ecc_step_ds = 512;  in nand_flash_detect_onfi()
3973 	} else if (chip->onfi_version >= 21 &&  in nand_flash_detect_onfi()
3979 		 * by the chip->cmdfunc. So try to update the chip->cmdfunc  in nand_flash_detect_onfi()
3982 		if (mtd->writesize > 512 && chip->cmdfunc == nand_command)  in nand_flash_detect_onfi()
3983 			chip->cmdfunc = nand_command_lp;  in nand_flash_detect_onfi()
3992 	if (p->jedec_id == NAND_MFR_MICRON)  in nand_flash_detect_onfi()
4011 	struct nand_jedec_params *p = &chip->jedec_params;  in nand_flash_detect_jedec()
4031 				le16_to_cpu(p->crc))  in nand_flash_detect_jedec()
4041 	val = le16_to_cpu(p->revision);  in nand_flash_detect_jedec()
4043 		chip->jedec_version = 10;  in nand_flash_detect_jedec()
4045 		chip->jedec_version = 1; /* vendor specific version */  in nand_flash_detect_jedec()
4047 	if (!chip->jedec_version) {  in nand_flash_detect_jedec()
4052 	sanitize_string(p->manufacturer, sizeof(p->manufacturer));  in nand_flash_detect_jedec()
4053 	sanitize_string(p->model, sizeof(p->model));  in nand_flash_detect_jedec()
4054 	if (!mtd->name)  in nand_flash_detect_jedec()
4055 		mtd->name = p->model;  in nand_flash_detect_jedec()
4057 	mtd->writesize = le32_to_cpu(p->byte_per_page);  in nand_flash_detect_jedec()
4060 	mtd->erasesize = 1 << (fls(le32_to_cpu(p->pages_per_block)) - 1);  in nand_flash_detect_jedec()
4061 	mtd->erasesize *= mtd->writesize;  in nand_flash_detect_jedec()
4063 	mtd->oobsize = le16_to_cpu(p->spare_bytes_per_page);  in nand_flash_detect_jedec()
4066 	chip->chipsize = 1 << (fls(le32_to_cpu(p->blocks_per_lun)) - 1);  in nand_flash_detect_jedec()
4067 	chip->chipsize *= (uint64_t)mtd->erasesize * p->lun_count;  in nand_flash_detect_jedec()
4068 	chip->bits_per_cell = p->bits_per_cell;  in nand_flash_detect_jedec()
4076 	ecc = &p->ecc_info[0];  in nand_flash_detect_jedec()
4078 	if (ecc->codeword_size >= 9) {  in nand_flash_detect_jedec()
4079 		chip->ecc_strength_ds = ecc->ecc_bits;  in nand_flash_detect_jedec()
4080 		chip->ecc_step_ds = 1 << ecc->codeword_size;  in nand_flash_detect_jedec()
4089  * nand_id_has_period - Check if an ID string has a given wraparound period
4096  * period of 3). This is a helper function for nand_id_len(). Returns non-zero
4110  * nand_id_len - Get the length of an ID string returned by CMD_READID
4121 	/* Find last non-zero byte */  in nand_id_len()
4122 	for (last_nonzero = arrlen - 1; last_nonzero >= 0; last_nonzero--)  in nand_id_len()
4140 	if (last_nonzero < arrlen - 1)  in nand_id_len()
4160  * manufacturer-specific "extended ID" decoding patterns.
4167 	chip->bits_per_cell = nand_get_bits_per_cell(id_data[2]);  in nand_decode_ext_id()
4179 	 * Check for ID length, non-zero 6th byte, cell type, and Hynix/Samsung  in nand_decode_ext_id()
4185 		mtd->writesize = 2048 << (extid & 0x03);  in nand_decode_ext_id()
4190 			mtd->oobsize = 128;  in nand_decode_ext_id()
4193 			mtd->oobsize = 218;  in nand_decode_ext_id()
4196 			mtd->oobsize = 400;  in nand_decode_ext_id()
4199 			mtd->oobsize = 436;  in nand_decode_ext_id()
4202 			mtd->oobsize = 512;  in nand_decode_ext_id()
4205 			mtd->oobsize = 640;  in nand_decode_ext_id()
4209 			mtd->oobsize = 1024;  in nand_decode_ext_id()
4214 		mtd->erasesize = (128 * 1024) <<  in nand_decode_ext_id()
4222 		mtd->writesize = 2048 << (extid & 0x03);  in nand_decode_ext_id()
4227 			mtd->oobsize = 128;  in nand_decode_ext_id()
4230 			mtd->oobsize = 224;  in nand_decode_ext_id()
4233 			mtd->oobsize = 448;  in nand_decode_ext_id()
4236 			mtd->oobsize = 64;  in nand_decode_ext_id()
4239 			mtd->oobsize = 32;  in nand_decode_ext_id()
4242 			mtd->oobsize = 16;  in nand_decode_ext_id()
4245 			mtd->oobsize = 640;  in nand_decode_ext_id()
4252 			mtd->erasesize = (128 * 1024) << tmp;  in nand_decode_ext_id()
4254 			mtd->erasesize = 768 * 1024;  in nand_decode_ext_id()
4256 			mtd->erasesize = (64 * 1024) << tmp;  in nand_decode_ext_id()
4260 		mtd->writesize = 1024 << (extid & 0x03);  in nand_decode_ext_id()
4263 		mtd->oobsize = (8 << (extid & 0x01)) *  in nand_decode_ext_id()
4264 			(mtd->writesize >> 9);  in nand_decode_ext_id()
4267 		mtd->erasesize = (64 * 1024) << (extid & 0x03);  in nand_decode_ext_id()
4276 		 * - ID byte 6, bits[2:0]: 100b -> 43nm, 101b -> 32nm,  in nand_decode_ext_id()
4277 		 *                         110b -> 24nm  in nand_decode_ext_id()
4278 		 * - ID byte 5, bit[7]:    1 -> BENAND, 0 -> raw SLC  in nand_decode_ext_id()
4284 			mtd->oobsize = 32 * mtd->writesize >> 9;  in nand_decode_ext_id()
4301 	mtd->erasesize = type->erasesize;  in nand_decode_id()
4302 	mtd->writesize = type->pagesize;  in nand_decode_id()
4303 	mtd->oobsize = mtd->writesize / 32;  in nand_decode_id()
4304 	*busw = type->options & NAND_BUSWIDTH_16;  in nand_decode_id()
4306 	/* All legacy ID NAND are small-page, SLC */  in nand_decode_id()
4307 	chip->bits_per_cell = 1;  in nand_decode_id()
4313 	 * Data sheet (5 byte ID): Spansion S30ML-P ORNAND (p.39)  in nand_decode_id()
4317 			&& mtd->writesize == 512) {  in nand_decode_id()
4318 		mtd->erasesize = 128 * 1024;  in nand_decode_id()
4319 		mtd->erasesize <<= ((id_data[3] & 0x03) << 1);  in nand_decode_id()
4326  * page size, cell-type information).
4334 	if (mtd->writesize > 512 || (chip->options & NAND_BUSWIDTH_16))  in nand_decode_bbm_options()
4335 		chip->badblockpos = NAND_LARGE_BADBLOCK_POS;  in nand_decode_bbm_options()
4337 		chip->badblockpos = NAND_SMALL_BADBLOCK_POS;  in nand_decode_bbm_options()
4348 		chip->bbt_options |= NAND_BBT_SCANLASTPAGE;  in nand_decode_bbm_options()
4355 			(mtd->writesize == 2048 &&  in nand_decode_bbm_options()
4357 		chip->bbt_options |= NAND_BBT_SCAN2NDPAGE;  in nand_decode_bbm_options()
4362 	return type->id_len;  in is_full_id_nand()
4368 	if (!strncmp((char *)type->id, (char *)id_data, type->id_len)) {  in find_full_id_nand()
4369 		mtd->writesize = type->pagesize;  in find_full_id_nand()
4370 		mtd->erasesize = type->erasesize;  in find_full_id_nand()
4371 		mtd->oobsize = type->oobsize;  in find_full_id_nand()
4373 		chip->bits_per_cell = nand_get_bits_per_cell(id_data[2]);  in find_full_id_nand()
4374 		chip->chipsize = (uint64_t)type->chipsize << 20;  in find_full_id_nand()
4375 		chip->options |= type->options;  in find_full_id_nand()
4376 		chip->ecc_strength_ds = NAND_ECC_STRENGTH(type);  in find_full_id_nand()
4377 		chip->ecc_step_ds = NAND_ECC_STEP(type);  in find_full_id_nand()
4378 		chip->onfi_timing_mode_default =  in find_full_id_nand()
4379 					type->onfi_timing_mode_default;  in find_full_id_nand()
4381 		*busw = type->options & NAND_BUSWIDTH_16;  in find_full_id_nand()
4383 		if (!mtd->name)  in find_full_id_nand()
4384 			mtd->name = type->name;  in find_full_id_nand()
4405 	 * after power-up.  in nand_get_flash_type()
4412 	chip->select_chip(mtd, 0);  in nand_get_flash_type()
4424 	 * Try again to make sure, as some systems the bus-hold or other  in nand_get_flash_type()
4438 		return ERR_PTR(-ENODEV);  in nand_get_flash_type()
4444 	for (; type->name != NULL; type++) {  in nand_get_flash_type()
4448 		} else if (*dev_id == type->dev_id) {  in nand_get_flash_type()
4453 	chip->onfi_version = 0;  in nand_get_flash_type()
4454 	if (!type->name || !type->pagesize) {  in nand_get_flash_type()
4464 	if (!type->name)  in nand_get_flash_type()
4465 		return ERR_PTR(-ENODEV);  in nand_get_flash_type()
4467 	if (!mtd->name)  in nand_get_flash_type()
4468 		mtd->name = type->name;  in nand_get_flash_type()
4470 	chip->chipsize = (uint64_t)type->chipsize << 20;  in nand_get_flash_type()
4472 	if (!type->pagesize) {  in nand_get_flash_type()
4479 	chip->options |= type->options;  in nand_get_flash_type()
4485 	if (*maf_id != NAND_MFR_SAMSUNG && !type->pagesize)  in nand_get_flash_type()
4486 		chip->options &= ~NAND_SAMSUNG_LP_OPTIONS;  in nand_get_flash_type()
4495 	if (chip->options & NAND_BUSWIDTH_AUTO) {  in nand_get_flash_type()
4496 		WARN_ON(chip->options & NAND_BUSWIDTH_16);  in nand_get_flash_type()
4497 		chip->options |= busw;  in nand_get_flash_type()
4499 	} else if (busw != (chip->options & NAND_BUSWIDTH_16)) {  in nand_get_flash_type()
4506 		pr_info("%s %s\n", nand_manuf_ids[maf_idx].name, mtd->name);  in nand_get_flash_type()
4508 			   (chip->options & NAND_BUSWIDTH_16) ? 16 : 8,  in nand_get_flash_type()
4510 		return ERR_PTR(-EINVAL);  in nand_get_flash_type()
4516 	chip->page_shift = ffs(mtd->writesize) - 1;  in nand_get_flash_type()
4517 	/* Convert chipsize to number of pages per chip -1 */  in nand_get_flash_type()
4518 	chip->pagemask = (chip->chipsize >> chip->page_shift) - 1;  in nand_get_flash_type()
4520 	chip->bbt_erase_shift = chip->phys_erase_shift =  in nand_get_flash_type()
4521 		ffs(mtd->erasesize) - 1;  in nand_get_flash_type()
4522 	if (chip->chipsize & 0xffffffff)  in nand_get_flash_type()
4523 		chip->chip_shift = ffs((unsigned)chip->chipsize) - 1;  in nand_get_flash_type()
4525 		chip->chip_shift = ffs((unsigned)(chip->chipsize >> 32));  in nand_get_flash_type()
4526 		chip->chip_shift += 32 - 1;  in nand_get_flash_type()
4529 	if (chip->chip_shift - chip->page_shift > 16)  in nand_get_flash_type()
4530 		chip->options |= NAND_ROW_ADDR_3;  in nand_get_flash_type()
4532 	chip->badblockbits = 8;  in nand_get_flash_type()
4533 	chip->erase = single_erase;  in nand_get_flash_type()
4536 	if (mtd->writesize > 512 && chip->cmdfunc == nand_command)  in nand_get_flash_type()
4537 		chip->cmdfunc = nand_command_lp;  in nand_get_flash_type()
4543 	if (chip->onfi_version)  in nand_get_flash_type()
4545 				chip->onfi_params.model);  in nand_get_flash_type()
4546 	else if (chip->jedec_version)  in nand_get_flash_type()
4548 				chip->jedec_params.model);  in nand_get_flash_type()
4551 				type->name);  in nand_get_flash_type()
4553 	if (chip->jedec_version)  in nand_get_flash_type()
4555 				chip->jedec_params.model);  in nand_get_flash_type()
4558 				type->name);  in nand_get_flash_type()
4561 		type->name);  in nand_get_flash_type()
4565 		(int)(chip->chipsize >> 20), nand_is_slc(chip) ? "SLC" : "MLC",  in nand_get_flash_type()
4566 		mtd->erasesize >> 10, mtd->writesize, mtd->oobsize);  in nand_get_flash_type()
4576 	int ret, ecc_mode = -1, ecc_strength, ecc_step;  in nand_dt_init()
4577 	const void *blob = gd->fdt_blob;  in nand_dt_init()
4580 	ret = fdtdec_get_int(blob, node, "nand-bus-width", -1);  in nand_dt_init()
4582 		chip->options |= NAND_BUSWIDTH_16;  in nand_dt_init()
4584 	if (fdtdec_get_bool(blob, node, "nand-on-flash-bbt"))  in nand_dt_init()
4585 		chip->bbt_options |= NAND_BBT_USE_FLASH;  in nand_dt_init()
4587 	str = fdt_getprop(blob, node, "nand-ecc-mode", NULL);  in nand_dt_init()
4604 	ecc_strength = fdtdec_get_int(blob, node, "nand-ecc-strength", -1);  in nand_dt_init()
4605 	ecc_step = fdtdec_get_int(blob, node, "nand-ecc-step-size", -1);  in nand_dt_init()
4610 		return -EINVAL;  in nand_dt_init()
4614 		chip->ecc.mode = ecc_mode;  in nand_dt_init()
4617 		chip->ecc.strength = ecc_strength;  in nand_dt_init()
4620 		chip->ecc.size = ecc_step;  in nand_dt_init()
4622 	if (fdt_getprop(blob, node, "nand-ecc-maximize", NULL))  in nand_dt_init()
4623 		chip->ecc.options |= NAND_ECC_MAXIMIZE;  in nand_dt_init()
4635  * nand_scan_ident - [NAND Interface] Scan for the NAND device
4652 	if (chip->flash_node) {  in nand_scan_ident()
4653 		ret = nand_dt_init(mtd, chip, chip->flash_node);  in nand_scan_ident()
4659 	nand_set_defaults(chip, chip->options & NAND_BUSWIDTH_16);  in nand_scan_ident()
4666 		if (!(chip->options & NAND_SCAN_SILENT_NODEV))  in nand_scan_ident()
4668 		chip->select_chip(mtd, -1);  in nand_scan_ident()
4672 	/* Initialize the ->data_interface field. */  in nand_scan_ident()
4681 	 * ->data_interface and ->default_onfi_timing_mode were set.  in nand_scan_ident()
4689 	chip->select_chip(mtd, -1);  in nand_scan_ident()
4698 		chip->select_chip(mtd, i);  in nand_scan_ident()
4704 			chip->select_chip(mtd, -1);  in nand_scan_ident()
4707 		chip->select_chip(mtd, -1);  in nand_scan_ident()
4716 	chip->numchips = i;  in nand_scan_ident()
4717 	mtd->size = i * chip->chipsize;  in nand_scan_ident()
4724  * nand_check_ecc_caps - check the sanity of preset ECC settings
4738 	int preset_step = chip->ecc.size;  in nand_check_ecc_caps()
4739 	int preset_strength = chip->ecc.strength;  in nand_check_ecc_caps()
4744 		return -EINVAL;  in nand_check_ecc_caps()
4747 		return -ENODATA;  in nand_check_ecc_caps()
4749 	nsteps = mtd->writesize / preset_step;  in nand_check_ecc_caps()
4751 	for (i = 0; i < caps->nstepinfos; i++) {  in nand_check_ecc_caps()
4752 		stepinfo = &caps->stepinfos[i];  in nand_check_ecc_caps()
4754 		if (stepinfo->stepsize != preset_step)  in nand_check_ecc_caps()
4757 		for (j = 0; j < stepinfo->nstrengths; j++) {  in nand_check_ecc_caps()
4758 			if (stepinfo->strengths[j] != preset_strength)  in nand_check_ecc_caps()
4761 			ecc_bytes = caps->calc_ecc_bytes(preset_step,  in nand_check_ecc_caps()
4769 				return -ENOSPC;  in nand_check_ecc_caps()
4772 			chip->ecc.bytes = ecc_bytes;  in nand_check_ecc_caps()
4781 	return -ENOTSUPP;  in nand_check_ecc_caps()
4786  * nand_match_ecc_req - meet the chip's requirement with least ECC bytes
4792  * number of ECC bytes (i.e. with the largest number of OOB-free bytes).
4800 	int req_step = chip->ecc_step_ds;  in nand_match_ecc_req()
4801 	int req_strength = chip->ecc_strength_ds;  in nand_match_ecc_req()
4808 		return -EINVAL;  in nand_match_ecc_req()
4812 		return -ENOTSUPP;  in nand_match_ecc_req()
4815 	req_corr = mtd->writesize / req_step * req_strength;  in nand_match_ecc_req()
4817 	for (i = 0; i < caps->nstepinfos; i++) {  in nand_match_ecc_req()
4818 		stepinfo = &caps->stepinfos[i];  in nand_match_ecc_req()
4819 		step_size = stepinfo->stepsize;  in nand_match_ecc_req()
4821 		for (j = 0; j < stepinfo->nstrengths; j++) {  in nand_match_ecc_req()
4822 			strength = stepinfo->strengths[j];  in nand_match_ecc_req()
4832 			if (mtd->writesize % step_size)  in nand_match_ecc_req()
4835 			nsteps = mtd->writesize / step_size;  in nand_match_ecc_req()
4837 			ecc_bytes = caps->calc_ecc_bytes(step_size, strength);  in nand_match_ecc_req()
4860 		return -ENOTSUPP;  in nand_match_ecc_req()
4862 	chip->ecc.size = best_step;  in nand_match_ecc_req()
4863 	chip->ecc.strength = best_strength;  in nand_match_ecc_req()
4864 	chip->ecc.bytes = best_ecc_bytes;  in nand_match_ecc_req()
4871  * nand_maximize_ecc - choose the max ECC strength available
4891 		return -EINVAL;  in nand_maximize_ecc()
4893 	for (i = 0; i < caps->nstepinfos; i++) {  in nand_maximize_ecc()
4894 		stepinfo = &caps->stepinfos[i];  in nand_maximize_ecc()
4895 		step_size = stepinfo->stepsize;  in nand_maximize_ecc()
4897 		/* If chip->ecc.size is already set, respect it */  in nand_maximize_ecc()
4898 		if (chip->ecc.size && step_size != chip->ecc.size)  in nand_maximize_ecc()
4901 		for (j = 0; j < stepinfo->nstrengths; j++) {  in nand_maximize_ecc()
4902 			strength = stepinfo->strengths[j];  in nand_maximize_ecc()
4904 			if (mtd->writesize % step_size)  in nand_maximize_ecc()
4907 			nsteps = mtd->writesize / step_size;  in nand_maximize_ecc()
4909 			ecc_bytes = caps->calc_ecc_bytes(step_size, strength);  in nand_maximize_ecc()
4933 		return -ENOTSUPP;  in nand_maximize_ecc()
4935 	chip->ecc.size = best_step;  in nand_maximize_ecc()
4936 	chip->ecc.strength = best_strength;  in nand_maximize_ecc()
4937 	chip->ecc.bytes = best_ecc_bytes;  in nand_maximize_ecc()
4960 	struct nand_ecc_ctrl *ecc = &chip->ecc;  in nand_ecc_strength_good()
4963 	if (ecc->size == 0 || chip->ecc_step_ds == 0)  in nand_ecc_strength_good()
4971 	corr = (mtd->writesize * ecc->strength) / ecc->size;  in nand_ecc_strength_good()
4972 	ds_corr = (mtd->writesize * chip->ecc_strength_ds) / chip->ecc_step_ds;  in nand_ecc_strength_good()
4974 	return corr >= ds_corr && ecc->strength >= chip->ecc_strength_ds;  in nand_ecc_strength_good()
4979 	struct nand_ecc_ctrl *ecc = &chip->ecc;  in invalid_ecc_page_accessors()
4990 	return (!ecc->read_page || !ecc->write_page ||  in invalid_ecc_page_accessors()
4991 		!ecc->read_page_raw || !ecc->write_page_raw ||  in invalid_ecc_page_accessors()
4992 		(NAND_HAS_SUBPAGE_READ(chip) && !ecc->read_subpage) ||  in invalid_ecc_page_accessors()
4993 		(NAND_HAS_SUBPAGE_WRITE(chip) && !ecc->write_subpage &&  in invalid_ecc_page_accessors()
4994 		 ecc->hwctl && ecc->calculate));  in invalid_ecc_page_accessors()
4998  * nand_scan_tail - [NAND Interface] Scan for the NAND device
5009 	struct nand_ecc_ctrl *ecc = &chip->ecc;  in nand_scan_tail()
5012 	/* New bad blocks should be marked in OOB, flash-based BBT, or both */  in nand_scan_tail()
5013 	BUG_ON((chip->bbt_options & NAND_BBT_NO_OOB_BBM) &&  in nand_scan_tail()
5014 			!(chip->bbt_options & NAND_BBT_USE_FLASH));  in nand_scan_tail()
5018 		return -EINVAL;  in nand_scan_tail()
5021 	if (!(chip->options & NAND_OWN_BUFFERS)) {  in nand_scan_tail()
5023 		chip->buffers = nbuf;  in nand_scan_tail()
5025 		if (!chip->buffers)  in nand_scan_tail()
5026 			return -ENOMEM;  in nand_scan_tail()
5030 	chip->oob_poi = chip->buffers->databuf + mtd->writesize;  in nand_scan_tail()
5035 	if (!ecc->layout && (ecc->mode != NAND_ECC_SOFT_BCH)) {  in nand_scan_tail()
5036 		switch (mtd->oobsize) {  in nand_scan_tail()
5039 			ecc->layout = &nand_oob_8;  in nand_scan_tail()
5042 			ecc->layout = &nand_oob_16;  in nand_scan_tail()
5045 			ecc->layout = &nand_oob_64;  in nand_scan_tail()
5048 			ecc->layout = &nand_oob_128;  in nand_scan_tail()
5053 				   mtd->oobsize);  in nand_scan_tail()
5058 	if (!chip->write_page)  in nand_scan_tail()
5059 		chip->write_page = nand_write_page;  in nand_scan_tail()
5066 	switch (ecc->mode) {  in nand_scan_tail()
5069 		if (!ecc->calculate || !ecc->correct || !ecc->hwctl) {  in nand_scan_tail()
5073 		if (!ecc->read_page)  in nand_scan_tail()
5074 			ecc->read_page = nand_read_page_hwecc_oob_first;  in nand_scan_tail()
5078 		if (!ecc->read_page)  in nand_scan_tail()
5079 			ecc->read_page = nand_read_page_hwecc;  in nand_scan_tail()
5080 		if (!ecc->write_page)  in nand_scan_tail()
5081 			ecc->write_page = nand_write_page_hwecc;  in nand_scan_tail()
5082 		if (!ecc->read_page_raw)  in nand_scan_tail()
5083 			ecc->read_page_raw = nand_read_page_raw;  in nand_scan_tail()
5084 		if (!ecc->write_page_raw)  in nand_scan_tail()
5085 			ecc->write_page_raw = nand_write_page_raw;  in nand_scan_tail()
5086 		if (!ecc->read_oob)  in nand_scan_tail()
5087 			ecc->read_oob = nand_read_oob_std;  in nand_scan_tail()
5088 		if (!ecc->write_oob)  in nand_scan_tail()
5089 			ecc->write_oob = nand_write_oob_std;  in nand_scan_tail()
5090 		if (!ecc->read_subpage)  in nand_scan_tail()
5091 			ecc->read_subpage = nand_read_subpage;  in nand_scan_tail()
5092 		if (!ecc->write_subpage && ecc->hwctl && ecc->calculate)  in nand_scan_tail()
5093 			ecc->write_subpage = nand_write_subpage_hwecc;  in nand_scan_tail()
5096 		if ((!ecc->calculate || !ecc->correct || !ecc->hwctl) &&  in nand_scan_tail()
5097 		    (!ecc->read_page ||  in nand_scan_tail()
5098 		     ecc->read_page == nand_read_page_hwecc ||  in nand_scan_tail()
5099 		     !ecc->write_page ||  in nand_scan_tail()
5100 		     ecc->write_page == nand_write_page_hwecc)) {  in nand_scan_tail()
5105 		if (!ecc->read_page)  in nand_scan_tail()
5106 			ecc->read_page = nand_read_page_syndrome;  in nand_scan_tail()
5107 		if (!ecc->write_page)  in nand_scan_tail()
5108 			ecc->write_page = nand_write_page_syndrome;  in nand_scan_tail()
5109 		if (!ecc->read_page_raw)  in nand_scan_tail()
5110 			ecc->read_page_raw = nand_read_page_raw_syndrome;  in nand_scan_tail()
5111 		if (!ecc->write_page_raw)  in nand_scan_tail()
5112 			ecc->write_page_raw = nand_write_page_raw_syndrome;  in nand_scan_tail()
5113 		if (!ecc->read_oob)  in nand_scan_tail()
5114 			ecc->read_oob = nand_read_oob_syndrome;  in nand_scan_tail()
5115 		if (!ecc->write_oob)  in nand_scan_tail()
5116 			ecc->write_oob = nand_write_oob_syndrome;  in nand_scan_tail()
5118 		if (mtd->writesize >= ecc->size) {  in nand_scan_tail()
5119 			if (!ecc->strength) {  in nand_scan_tail()
5126 			ecc->size, mtd->writesize);  in nand_scan_tail()
5127 		ecc->mode = NAND_ECC_SOFT;  in nand_scan_tail()
5130 		ecc->calculate = nand_calculate_ecc;  in nand_scan_tail()
5131 		ecc->correct = nand_correct_data;  in nand_scan_tail()
5132 		ecc->read_page = nand_read_page_swecc;  in nand_scan_tail()
5133 		ecc->read_subpage = nand_read_subpage;  in nand_scan_tail()
5134 		ecc->write_page = nand_write_page_swecc;  in nand_scan_tail()
5135 		ecc->read_page_raw = nand_read_page_raw;  in nand_scan_tail()
5136 		ecc->write_page_raw = nand_write_page_raw;  in nand_scan_tail()
5137 		ecc->read_oob = nand_read_oob_std;  in nand_scan_tail()
5138 		ecc->write_oob = nand_write_oob_std;  in nand_scan_tail()
5139 		if (!ecc->size)  in nand_scan_tail()
5140 			ecc->size = 256;  in nand_scan_tail()
5141 		ecc->bytes = 3;  in nand_scan_tail()
5142 		ecc->strength = 1;  in nand_scan_tail()
5150 		ecc->calculate = nand_bch_calculate_ecc;  in nand_scan_tail()
5151 		ecc->correct = nand_bch_correct_data;  in nand_scan_tail()
5152 		ecc->read_page = nand_read_page_swecc;  in nand_scan_tail()
5153 		ecc->read_subpage = nand_read_subpage;  in nand_scan_tail()
5154 		ecc->write_page = nand_write_page_swecc;  in nand_scan_tail()
5155 		ecc->read_page_raw = nand_read_page_raw;  in nand_scan_tail()
5156 		ecc->write_page_raw = nand_write_page_raw;  in nand_scan_tail()
5157 		ecc->read_oob = nand_read_oob_std;  in nand_scan_tail()
5158 		ecc->write_oob = nand_write_oob_std;  in nand_scan_tail()
5164 		if (!ecc->size && (mtd->oobsize >= 64)) {  in nand_scan_tail()
5165 			ecc->size = 512;  in nand_scan_tail()
5166 			ecc->strength = 4;  in nand_scan_tail()
5170 		ecc->bytes = 0;  in nand_scan_tail()
5171 		ecc->priv = nand_bch_init(mtd);  in nand_scan_tail()
5172 		if (!ecc->priv) {  in nand_scan_tail()
5180 		ecc->read_page = nand_read_page_raw;  in nand_scan_tail()
5181 		ecc->write_page = nand_write_page_raw;  in nand_scan_tail()
5182 		ecc->read_oob = nand_read_oob_std;  in nand_scan_tail()
5183 		ecc->read_page_raw = nand_read_page_raw;  in nand_scan_tail()
5184 		ecc->write_page_raw = nand_write_page_raw;  in nand_scan_tail()
5185 		ecc->write_oob = nand_write_oob_std;  in nand_scan_tail()
5186 		ecc->size = mtd->writesize;  in nand_scan_tail()
5187 		ecc->bytes = 0;  in nand_scan_tail()
5188 		ecc->strength = 0;  in nand_scan_tail()
5192 		pr_warn("Invalid NAND_ECC_MODE %d\n", ecc->mode);  in nand_scan_tail()
5197 	if (!ecc->read_oob_raw)  in nand_scan_tail()
5198 		ecc->read_oob_raw = ecc->read_oob;  in nand_scan_tail()
5199 	if (!ecc->write_oob_raw)  in nand_scan_tail()
5200 		ecc->write_oob_raw = ecc->write_oob;  in nand_scan_tail()
5206 	mtd->oobavail = 0;  in nand_scan_tail()
5207 	if (ecc->layout) {  in nand_scan_tail()
5208 		for (i = 0; ecc->layout->oobfree[i].length; i++)  in nand_scan_tail()
5209 			mtd->oobavail += ecc->layout->oobfree[i].length;  in nand_scan_tail()
5215 			mtd->name);  in nand_scan_tail()
5221 	ecc->steps = mtd->writesize / ecc->size;  in nand_scan_tail()
5222 	if (ecc->steps * ecc->size != mtd->writesize) {  in nand_scan_tail()
5226 	ecc->total = ecc->steps * ecc->bytes;  in nand_scan_tail()
5229 	if (!(chip->options & NAND_NO_SUBPAGE_WRITE) && nand_is_slc(chip)) {  in nand_scan_tail()
5230 		switch (ecc->steps) {  in nand_scan_tail()
5232 			mtd->subpage_sft = 1;  in nand_scan_tail()
5237 			mtd->subpage_sft = 2;  in nand_scan_tail()
5241 	chip->subpagesize = mtd->writesize >> mtd->subpage_sft;  in nand_scan_tail()
5244 	chip->state = FL_READY;  in nand_scan_tail()
5247 	chip->pagebuf = -1;  in nand_scan_tail()
5250 	switch (ecc->mode) {  in nand_scan_tail()
5253 		if (chip->page_shift > 9)  in nand_scan_tail()
5254 			chip->options |= NAND_SUBPAGE_READ;  in nand_scan_tail()
5262 	mtd->type = nand_is_slc(chip) ? MTD_NANDFLASH : MTD_MLCNANDFLASH;  in nand_scan_tail()
5263 	mtd->flags = (chip->options & NAND_ROM) ? MTD_CAP_ROM :  in nand_scan_tail()
5265 	mtd->_erase = nand_erase;  in nand_scan_tail()
5266 	mtd->_panic_write = panic_nand_write;  in nand_scan_tail()
5267 	mtd->_read_oob = nand_read_oob;  in nand_scan_tail()
5268 	mtd->_write_oob = nand_write_oob;  in nand_scan_tail()
5269 	mtd->_sync = nand_sync;  in nand_scan_tail()
5270 	mtd->_lock = NULL;  in nand_scan_tail()
5271 	mtd->_unlock = NULL;  in nand_scan_tail()
5272 	mtd->_block_isreserved = nand_block_isreserved;  in nand_scan_tail()
5273 	mtd->_block_isbad = nand_block_isbad;  in nand_scan_tail()
5274 	mtd->_block_markbad = nand_block_markbad;  in nand_scan_tail()
5275 	mtd->writebufsize = mtd->writesize;  in nand_scan_tail()
5278 	mtd->ecclayout = ecc->layout;  in nand_scan_tail()
5279 	mtd->ecc_strength = ecc->strength;  in nand_scan_tail()
5280 	mtd->ecc_step_size = ecc->size;  in nand_scan_tail()
5286 	if (!mtd->bitflip_threshold)  in nand_scan_tail()
5287 		mtd->bitflip_threshold = DIV_ROUND_UP(mtd->ecc_strength * 3, 4);  in nand_scan_tail()
5294  * nand_scan - [NAND Interface] Scan for the NAND device