/* * Linux driver for Disk-On-Chip 2000 and Millennium * (c) 1999 Machine Vision Holdings, Inc. * (c) 1999, 2000 David Woodhouse <dwmw2@infradead.org> * * $Id: doc2000.c,v 1.2 2007/09/21 03:09:24 quy Exp $ */#include <linux/kernel.h>#include <linux/module.h>#include <asm/errno.h>#include <asm/io.h>#include <asm/uaccess.h>#include <linux/miscdevice.h>#include <linux/pci.h>#include <linux/delay.h>#include <linux/slab.h>#include <linux/sched.h>#include <linux/init.h>#include <linux/types.h>#include <linux/bitops.h>#include <linux/mtd/mtd.h>#include <linux/mtd/nand.h>#include <linux/mtd/doc2000.h>#define DOC_SUPPORT_2000#define DOC_SUPPORT_2000TSOP#define DOC_SUPPORT_MILLENNIUM#ifdef DOC_SUPPORT_2000#define DoC_is_2000(doc) (doc->ChipID == DOC_ChipID_Doc2k)#else#define DoC_is_2000(doc) (0)#endif#if defined(DOC_SUPPORT_2000TSOP) || defined(DOC_SUPPORT_MILLENNIUM)#define DoC_is_Millennium(doc) (doc->ChipID == DOC_ChipID_DocMil)#else#define DoC_is_Millennium(doc) (0)#endif/* #define ECC_DEBUG *//* I have no idea why some DoC chips can not use memcpy_from|to_io(). * This may be due to the different revisions of the ASIC controller built-in or * simplily a QA/Bug issue. Who knows ?? If you have trouble, please uncomment * this: #undef USE_MEMCPY*/static int doc_read(struct mtd_info *mtd, loff_t from, size_t len,		    size_t *retlen, u_char *buf);static int doc_write(struct mtd_info *mtd, loff_t to, size_t len,		     size_t *retlen, const u_char *buf);static int doc_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,			size_t *retlen, u_char *buf, u_char *eccbuf, struct nand_oobinfo *oobsel);static int doc_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,			 size_t *retlen, const u_char *buf, u_char *eccbuf, struct nand_oobinfo *oobsel);static int doc_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);static int doc_read_oob(struct mtd_info *mtd, loff_t ofs, size_t len,			size_t *retlen, u_char *buf);static int doc_write_oob(struct mtd_info *mtd, loff_t ofs, size_t len,			 size_t *retlen, const u_char *buf);static int doc_write_oob_nolock(struct mtd_info *mtd, loff_t ofs, size_t len,			 size_t *retlen, const u_char *buf);static int doc_erase (struct mtd_info *mtd, struct erase_info *instr);static struct mtd_info *doc2klist = NULL;/* Perform the required delay cycles by reading from the appropriate register */static void DoC_Delay(struct DiskOnChip *doc, unsigned short cycles){	volatile char dummy;	int i;		for (i = 0; i < cycles; i++) {		if (DoC_is_Millennium(doc))			dummy = ReadDOC(doc->virtadr, NOP);		else			dummy = ReadDOC(doc->virtadr, DOCStatus);	}	}/* DOC_WaitReady: Wait for RDY line to be asserted by the flash chip */static int _DoC_WaitReady(struct DiskOnChip *doc){	unsigned long docptr = doc->virtadr;	unsigned long timeo = jiffies + (HZ * 10);	DEBUG(MTD_DEBUG_LEVEL3,	      "_DoC_WaitReady called for out-of-line wait\n");	/* Out-of-line routine to wait for chip response */	while (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B)) {		/* issue 2 read from NOP register after reading from CDSNControl register	   	see Software Requirement 11.4 item 2. */		DoC_Delay(doc, 2);		if (time_after(jiffies, timeo)) {			DEBUG(MTD_DEBUG_LEVEL2, "_DoC_WaitReady timed out.\n");			return -EIO;		}		udelay(1);		cond_resched();	}	return 0;}static inline int DoC_WaitReady(struct DiskOnChip *doc){	unsigned long docptr = doc->virtadr;	/* This is inline, to optimise the common case, where it's ready instantly */	int ret = 0;	/* 4 read form NOP register should be issued in prior to the read from CDSNControl	   see Software Requirement 11.4 item 2. */	DoC_Delay(doc, 4);	if (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B))		/* Call the out-of-line routine to wait */		ret = _DoC_WaitReady(doc);	/* issue 2 read from NOP register after reading from CDSNControl register	   see Software Requirement 11.4 item 2. */	DoC_Delay(doc, 2);	return ret;}/* DoC_Command: Send a flash command to the flash chip through the CDSN Slow IO register to   bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is   required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */static inline int DoC_Command(struct DiskOnChip *doc, unsigned char command,			      unsigned char xtraflags){	unsigned long docptr = doc->virtadr;	if (DoC_is_2000(doc))		xtraflags |= CDSN_CTRL_FLASH_IO;	/* Assert the CLE (Command Latch Enable) line to the flash chip */	WriteDOC(xtraflags | CDSN_CTRL_CLE | CDSN_CTRL_CE, docptr, CDSNControl);	DoC_Delay(doc, 4);	/* Software requirement 11.4.3 for Millennium */	if (DoC_is_Millennium(doc))		WriteDOC(command, docptr, CDSNSlowIO);	/* Send the command */	WriteDOC_(command, docptr, doc->ioreg);	if (DoC_is_Millennium(doc))		WriteDOC(command, docptr, WritePipeTerm);	/* Lower the CLE line */	WriteDOC(xtraflags | CDSN_CTRL_CE, docptr, CDSNControl);	DoC_Delay(doc, 4);	/* Software requirement 11.4.3 for Millennium */	/* Wait for the chip to respond - Software requirement 11.4.1 (extended for any command) */	return DoC_WaitReady(doc);}/* DoC_Address: Set the current address for the flash chip through the CDSN Slow IO register to   bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is   required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */static int DoC_Address(struct DiskOnChip *doc, int numbytes, unsigned long ofs,		       unsigned char xtraflags1, unsigned char xtraflags2){	unsigned long docptr;	int i;	docptr = doc->virtadr;	if (DoC_is_2000(doc))		xtraflags1 |= CDSN_CTRL_FLASH_IO;	/* Assert the ALE (Address Latch Enable) line to the flash chip */	WriteDOC(xtraflags1 | CDSN_CTRL_ALE | CDSN_CTRL_CE, docptr, CDSNControl);	DoC_Delay(doc, 4);	/* Software requirement 11.4.3 for Millennium */	/* Send the address */	/* Devices with 256-byte page are addressed as:	   Column (bits 0-7), Page (bits 8-15, 16-23, 24-31)	   * there is no device on the market with page256	   and more than 24 bits.	   Devices with 512-byte page are addressed as:	   Column (bits 0-7), Page (bits 9-16, 17-24, 25-31)	   * 25-31 is sent only if the chip support it.	   * bit 8 changes the read command to be sent	   (NAND_CMD_READ0 or NAND_CMD_READ1).	 */	if (numbytes == ADDR_COLUMN || numbytes == ADDR_COLUMN_PAGE) {		if (DoC_is_Millennium(doc))			WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);		WriteDOC_(ofs & 0xff, docptr, doc->ioreg);	}	if (doc->page256) {		ofs = ofs >> 8;	} else {		ofs = ofs >> 9;	}	if (numbytes == ADDR_PAGE || numbytes == ADDR_COLUMN_PAGE) {		for (i = 0; i < doc->pageadrlen; i++, ofs = ofs >> 8) {			if (DoC_is_Millennium(doc))				WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);			WriteDOC_(ofs & 0xff, docptr, doc->ioreg);		}	}	if (DoC_is_Millennium(doc))		WriteDOC(ofs & 0xff, docptr, WritePipeTerm);	DoC_Delay(doc, 2);	/* Needed for some slow flash chips. mf. */		/* FIXME: The SlowIO's for millennium could be replaced by 	   a single WritePipeTerm here. mf. */	/* Lower the ALE line */	WriteDOC(xtraflags1 | xtraflags2 | CDSN_CTRL_CE, docptr,		 CDSNControl);	DoC_Delay(doc, 4);	/* Software requirement 11.4.3 for Millennium */	/* Wait for the chip to respond - Software requirement 11.4.1 */	return DoC_WaitReady(doc);}/* Read a buffer from DoC, taking care of Millennium odditys */static void DoC_ReadBuf(struct DiskOnChip *doc, u_char * buf, int len){	volatile int dummy;	int modulus = 0xffff;	unsigned long docptr;	int i;	docptr = doc->virtadr;	if (len <= 0)		return;	if (DoC_is_Millennium(doc)) {		/* Read the data via the internal pipeline through CDSN IO register,		   see Pipelined Read Operations 11.3 */		dummy = ReadDOC(docptr, ReadPipeInit);		/* Millennium should use the LastDataRead register - Pipeline Reads */		len--;		/* This is needed for correctly ECC calculation */		modulus = 0xff;	}	for (i = 0; i < len; i++)		buf[i] = ReadDOC_(docptr, doc->ioreg + (i & modulus));	if (DoC_is_Millennium(doc)) {		buf[i] = ReadDOC(docptr, LastDataRead);	}}/* Write a buffer to DoC, taking care of Millennium odditys */static void DoC_WriteBuf(struct DiskOnChip *doc, const u_char * buf, int len){	unsigned long docptr;	int i;	docptr = doc->virtadr;	if (len <= 0)		return;	for (i = 0; i < len; i++)		WriteDOC_(buf[i], docptr, doc->ioreg + i);	if (DoC_is_Millennium(doc)) {		WriteDOC(0x00, docptr, WritePipeTerm);	}}/* DoC_SelectChip: Select a given flash chip within the current floor */static inline int DoC_SelectChip(struct DiskOnChip *doc, int chip){	unsigned long docptr = doc->virtadr;	/* Software requirement 11.4.4 before writing DeviceSelect */	/* Deassert the CE line to eliminate glitches on the FCE# outputs */	WriteDOC(CDSN_CTRL_WP, docptr, CDSNControl);	DoC_Delay(doc, 4);	/* Software requirement 11.4.3 for Millennium */	/* Select the individual flash chip requested */	WriteDOC(chip, docptr, CDSNDeviceSelect);	DoC_Delay(doc, 4);	/* Reassert the CE line */	WriteDOC(CDSN_CTRL_CE | CDSN_CTRL_FLASH_IO | CDSN_CTRL_WP, docptr,		 CDSNControl);	DoC_Delay(doc, 4);	/* Software requirement 11.4.3 for Millennium */	/* Wait for it to be ready */	return DoC_WaitReady(doc);}/* DoC_SelectFloor: Select a given floor (bank of flash chips) */static inline int DoC_SelectFloor(struct DiskOnChip *doc, int floor){	unsigned long docptr = doc->virtadr;	/* Select the floor (bank) of chips required */	WriteDOC(floor, docptr, FloorSelect);	/* Wait for the chip to be ready */	return DoC_WaitReady(doc);}/* DoC_IdentChip: Identify a given NAND chip given {floor,chip} */static int DoC_IdentChip(struct DiskOnChip *doc, int floor, int chip){	int mfr, id, i, j;	volatile char dummy;	/* Page in the required floor/chip */	DoC_SelectFloor(doc, floor);	DoC_SelectChip(doc, chip);	/* Reset the chip */	if (DoC_Command(doc, NAND_CMD_RESET, CDSN_CTRL_WP)) {		DEBUG(MTD_DEBUG_LEVEL2,		      "DoC_Command (reset) for %d,%d returned true\n",		      floor, chip);		return 0;	}	/* Read the NAND chip ID: 1. Send ReadID command */	if (DoC_Command(doc, NAND_CMD_READID, CDSN_CTRL_WP)) {		DEBUG(MTD_DEBUG_LEVEL2,		      "DoC_Command (ReadID) for %d,%d returned true\n",		      floor, chip);		return 0;	}	/* Read the NAND chip ID: 2. Send address byte zero */	DoC_Address(doc, ADDR_COLUMN, 0, CDSN_CTRL_WP, 0);	/* Read the manufacturer and device id codes from the device */	if (DoC_is_Millennium(doc)) {		DoC_Delay(doc, 2);		dummy = ReadDOC(doc->virtadr, ReadPipeInit);		mfr = ReadDOC(doc->virtadr, LastDataRead);		DoC_Delay(doc, 2);		dummy = ReadDOC(doc->virtadr, ReadPipeInit);		id = ReadDOC(doc->virtadr, LastDataRead);	} else {		/* CDSN Slow IO register see Software Req 11.4 item 5. */		dummy = ReadDOC(doc->virtadr, CDSNSlowIO);		DoC_Delay(doc, 2);		mfr = ReadDOC_(doc->virtadr, doc->ioreg);		/* CDSN Slow IO register see Software Req 11.4 item 5. */		dummy = ReadDOC(doc->virtadr, CDSNSlowIO);		DoC_Delay(doc, 2);		id = ReadDOC_(doc->virtadr, doc->ioreg);	}	/* No response - return failure */	if (mfr == 0xff || mfr == 0)		return 0;	/* Check it's the same as the first chip we identified. 	 * M-Systems say that any given DiskOnChip device should only	 * contain _one_ type of flash part, although that's not a 	 * hardware restriction. */	if (doc->mfr) {		if (doc->mfr == mfr && doc->id == id)			return 1;	/* This is another the same the first */		else			printk(KERN_WARNING			       "Flash chip at floor %d, chip %d is different:\n",			       floor, chip);	}	/* Print and store the manufacturer and ID codes. */	for (i = 0; nand_flash_ids[i].name != NULL; i++) {		if (id == nand_flash_ids[i].id) {			/* Try to identify manufacturer */			for (j = 0; nand_manuf_ids[j].id != 0x0; j++) {				if (nand_manuf_ids[j].id == mfr)					break;			}				printk(KERN_INFO			       "Flash chip found: Manufacturer ID: %2.2X, "			       "Chip ID: %2.2X (%s:%s)\n", mfr, id,			       nand_manuf_ids[j].name, nand_flash_ids[i].name);			if (!doc->mfr) {				doc->mfr = mfr;				doc->id = id;				doc->chipshift = 					ffs((nand_flash_ids[i].chipsize << 20)) - 1;				doc->page256 = (nand_flash_ids[i].pagesize == 256) ? 1 : 0;				doc->pageadrlen = doc->chipshift > 25 ? 3 : 2;				doc->erasesize =				    nand_flash_ids[i].erasesize;				return 1;			}			return 0;		}	}	/* We haven't fully identified the chip. Print as much as we know. */	printk(KERN_WARNING "Unknown flash chip found: %2.2X %2.2X\n",	       id, mfr);	printk(KERN_WARNING "Please report to dwmw2@infradead.org\n");	return 0;}/* DoC_ScanChips: Find all NAND chips present in a DiskOnChip, and identify them */static void DoC_ScanChips(struct DiskOnChip *this, int maxchips){	int floor, chip;	int numchips[MAX_FLOORS];	int ret = 1;	this->numchips = 0;