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->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;	}	/* Loop through the pages */	len = instr->len;	instr->state = MTD_ERASING;	while (len) {#ifndef NAND_ALLOW_ERASE_ALL		/* 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;		}#endif		/* 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 block erase succeeded */		if (status & 0x01) {			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;		}		/* 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);		}	}	instr->state = MTD_ERASE_DONE;erase_exit:	ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;	/* Do call back function */	if (!ret)		mtd_erase_callback(instr);	/* Deselect and wake up anyone waiting on the device */	nand_release_device(mtd);	/* Return more or less happy */	return ret;}/** * nand_sync - [MTD Interface] sync * @mtd:	MTD device structure * * Sync is actually a wait for chip ready function */static void nand_sync (struct mtd_info *mtd){	struct nand_chip *this = mtd->priv;	DEBUG (MTD_DEBUG_LEVEL3, "nand_sync: called\n");	/* Grab the lock and see if the device is available */	nand_get_device (this, mtd, FL_SYNCING);	/* Release it and go back */	nand_release_device (mtd);}/** * nand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad * @mtd:	MTD device structure * @ofs:	offset relative to mtd start */static int nand_block_isbad (struct mtd_info *mtd, loff_t ofs){	/* Check for invalid offset */	if (ofs > mtd->size)		return -EINVAL;	return nand_block_checkbad (mtd, ofs, 1, 0);}/** * nand_block_markbad - [MTD Interface] Mark the block at the given offset as bad * @mtd:	MTD device structure * @ofs:	offset relative to mtd start */static int nand_block_markbad (struct mtd_info *mtd, loff_t ofs){	struct nand_chip *this = mtd->priv;	int ret;	if ((ret = nand_block_isbad(mtd, ofs))) {		/* If it was bad already, return success and do nothing. */		if (ret > 0)			return 0;		return ret;	}	return this->block_markbad(mtd, ofs);}/** * nand_scan - [NAND Interface] Scan for the NAND device * @mtd:	MTD device structure * @maxchips:	Number of chips to scan for * * This fills out all the not initialized function pointers * with the defaults. * The flash ID is read and the mtd/chip structures are * filled with the appropriate values. Buffers are allocated if * they are not provided by the board driver * */int nand_scan (struct mtd_info *mtd, int maxchips){	int i, j, nand_maf_id, nand_dev_id, busw;	struct nand_chip *this = mtd->priv;	/* Get buswidth to select the correct functions*/	busw = this->options & NAND_BUSWIDTH_16;	/* check for proper chip_delay setup, set 20us if not */	if (!this->chip_delay)		this->chip_delay = 20;	/* check, if a user supplied command function given */	if (this->cmdfunc == NULL)		this->cmdfunc = nand_command;	/* check, if a user supplied wait function given */	if (this->waitfunc == NULL)		this->waitfunc = nand_wait;	if (!this->select_chip)		this->select_chip = nand_select_chip;	if (!this->write_byte)		this->write_byte = busw ? nand_write_byte16 : nand_write_byte;	if (!this->read_byte)		this->read_byte = busw ? nand_read_byte16 : nand_read_byte;	if (!this->write_word)		this->write_word = nand_write_word;	if (!this->read_word)		this->read_word = nand_read_word;	if (!this->block_bad)		this->block_bad = nand_b