/* Loop until all data is written */	while (*retlen < len) {		/* Write data into buffer */		if ((col + len) >= mtd->oobblock)			for (i = col, cnt = 0; i < mtd->oobblock; i++, cnt++)				this->data_buf[i] = buf[(*retlen + cnt)];		else			for (i = col, cnt = 0; cnt < (len - *retlen); i++, cnt++)				this->data_buf[i] = buf[(*retlen + cnt)];		/* Write ones for partial page programming */		for (i = mtd->oobblock; i < (mtd->oobblock + mtd->oobsize); i++)			this->data_buf[i] = 0xff;				/* Write pre-padding bytes into buffer */		for (i = 0; i < col; i++)			this->data_buf[i] = 0xff;		/* Write post-padding bytes into buffer */		if ((col + (len - *retlen)) < mtd->oobblock) {			for (i = (col + cnt); i < mtd->oobblock; i++)				this->data_buf[i] = 0xff;		}        /* mike.arm9 for cal ECC */        s3c2440nand->NFCONT |= (1<<4);   // Reset ECC        s3c2440nand->NFCONT &= ~(1<<5);  // UnLock MECC		/* Send command to begin auto page programming */		this->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);		/* Write out complete page of data */		this->write_buf(mtd, this->data_buf, mtd->oobblock);        s3c2440nand->NFCONT |= (1<<5);   // Lock MECC        *pdwECCVal = s3c2440nand->NFMECC0; // Read MECC		this->write_buf(mtd, &this->data_buf[mtd->oobblock], mtd->oobsize);            	/* Send command to actually program the data */    	this->cmdfunc (mtd, NAND_CMD_PAGEPROG, -1, -1);    	/* call wait ready function */    	status = this->waitfunc (mtd, this, FL_WRITING);    	/* See if device thinks it succeeded */    	if (status & 0x01) {    		DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write, page 0x%08x, ", __FUNCTION__, page);    		return -EIO;    	}		/* 		 * If we are writing a large amount of data and/or it		 * crosses page or half-page boundaries, we set the		 * the column to zero. It simplifies the program logic.		 */		if (col)			col = 0x00;		/* Update written bytes count */		*retlen += cnt;		/* Increment page address */		page++;			}	/* Return happy */	*retlen = len;	i = 0;nand_write_exit:	/* Deselect and wake up anyone waiting on the device */	nand_release_device(mtd);	return i;}/** * nand_write_oob - [MTD Interface] NAND write out-of-band * @mtd:	MTD device structure * @to:		offset to write to * @len:	number of bytes to write * @retlen:	pointer to variable to store the number of written bytes * @buf:	the data to write * * NAND write out-of-band */static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf){	int column, page, status, ret = -EIO, chipnr;	struct nand_chip *this = mtd->priv;	DEBUG (MTD_DEBUG_LEVEL3, "nand_write_oob: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);	/* Shift to get page */	page = (int) (to >> this->page_shift);	chipnr = (int) (to >> this->chip_shift);	/* Mask to get column */	column = to & (mtd->oobsize - 1);	/* Initialize return length value */	*retlen = 0;	/* Do not allow write past end of page */	if ((column + len) > mtd->oobsize) {		DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: Attempt to write past end of page\n");		return -EINVAL;	}	/* Grab the lock and see if the device is available */	nand_get_device (this, mtd, FL_WRITING);	/* Select the NAND device */	this->select_chip(mtd, chipnr);	/* Reset the chip. Some chips (like the Toshiba TC5832DC found	   in one of my DiskOnChip 2000 test units) will clear the whole	   data page too if we don't do this. I have no clue why, but	   I seem to have 'fixed' it in the doc2000 driver in	   August 1999.  dwmw2. */	this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);	/* Check, if it is write protected */	if (nand_check_wp(mtd))		goto out;	/* Invalidate the page cache, if we write to the cached page */	if (page == this->pagebuf)		this->pagebuf = -1;	if (NAND_MUST_PAD(this)) {		/* Write out desired data */		this->cmdfunc (mtd, NAND_CMD_SEQIN, mtd->oobblock, page & this->pagemask);		/* prepad 0xff for partial programming */		this->write_buf(mtd, ffchars, column);		/* write data */		this->write_buf(mtd, buf, len);		/* postpad 0xff for partial programming */		this->write_buf(mtd, ffchars, mtd->oobsize - (len+column));	} else {		/* Write out desired data */		this->cmdfunc (mtd, NAND_CMD_SEQIN, mtd->oobblock + column, page & this->pagemask);		/* write data */		this->write_buf(mtd, buf, len);	}	/* Send command to program the OOB data */	this->cmdfunc (mtd, NAND_CMD_PAGEPROG, -1, -1);	status = this->waitfunc (mtd, this, FL_WRITING);	/* See if device thinks it succeeded */	if (status & 0x01) {		DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write, page 0x%08x\n", page);		ret = -EIO;		goto out;	}	/* Return happy */	*retlen = len;#ifdef CONFIG_MTD_NAND_VERIFY_WRITE	/* Send command to read back the data */	this->cmdfunc (mtd, NAND_CMD_READOOB, column, page & this->pagemask);	if (this->verify_buf(mtd, buf, len)) {		DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write verify, page 0x%08x\n", page);		ret = -EIO;		goto out;	}#endif	ret = 0;out:	/* Deselect and wake up anyone waiting on the device */	nand_release_device(mtd);	return ret;}/* XXX U-BOOT XXX */#if 0/** * nand_writev - [MTD Interface] compabilty function for nand_writev_ecc * @mtd:	MTD device structure * @vecs:	the iovectors to write * @count:	number of vectors * @to:		offset to write to * @retlen:	pointer to variable to store the number of written bytes * * NAND write with kvec. This just calls the ecc function */static int nand_writev (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count,		loff_t to, size_t * retlen){	return (nand_writev_ecc (mtd, vecs, count, to, retlen, NULL, NULL));}/** * nand_writev_ecc - [MTD Interface] write with iovec with ecc * @mtd:	MTD device structure * @vecs:	the iovectors to write * @count:	number of vectors * @to:		offset to write to * @retlen:	pointer to variable to store the number of written bytes * @eccbuf:	filesystem supplied oob data buffer * @oobsel:	oob selection structure * * NAND write with iovec with ecc */static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count,		loff_t to, size_t * retlen, u_char *eccbuf, struct nand_oobinfo *oobsel){	int i, page, len, total_len, ret = -EIO, written = 0, chipnr;	int oob, numpages, autoplace = 0, startpage;	struct nand_chip *this = mtd->priv;	int	ppblock = (1 << (this->phys_erase_shift - this->page_shift));	u_char *oobbuf, *bufstart;	/* Preset written len for early exit */	*retlen = 0;	/* Calculate total length of data */	total_len = 0;	for (i = 0; i < count; i++)		total_len += (int) vecs[i].iov_len;	DEBUG (MTD_DEBUG_LEVEL3,	       "nand_writev: to = 0x%08x, len = %i, count = %ld\n", (unsigned int) to, (unsigned int) total_len, count);	/* Do not allow write past end of page */	if ((to + total_len) > mtd->size) {		DEBUG (MTD_DEBUG_LEVEL0, "nand_writev: Attempted write past end of device\n");		return -EINVAL;	}	/* reject writes, which are not page aligned */	if (NOTALIGNED (to) || NOTALIGNED(total_len)) {		printk (KERN_NOTICE "nand_write_ecc: Attempt to write not page aligned data\n");		return -EINVAL;	}	/* Grab the lock and see if the device is available */	nand_get_device (this, mtd, FL_WRITING);	/* Get the current chip-nr */	chipnr = (int) (to >> this->chip_shift);	/* Select the NAND device */	this->select_chip(mtd, chipnr);	/* Check, if it is write protected */	if (nand_check_wp(mtd))		goto out;	/* if oobsel is NULL, use chip defaults */	if (oobsel == NULL)		oobsel = &mtd->oobinfo;	/* Autoplace of oob data ? Use the default placement scheme */	if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) {		oobsel = this->autooob;		autoplace = 1;	}	if (oobsel->useecc == MTD_NANDECC_AUTOPL_USR)		autoplace = 1;	/* Setup start page */	page = (int) (to >> this->page_shift);	/* Invalidate the page cache, if we write to the cached page */	if (page <= this->pagebuf && this->pagebuf < ((to + total_len) >> this->page_shift))		this->pagebuf = -1;	startpage = page & this->pagemask;	/* Loop until all kvec' data has been written */	len = 0;	while (count) {		/* If the given tuple is >= pagesize then		 * write it out from the iov		 */		if ((vecs->iov_len - len) >= mtd->oobblock) {			/* Calc number of pages we can write			 * out of this iov in one go */			numpages = (vecs->iov_len - len) >> this->page_shift;			/* Do not cross block boundaries */			numpages = min (ppblock - (startpage & (ppblock - 1)), numpages);			oobbuf = nand_prepare_oobbuf (mtd, NULL, oobsel, autoplace, numpages);			bufstart = (u_char *)vecs->iov_base;			bufstart += len;			this->data_poi = bufstart;			oob = 0;			for (i = 1; i <= numpages; i++) {				/* Write one page. If this is the last page to write				 * then use the real pageprogram command, else select				 * cached programming if supported by the chip.				 */				ret = nand_write_page (mtd, this, page & this->pagemask,					&oobbuf[oob], oobsel, i != numpages);				if (ret)					goto out;				this->data_poi += mtd->oobblock;				len += mtd->oobblock;				oob += mtd->oobsize;				page++;			}			/* Check, if we have to switch to the next tuple */			if (len >= (int) vecs->iov_len) {				vecs++;				len = 0;				count--;			}		} else {			/* We must use the internal buffer, read data out of each			 * tuple until we have a full page to write			 */			int cnt = 0;			while (cnt < mtd->oobblock) {				if (vecs->iov_base != NULL && vecs->iov_len)					this->data_buf[cnt++] = ((u_char *) vecs->iov_base)[len++];				/* Check, if we have to switch to the next tuple */				if (len >= (int) vecs->iov_len) {					vecs++;					len = 0;					count--;				}			}			this->pagebuf = page;			this->data_poi = this->data_buf;			bufstart = this->data_poi;			numpages = 1;			oobbuf = nand_prepare_oobbuf (mtd, NULL, oobsel, autoplace, numpages);			ret = nand_write_page (mtd, this, page & this->pagemask,				oobbuf, oobsel, 0);			if (ret)				goto out;			page++;		}		this->data_poi = bufstart;		ret = nand_verify_pages (mtd, this, startpage, numpages, oobbuf, oobsel, chipnr, 0);		if (ret)			goto out;		written += mtd->oobblock * numpages;		/* All done ? */		if (!count)			break;		startpage = page & this->pagemask;		/* Check, if we cross a chip boundary */		if (!startpage) {			chipnr++;			this->select_chip(mtd, -1);			this->select_chip(mtd, chipnr);		}	}	ret = 0;out:	/* Deselect and wake up anyone waiting on the device */	nand_release_device(mtd);	*retlen = written;	return ret;}#endif/** * single_erease_cmd - [GENERIC] NAND standard block erase command function * @mtd:	MTD device structure * @page:	the page address of the block which will be erased * * Standard erase command for NAND chips */static void single_erase_cmd (struct mtd_info *mtd, int page){	struct nand_chip *this = mtd->priv;	/* Send commands to erase a block */	this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page);	this->cmdfunc (mtd, NAND_CMD_ERASE2, -1, -1);}/** * multi_erease_cmd - [GENERIC] AND specific block erase command function * @mtd:	MTD device structure * @page:	the page address of the block which will be erased * * AND multi block erase command function * Erase 4 consecutive blocks */static void multi_erase_cmd (struct mtd_info *mtd, int page){	struct nand_chip *this = mtd->priv;	/* Send commands to erase a block */	this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++);	this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++);	this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++);	this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page);	this->cmdfunc (mtd, NAND_CMD_ERASE2, -1, -1);}/** * nand_erase - [MTD Interface] erase block(s) * @mtd:	MTD device structure * @instr:	erase instruction * * Erase one ore more blocks */static int nand_erase (struct mtd_info *mtd, struct erase_info *instr){	return nand_erase_nand (mtd, instr, 0);}/** * nand_erase_intern - [NAND Interface] erase block(s) * @mtd:	MTD device structure * @instr:	erase instruction * @allowbbt:	allow erasing the bbt area * * Erase one ore more blocks */int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbbt){	int page, len, status, pages_per_block, ret, chipnr;	struct nand_chip *this = mtd->priv;	DEBUG (MTD_DEBUG_LEVEL3,	       "nand_erase: start = 0x%08x, len = %i\n", (unsigned int) instr->addr, (unsigned int) instr->len);	/* Start address must align on block boundary */	if (instr->addr & ((1 << this->phys_erase_shift) - 1)) {		DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Unaligned address\n");		return -EINVAL;	}	/* Length must align on block boundary */	if (instr->len & ((1 << this->phys_erase_shift) - 1)) {		DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Length not block aligned\n");		return -EINVAL;	}	/* Do not allow erase past end of device */	if ((instr->len + instr->addr) > mtd->size) {		DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Erase past end of device\n");		return -EINVAL;	}	instr->fail_addr = 0xffffffff;	/* Grab the lock and see if the device is available */	nand_get_device (this, mtd, FL_ERASING);	/* Shift to get first page */	page = (int) (instr->addr >> this->page_shift);	chipnr = (int) (instr->addr >> this->chip_shift);	/* Calculate pages in each block */	pages_per_block = 1 << (this