/* 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 & NAND_STATUS_FAIL) {		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;}/** * 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;}/** * 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);}#define BBT_PAGE_MASK	0xffffff3f/** * 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;	int rewrite_bbt[NAND_MAX_CHIPS]={0};	/* flags to indicate the page, if bbt needs to be rewritten. */	unsigned int bbt_masked_page;		/* bbt mask to compare to page being erased. */						/* It is used to see if the current page is in the same */						/*   256 block group and the same bank as the bbt. */	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->phys_erase_shift - this->page_shift);	/* Select the NAND device */	this->select_chip(mtd, chipnr);	/* Check the WP bit */	/* Check, if it is write protected */	if (nand_check_wp(mtd)) {		DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Device is write protected!!!\n");		instr->state = MTD_ERASE_FAILED;		goto erase_exit;	}	/* if BBT requires refresh, set the BBT page mask to see if the BBT should be rewritten */	if (this->options & BBT_AUTO_REFRESH) {		bbt_masked_page = this->bbt_td->pages[chipnr] & BBT_PAGE_MASK;	} else {		bbt_masked_page = 0xffffffff;	/* should not match anything */	}	/* Loop through the pages */	len = instr->len;	instr->state = MTD_ERASING;	while (len) {		/* Check if we have a bad block, we do not erase bad blocks ! */		if (nand_block_checkbad(mtd, ((loff_t) page) << this->page_shift, 0, allowbbt)) {			printk (KERN_WARNING "nand_erase: attempt to erase a bad block at page 0x%08x\n", page);			instr->state = MTD_ERASE_FAILED;			goto erase_exit;		}		/* Invalidate the page cache, if we erase the block which contains		   the current cached page */		if (page <= this->pagebuf && this->pagebuf < (page + pages_per_block))			this->pagebuf = -1;		this->erase_cmd (mtd, page & this->pagemask);		status = this->waitfunc (mtd, this, FL_ERASING);		/* See if operation failed and additional status checks are available */		if ((status & NAND_STATUS_FAIL) && (this->errstat)) {			status = this->errstat(mtd, this, FL_ERASING, status, page);		}		/* See if block erase succeeded */		if (status & NAND_STATUS_FAIL) {			DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: " "Failed erase, page 0x%08x\n", page);			instr->state = MTD_ERASE_FAILED;			instr->fail_addr = (page << this->page_shift);			goto erase_exit;		}		/* if BBT requires refresh, set the BBT rewrite flag to the page being erased */		if (this->options & BBT_AUTO_REFRESH) {			if (((page & BBT_PAGE_MASK) == bbt_masked_page) &&			     (page != this->bbt_td->pages[chipnr])) {				rewrite_bbt[chipnr] = (page << this->page_shift);			}		}		/* Increment page address and decrement length */		len -= (1 << this->phys_erase_shift);		page += pages_per_block;		/* Check, if we cross a chip boundary */		if (len && !(page & this->pagemask)) {			chipnr++;			this->select_chip(mtd, -1);			this->select_chip(mtd, chipnr);			/* if BBT requires refresh and BBT-PERCHIP,			 *   set the BBT page mask to see if this BBT should be rewritten */			if ((this->options & BBT_AUTO_REFRESH) && (this->bbt_td->options & NAND_BBT_PERCHIP)) {				bbt_masked_pa