cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

diskonchip.c (44456B)


      1// SPDX-License-Identifier: GPL-2.0-only
      2/*
      3 * (C) 2003 Red Hat, Inc.
      4 * (C) 2004 Dan Brown <dan_brown@ieee.org>
      5 * (C) 2004 Kalev Lember <kalev@smartlink.ee>
      6 *
      7 * Author: David Woodhouse <dwmw2@infradead.org>
      8 * Additional Diskonchip 2000 and Millennium support by Dan Brown <dan_brown@ieee.org>
      9 * Diskonchip Millennium Plus support by Kalev Lember <kalev@smartlink.ee>
     10 *
     11 * Error correction code lifted from the old docecc code
     12 * Author: Fabrice Bellard (fabrice.bellard@netgem.com)
     13 * Copyright (C) 2000 Netgem S.A.
     14 * converted to the generic Reed-Solomon library by Thomas Gleixner <tglx@linutronix.de>
     15 *
     16 * Interface to generic NAND code for M-Systems DiskOnChip devices
     17 */
     18
     19#include <linux/kernel.h>
     20#include <linux/init.h>
     21#include <linux/sched.h>
     22#include <linux/delay.h>
     23#include <linux/rslib.h>
     24#include <linux/moduleparam.h>
     25#include <linux/slab.h>
     26#include <linux/io.h>
     27
     28#include <linux/mtd/mtd.h>
     29#include <linux/mtd/rawnand.h>
     30#include <linux/mtd/doc2000.h>
     31#include <linux/mtd/partitions.h>
     32#include <linux/mtd/inftl.h>
     33#include <linux/module.h>
     34
     35/* Where to look for the devices? */
     36#ifndef CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDRESS
     37#define CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDRESS 0
     38#endif
     39
     40static unsigned long doc_locations[] __initdata = {
     41#if defined (__alpha__) || defined(__i386__) || defined(__x86_64__)
     42#ifdef CONFIG_MTD_NAND_DISKONCHIP_PROBE_HIGH
     43	0xfffc8000, 0xfffca000, 0xfffcc000, 0xfffce000,
     44	0xfffd0000, 0xfffd2000, 0xfffd4000, 0xfffd6000,
     45	0xfffd8000, 0xfffda000, 0xfffdc000, 0xfffde000,
     46	0xfffe0000, 0xfffe2000, 0xfffe4000, 0xfffe6000,
     47	0xfffe8000, 0xfffea000, 0xfffec000, 0xfffee000,
     48#else
     49	0xc8000, 0xca000, 0xcc000, 0xce000,
     50	0xd0000, 0xd2000, 0xd4000, 0xd6000,
     51	0xd8000, 0xda000, 0xdc000, 0xde000,
     52	0xe0000, 0xe2000, 0xe4000, 0xe6000,
     53	0xe8000, 0xea000, 0xec000, 0xee000,
     54#endif
     55#endif
     56	0xffffffff };
     57
     58static struct mtd_info *doclist = NULL;
     59
     60struct doc_priv {
     61	struct nand_controller base;
     62	void __iomem *virtadr;
     63	unsigned long physadr;
     64	u_char ChipID;
     65	u_char CDSNControl;
     66	int chips_per_floor;	/* The number of chips detected on each floor */
     67	int curfloor;
     68	int curchip;
     69	int mh0_page;
     70	int mh1_page;
     71	struct rs_control *rs_decoder;
     72	struct mtd_info *nextdoc;
     73	bool supports_32b_reads;
     74
     75	/* Handle the last stage of initialization (BBT scan, partitioning) */
     76	int (*late_init)(struct mtd_info *mtd);
     77};
     78
     79/* This is the ecc value computed by the HW ecc generator upon writing an empty
     80   page, one with all 0xff for data. */
     81static u_char empty_write_ecc[6] = { 0x4b, 0x00, 0xe2, 0x0e, 0x93, 0xf7 };
     82
     83#define INFTL_BBT_RESERVED_BLOCKS 4
     84
     85#define DoC_is_MillenniumPlus(doc) ((doc)->ChipID == DOC_ChipID_DocMilPlus16 || (doc)->ChipID == DOC_ChipID_DocMilPlus32)
     86#define DoC_is_Millennium(doc) ((doc)->ChipID == DOC_ChipID_DocMil)
     87#define DoC_is_2000(doc) ((doc)->ChipID == DOC_ChipID_Doc2k)
     88
     89static int debug = 0;
     90module_param(debug, int, 0);
     91
     92static int try_dword = 1;
     93module_param(try_dword, int, 0);
     94
     95static int no_ecc_failures = 0;
     96module_param(no_ecc_failures, int, 0);
     97
     98static int no_autopart = 0;
     99module_param(no_autopart, int, 0);
    100
    101static int show_firmware_partition = 0;
    102module_param(show_firmware_partition, int, 0);
    103
    104#ifdef CONFIG_MTD_NAND_DISKONCHIP_BBTWRITE
    105static int inftl_bbt_write = 1;
    106#else
    107static int inftl_bbt_write = 0;
    108#endif
    109module_param(inftl_bbt_write, int, 0);
    110
    111static unsigned long doc_config_location = CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDRESS;
    112module_param(doc_config_location, ulong, 0);
    113MODULE_PARM_DESC(doc_config_location, "Physical memory address at which to probe for DiskOnChip");
    114
    115/* Sector size for HW ECC */
    116#define SECTOR_SIZE 512
    117/* The sector bytes are packed into NB_DATA 10 bit words */
    118#define NB_DATA (((SECTOR_SIZE + 1) * 8 + 6) / 10)
    119/* Number of roots */
    120#define NROOTS 4
    121/* First consective root */
    122#define FCR 510
    123/* Number of symbols */
    124#define NN 1023
    125
    126/*
    127 * The HW decoder in the DoC ASIC's provides us a error syndrome,
    128 * which we must convert to a standard syndrome usable by the generic
    129 * Reed-Solomon library code.
    130 *
    131 * Fabrice Bellard figured this out in the old docecc code. I added
    132 * some comments, improved a minor bit and converted it to make use
    133 * of the generic Reed-Solomon library. tglx
    134 */
    135static int doc_ecc_decode(struct rs_control *rs, uint8_t *data, uint8_t *ecc)
    136{
    137	int i, j, nerr, errpos[8];
    138	uint8_t parity;
    139	uint16_t ds[4], s[5], tmp, errval[8], syn[4];
    140	struct rs_codec *cd = rs->codec;
    141
    142	memset(syn, 0, sizeof(syn));
    143	/* Convert the ecc bytes into words */
    144	ds[0] = ((ecc[4] & 0xff) >> 0) | ((ecc[5] & 0x03) << 8);
    145	ds[1] = ((ecc[5] & 0xfc) >> 2) | ((ecc[2] & 0x0f) << 6);
    146	ds[2] = ((ecc[2] & 0xf0) >> 4) | ((ecc[3] & 0x3f) << 4);
    147	ds[3] = ((ecc[3] & 0xc0) >> 6) | ((ecc[0] & 0xff) << 2);
    148	parity = ecc[1];
    149
    150	/* Initialize the syndrome buffer */
    151	for (i = 0; i < NROOTS; i++)
    152		s[i] = ds[0];
    153	/*
    154	 *  Evaluate
    155	 *  s[i] = ds[3]x^3 + ds[2]x^2 + ds[1]x^1 + ds[0]
    156	 *  where x = alpha^(FCR + i)
    157	 */
    158	for (j = 1; j < NROOTS; j++) {
    159		if (ds[j] == 0)
    160			continue;
    161		tmp = cd->index_of[ds[j]];
    162		for (i = 0; i < NROOTS; i++)
    163			s[i] ^= cd->alpha_to[rs_modnn(cd, tmp + (FCR + i) * j)];
    164	}
    165
    166	/* Calc syn[i] = s[i] / alpha^(v + i) */
    167	for (i = 0; i < NROOTS; i++) {
    168		if (s[i])
    169			syn[i] = rs_modnn(cd, cd->index_of[s[i]] + (NN - FCR - i));
    170	}
    171	/* Call the decoder library */
    172	nerr = decode_rs16(rs, NULL, NULL, 1019, syn, 0, errpos, 0, errval);
    173
    174	/* Incorrectable errors ? */
    175	if (nerr < 0)
    176		return nerr;
    177
    178	/*
    179	 * Correct the errors. The bitpositions are a bit of magic,
    180	 * but they are given by the design of the de/encoder circuit
    181	 * in the DoC ASIC's.
    182	 */
    183	for (i = 0; i < nerr; i++) {
    184		int index, bitpos, pos = 1015 - errpos[i];
    185		uint8_t val;
    186		if (pos >= NB_DATA && pos < 1019)
    187			continue;
    188		if (pos < NB_DATA) {
    189			/* extract bit position (MSB first) */
    190			pos = 10 * (NB_DATA - 1 - pos) - 6;
    191			/* now correct the following 10 bits. At most two bytes
    192			   can be modified since pos is even */
    193			index = (pos >> 3) ^ 1;
    194			bitpos = pos & 7;
    195			if ((index >= 0 && index < SECTOR_SIZE) || index == (SECTOR_SIZE + 1)) {
    196				val = (uint8_t) (errval[i] >> (2 + bitpos));
    197				parity ^= val;
    198				if (index < SECTOR_SIZE)
    199					data[index] ^= val;
    200			}
    201			index = ((pos >> 3) + 1) ^ 1;
    202			bitpos = (bitpos + 10) & 7;
    203			if (bitpos == 0)
    204				bitpos = 8;
    205			if ((index >= 0 && index < SECTOR_SIZE) || index == (SECTOR_SIZE + 1)) {
    206				val = (uint8_t) (errval[i] << (8 - bitpos));
    207				parity ^= val;
    208				if (index < SECTOR_SIZE)
    209					data[index] ^= val;
    210			}
    211		}
    212	}
    213	/* If the parity is wrong, no rescue possible */
    214	return parity ? -EBADMSG : nerr;
    215}
    216
    217static void DoC_Delay(struct doc_priv *doc, unsigned short cycles)
    218{
    219	volatile char __always_unused dummy;
    220	int i;
    221
    222	for (i = 0; i < cycles; i++) {
    223		if (DoC_is_Millennium(doc))
    224			dummy = ReadDOC(doc->virtadr, NOP);
    225		else if (DoC_is_MillenniumPlus(doc))
    226			dummy = ReadDOC(doc->virtadr, Mplus_NOP);
    227		else
    228			dummy = ReadDOC(doc->virtadr, DOCStatus);
    229	}
    230
    231}
    232
    233#define CDSN_CTRL_FR_B_MASK	(CDSN_CTRL_FR_B0 | CDSN_CTRL_FR_B1)
    234
    235/* DOC_WaitReady: Wait for RDY line to be asserted by the flash chip */
    236static int _DoC_WaitReady(struct doc_priv *doc)
    237{
    238	void __iomem *docptr = doc->virtadr;
    239	unsigned long timeo = jiffies + (HZ * 10);
    240
    241	if (debug)
    242		printk("_DoC_WaitReady...\n");
    243	/* Out-of-line routine to wait for chip response */
    244	if (DoC_is_MillenniumPlus(doc)) {
    245		while ((ReadDOC(docptr, Mplus_FlashControl) & CDSN_CTRL_FR_B_MASK) != CDSN_CTRL_FR_B_MASK) {
    246			if (time_after(jiffies, timeo)) {
    247				printk("_DoC_WaitReady timed out.\n");
    248				return -EIO;
    249			}
    250			udelay(1);
    251			cond_resched();
    252		}
    253	} else {
    254		while (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B)) {
    255			if (time_after(jiffies, timeo)) {
    256				printk("_DoC_WaitReady timed out.\n");
    257				return -EIO;
    258			}
    259			udelay(1);
    260			cond_resched();
    261		}
    262	}
    263
    264	return 0;
    265}
    266
    267static inline int DoC_WaitReady(struct doc_priv *doc)
    268{
    269	void __iomem *docptr = doc->virtadr;
    270	int ret = 0;
    271
    272	if (DoC_is_MillenniumPlus(doc)) {
    273		DoC_Delay(doc, 4);
    274
    275		if ((ReadDOC(docptr, Mplus_FlashControl) & CDSN_CTRL_FR_B_MASK) != CDSN_CTRL_FR_B_MASK)
    276			/* Call the out-of-line routine to wait */
    277			ret = _DoC_WaitReady(doc);
    278	} else {
    279		DoC_Delay(doc, 4);
    280
    281		if (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B))
    282			/* Call the out-of-line routine to wait */
    283			ret = _DoC_WaitReady(doc);
    284		DoC_Delay(doc, 2);
    285	}
    286
    287	if (debug)
    288		printk("DoC_WaitReady OK\n");
    289	return ret;
    290}
    291
    292static void doc2000_write_byte(struct nand_chip *this, u_char datum)
    293{
    294	struct doc_priv *doc = nand_get_controller_data(this);
    295	void __iomem *docptr = doc->virtadr;
    296
    297	if (debug)
    298		printk("write_byte %02x\n", datum);
    299	WriteDOC(datum, docptr, CDSNSlowIO);
    300	WriteDOC(datum, docptr, 2k_CDSN_IO);
    301}
    302
    303static void doc2000_writebuf(struct nand_chip *this, const u_char *buf,
    304			     int len)
    305{
    306	struct doc_priv *doc = nand_get_controller_data(this);
    307	void __iomem *docptr = doc->virtadr;
    308	int i;
    309	if (debug)
    310		printk("writebuf of %d bytes: ", len);
    311	for (i = 0; i < len; i++) {
    312		WriteDOC_(buf[i], docptr, DoC_2k_CDSN_IO + i);
    313		if (debug && i < 16)
    314			printk("%02x ", buf[i]);
    315	}
    316	if (debug)
    317		printk("\n");
    318}
    319
    320static void doc2000_readbuf(struct nand_chip *this, u_char *buf, int len)
    321{
    322	struct doc_priv *doc = nand_get_controller_data(this);
    323	void __iomem *docptr = doc->virtadr;
    324	u32 *buf32 = (u32 *)buf;
    325	int i;
    326
    327	if (debug)
    328		printk("readbuf of %d bytes: ", len);
    329
    330	if (!doc->supports_32b_reads ||
    331	    ((((unsigned long)buf) | len) & 3)) {
    332		for (i = 0; i < len; i++)
    333			buf[i] = ReadDOC(docptr, 2k_CDSN_IO + i);
    334	} else {
    335		for (i = 0; i < len / 4; i++)
    336			buf32[i] = readl(docptr + DoC_2k_CDSN_IO + i);
    337	}
    338}
    339
    340/*
    341 * We need our own readid() here because it's called before the NAND chip
    342 * has been initialized, and calling nand_op_readid() would lead to a NULL
    343 * pointer exception when dereferencing the NAND timings.
    344 */
    345static void doc200x_readid(struct nand_chip *this, unsigned int cs, u8 *id)
    346{
    347	u8 addr = 0;
    348	struct nand_op_instr instrs[] = {
    349		NAND_OP_CMD(NAND_CMD_READID, 0),
    350		NAND_OP_ADDR(1, &addr, 50),
    351		NAND_OP_8BIT_DATA_IN(2, id, 0),
    352	};
    353
    354	struct nand_operation op = NAND_OPERATION(cs, instrs);
    355
    356	if (!id)
    357		op.ninstrs--;
    358
    359	this->controller->ops->exec_op(this, &op, false);
    360}
    361
    362static uint16_t __init doc200x_ident_chip(struct mtd_info *mtd, int nr)
    363{
    364	struct nand_chip *this = mtd_to_nand(mtd);
    365	struct doc_priv *doc = nand_get_controller_data(this);
    366	uint16_t ret;
    367	u8 id[2];
    368
    369	doc200x_readid(this, nr, id);
    370
    371	ret = ((u16)id[0] << 8) | id[1];
    372
    373	if (doc->ChipID == DOC_ChipID_Doc2k && try_dword && !nr) {
    374		/* First chip probe. See if we get same results by 32-bit access */
    375		union {
    376			uint32_t dword;
    377			uint8_t byte[4];
    378		} ident;
    379		void __iomem *docptr = doc->virtadr;
    380
    381		doc200x_readid(this, nr, NULL);
    382
    383		ident.dword = readl(docptr + DoC_2k_CDSN_IO);
    384		if (((ident.byte[0] << 8) | ident.byte[1]) == ret) {
    385			pr_info("DiskOnChip 2000 responds to DWORD access\n");
    386			doc->supports_32b_reads = true;
    387		}
    388	}
    389
    390	return ret;
    391}
    392
    393static void __init doc2000_count_chips(struct mtd_info *mtd)
    394{
    395	struct nand_chip *this = mtd_to_nand(mtd);
    396	struct doc_priv *doc = nand_get_controller_data(this);
    397	uint16_t mfrid;
    398	int i;
    399
    400	/* Max 4 chips per floor on DiskOnChip 2000 */
    401	doc->chips_per_floor = 4;
    402
    403	/* Find out what the first chip is */
    404	mfrid = doc200x_ident_chip(mtd, 0);
    405
    406	/* Find how many chips in each floor. */
    407	for (i = 1; i < 4; i++) {
    408		if (doc200x_ident_chip(mtd, i) != mfrid)
    409			break;
    410	}
    411	doc->chips_per_floor = i;
    412	pr_debug("Detected %d chips per floor.\n", i);
    413}
    414
    415static void doc2001_write_byte(struct nand_chip *this, u_char datum)
    416{
    417	struct doc_priv *doc = nand_get_controller_data(this);
    418	void __iomem *docptr = doc->virtadr;
    419
    420	WriteDOC(datum, docptr, CDSNSlowIO);
    421	WriteDOC(datum, docptr, Mil_CDSN_IO);
    422	WriteDOC(datum, docptr, WritePipeTerm);
    423}
    424
    425static void doc2001_writebuf(struct nand_chip *this, const u_char *buf, int len)
    426{
    427	struct doc_priv *doc = nand_get_controller_data(this);
    428	void __iomem *docptr = doc->virtadr;
    429	int i;
    430
    431	for (i = 0; i < len; i++)
    432		WriteDOC_(buf[i], docptr, DoC_Mil_CDSN_IO + i);
    433	/* Terminate write pipeline */
    434	WriteDOC(0x00, docptr, WritePipeTerm);
    435}
    436
    437static void doc2001_readbuf(struct nand_chip *this, u_char *buf, int len)
    438{
    439	struct doc_priv *doc = nand_get_controller_data(this);
    440	void __iomem *docptr = doc->virtadr;
    441	int i;
    442
    443	/* Start read pipeline */
    444	ReadDOC(docptr, ReadPipeInit);
    445
    446	for (i = 0; i < len - 1; i++)
    447		buf[i] = ReadDOC(docptr, Mil_CDSN_IO + (i & 0xff));
    448
    449	/* Terminate read pipeline */
    450	buf[i] = ReadDOC(docptr, LastDataRead);
    451}
    452
    453static void doc2001plus_writebuf(struct nand_chip *this, const u_char *buf, int len)
    454{
    455	struct doc_priv *doc = nand_get_controller_data(this);
    456	void __iomem *docptr = doc->virtadr;
    457	int i;
    458
    459	if (debug)
    460		printk("writebuf of %d bytes: ", len);
    461	for (i = 0; i < len; i++) {
    462		WriteDOC_(buf[i], docptr, DoC_Mil_CDSN_IO + i);
    463		if (debug && i < 16)
    464			printk("%02x ", buf[i]);
    465	}
    466	if (debug)
    467		printk("\n");
    468}
    469
    470static void doc2001plus_readbuf(struct nand_chip *this, u_char *buf, int len)
    471{
    472	struct doc_priv *doc = nand_get_controller_data(this);
    473	void __iomem *docptr = doc->virtadr;
    474	int i;
    475
    476	if (debug)
    477		printk("readbuf of %d bytes: ", len);
    478
    479	/* Start read pipeline */
    480	ReadDOC(docptr, Mplus_ReadPipeInit);
    481	ReadDOC(docptr, Mplus_ReadPipeInit);
    482
    483	for (i = 0; i < len - 2; i++) {
    484		buf[i] = ReadDOC(docptr, Mil_CDSN_IO);
    485		if (debug && i < 16)
    486			printk("%02x ", buf[i]);
    487	}
    488
    489	/* Terminate read pipeline */
    490	if (len >= 2) {
    491		buf[len - 2] = ReadDOC(docptr, Mplus_LastDataRead);
    492		if (debug && i < 16)
    493			printk("%02x ", buf[len - 2]);
    494	}
    495
    496	buf[len - 1] = ReadDOC(docptr, Mplus_LastDataRead);
    497	if (debug && i < 16)
    498		printk("%02x ", buf[len - 1]);
    499	if (debug)
    500		printk("\n");
    501}
    502
    503static void doc200x_write_control(struct doc_priv *doc, u8 value)
    504{
    505	WriteDOC(value, doc->virtadr, CDSNControl);
    506	/* 11.4.3 -- 4 NOPs after CSDNControl write */
    507	DoC_Delay(doc, 4);
    508}
    509
    510static void doc200x_exec_instr(struct nand_chip *this,
    511			       const struct nand_op_instr *instr)
    512{
    513	struct doc_priv *doc = nand_get_controller_data(this);
    514	unsigned int i;
    515
    516	switch (instr->type) {
    517	case NAND_OP_CMD_INSTR:
    518		doc200x_write_control(doc, CDSN_CTRL_CE | CDSN_CTRL_CLE);
    519		doc2000_write_byte(this, instr->ctx.cmd.opcode);
    520		break;
    521
    522	case NAND_OP_ADDR_INSTR:
    523		doc200x_write_control(doc, CDSN_CTRL_CE | CDSN_CTRL_ALE);
    524		for (i = 0; i < instr->ctx.addr.naddrs; i++) {
    525			u8 addr = instr->ctx.addr.addrs[i];
    526
    527			if (DoC_is_2000(doc))
    528				doc2000_write_byte(this, addr);
    529			else
    530				doc2001_write_byte(this, addr);
    531		}
    532		break;
    533
    534	case NAND_OP_DATA_IN_INSTR:
    535		doc200x_write_control(doc, CDSN_CTRL_CE);
    536		if (DoC_is_2000(doc))
    537			doc2000_readbuf(this, instr->ctx.data.buf.in,
    538					instr->ctx.data.len);
    539		else
    540			doc2001_readbuf(this, instr->ctx.data.buf.in,
    541					instr->ctx.data.len);
    542		break;
    543
    544	case NAND_OP_DATA_OUT_INSTR:
    545		doc200x_write_control(doc, CDSN_CTRL_CE);
    546		if (DoC_is_2000(doc))
    547			doc2000_writebuf(this, instr->ctx.data.buf.out,
    548					 instr->ctx.data.len);
    549		else
    550			doc2001_writebuf(this, instr->ctx.data.buf.out,
    551					 instr->ctx.data.len);
    552		break;
    553
    554	case NAND_OP_WAITRDY_INSTR:
    555		DoC_WaitReady(doc);
    556		break;
    557	}
    558
    559	if (instr->delay_ns)
    560		ndelay(instr->delay_ns);
    561}
    562
    563static int doc200x_exec_op(struct nand_chip *this,
    564			   const struct nand_operation *op,
    565			   bool check_only)
    566{
    567	struct doc_priv *doc = nand_get_controller_data(this);
    568	unsigned int i;
    569
    570	if (check_only)
    571		return true;
    572
    573	doc->curchip = op->cs % doc->chips_per_floor;
    574	doc->curfloor = op->cs / doc->chips_per_floor;
    575
    576	WriteDOC(doc->curfloor, doc->virtadr, FloorSelect);
    577	WriteDOC(doc->curchip, doc->virtadr, CDSNDeviceSelect);
    578
    579	/* Assert CE pin */
    580	doc200x_write_control(doc, CDSN_CTRL_CE);
    581
    582	for (i = 0; i < op->ninstrs; i++)
    583		doc200x_exec_instr(this, &op->instrs[i]);
    584
    585	/* De-assert CE pin */
    586	doc200x_write_control(doc, 0);
    587
    588	return 0;
    589}
    590
    591static void doc2001plus_write_pipe_term(struct doc_priv *doc)
    592{
    593	WriteDOC(0x00, doc->virtadr, Mplus_WritePipeTerm);
    594	WriteDOC(0x00, doc->virtadr, Mplus_WritePipeTerm);
    595}
    596
    597static void doc2001plus_exec_instr(struct nand_chip *this,
    598				   const struct nand_op_instr *instr)
    599{
    600	struct doc_priv *doc = nand_get_controller_data(this);
    601	unsigned int i;
    602
    603	switch (instr->type) {
    604	case NAND_OP_CMD_INSTR:
    605		WriteDOC(instr->ctx.cmd.opcode, doc->virtadr, Mplus_FlashCmd);
    606		doc2001plus_write_pipe_term(doc);
    607		break;
    608
    609	case NAND_OP_ADDR_INSTR:
    610		for (i = 0; i < instr->ctx.addr.naddrs; i++) {
    611			u8 addr = instr->ctx.addr.addrs[i];
    612
    613			WriteDOC(addr, doc->virtadr, Mplus_FlashAddress);
    614		}
    615		doc2001plus_write_pipe_term(doc);
    616		/* deassert ALE */
    617		WriteDOC(0, doc->virtadr, Mplus_FlashControl);
    618		break;
    619
    620	case NAND_OP_DATA_IN_INSTR:
    621		doc2001plus_readbuf(this, instr->ctx.data.buf.in,
    622				    instr->ctx.data.len);
    623		break;
    624	case NAND_OP_DATA_OUT_INSTR:
    625		doc2001plus_writebuf(this, instr->ctx.data.buf.out,
    626				     instr->ctx.data.len);
    627		doc2001plus_write_pipe_term(doc);
    628		break;
    629	case NAND_OP_WAITRDY_INSTR:
    630		DoC_WaitReady(doc);
    631		break;
    632	}
    633
    634	if (instr->delay_ns)
    635		ndelay(instr->delay_ns);
    636}
    637
    638static int doc2001plus_exec_op(struct nand_chip *this,
    639			       const struct nand_operation *op,
    640			       bool check_only)
    641{
    642	struct doc_priv *doc = nand_get_controller_data(this);
    643	unsigned int i;
    644
    645	if (check_only)
    646		return true;
    647
    648	doc->curchip = op->cs % doc->chips_per_floor;
    649	doc->curfloor = op->cs / doc->chips_per_floor;
    650
    651	/* Assert ChipEnable and deassert WriteProtect */
    652	WriteDOC(DOC_FLASH_CE, doc->virtadr, Mplus_FlashSelect);
    653
    654	for (i = 0; i < op->ninstrs; i++)
    655		doc2001plus_exec_instr(this, &op->instrs[i]);
    656
    657	/* De-assert ChipEnable */
    658	WriteDOC(0, doc->virtadr, Mplus_FlashSelect);
    659
    660	return 0;
    661}
    662
    663static void doc200x_enable_hwecc(struct nand_chip *this, int mode)
    664{
    665	struct doc_priv *doc = nand_get_controller_data(this);
    666	void __iomem *docptr = doc->virtadr;
    667
    668	/* Prime the ECC engine */
    669	switch (mode) {
    670	case NAND_ECC_READ:
    671		WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
    672		WriteDOC(DOC_ECC_EN, docptr, ECCConf);
    673		break;
    674	case NAND_ECC_WRITE:
    675		WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
    676		WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, ECCConf);
    677		break;
    678	}
    679}
    680
    681static void doc2001plus_enable_hwecc(struct nand_chip *this, int mode)
    682{
    683	struct doc_priv *doc = nand_get_controller_data(this);
    684	void __iomem *docptr = doc->virtadr;
    685
    686	/* Prime the ECC engine */
    687	switch (mode) {
    688	case NAND_ECC_READ:
    689		WriteDOC(DOC_ECC_RESET, docptr, Mplus_ECCConf);
    690		WriteDOC(DOC_ECC_EN, docptr, Mplus_ECCConf);
    691		break;
    692	case NAND_ECC_WRITE:
    693		WriteDOC(DOC_ECC_RESET, docptr, Mplus_ECCConf);
    694		WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, Mplus_ECCConf);
    695		break;
    696	}
    697}
    698
    699/* This code is only called on write */
    700static int doc200x_calculate_ecc(struct nand_chip *this, const u_char *dat,
    701				 unsigned char *ecc_code)
    702{
    703	struct doc_priv *doc = nand_get_controller_data(this);
    704	void __iomem *docptr = doc->virtadr;
    705	int i;
    706	int __always_unused emptymatch = 1;
    707
    708	/* flush the pipeline */
    709	if (DoC_is_2000(doc)) {
    710		WriteDOC(doc->CDSNControl & ~CDSN_CTRL_FLASH_IO, docptr, CDSNControl);
    711		WriteDOC(0, docptr, 2k_CDSN_IO);
    712		WriteDOC(0, docptr, 2k_CDSN_IO);
    713		WriteDOC(0, docptr, 2k_CDSN_IO);
    714		WriteDOC(doc->CDSNControl, docptr, CDSNControl);
    715	} else if (DoC_is_MillenniumPlus(doc)) {
    716		WriteDOC(0, docptr, Mplus_NOP);
    717		WriteDOC(0, docptr, Mplus_NOP);
    718		WriteDOC(0, docptr, Mplus_NOP);
    719	} else {
    720		WriteDOC(0, docptr, NOP);
    721		WriteDOC(0, docptr, NOP);
    722		WriteDOC(0, docptr, NOP);
    723	}
    724
    725	for (i = 0; i < 6; i++) {
    726		if (DoC_is_MillenniumPlus(doc))
    727			ecc_code[i] = ReadDOC_(docptr, DoC_Mplus_ECCSyndrome0 + i);
    728		else
    729			ecc_code[i] = ReadDOC_(docptr, DoC_ECCSyndrome0 + i);
    730		if (ecc_code[i] != empty_write_ecc[i])
    731			emptymatch = 0;
    732	}
    733	if (DoC_is_MillenniumPlus(doc))
    734		WriteDOC(DOC_ECC_DIS, docptr, Mplus_ECCConf);
    735	else
    736		WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
    737#if 0
    738	/* If emptymatch=1, we might have an all-0xff data buffer.  Check. */
    739	if (emptymatch) {
    740		/* Note: this somewhat expensive test should not be triggered
    741		   often.  It could be optimized away by examining the data in
    742		   the writebuf routine, and remembering the result. */
    743		for (i = 0; i < 512; i++) {
    744			if (dat[i] == 0xff)
    745				continue;
    746			emptymatch = 0;
    747			break;
    748		}
    749	}
    750	/* If emptymatch still =1, we do have an all-0xff data buffer.
    751	   Return all-0xff ecc value instead of the computed one, so
    752	   it'll look just like a freshly-erased page. */
    753	if (emptymatch)
    754		memset(ecc_code, 0xff, 6);
    755#endif
    756	return 0;
    757}
    758
    759static int doc200x_correct_data(struct nand_chip *this, u_char *dat,
    760				u_char *read_ecc, u_char *isnull)
    761{
    762	int i, ret = 0;
    763	struct doc_priv *doc = nand_get_controller_data(this);
    764	void __iomem *docptr = doc->virtadr;
    765	uint8_t calc_ecc[6];
    766	volatile u_char dummy;
    767
    768	/* flush the pipeline */
    769	if (DoC_is_2000(doc)) {
    770		dummy = ReadDOC(docptr, 2k_ECCStatus);
    771		dummy = ReadDOC(docptr, 2k_ECCStatus);
    772		dummy = ReadDOC(docptr, 2k_ECCStatus);
    773	} else if (DoC_is_MillenniumPlus(doc)) {
    774		dummy = ReadDOC(docptr, Mplus_ECCConf);
    775		dummy = ReadDOC(docptr, Mplus_ECCConf);
    776		dummy = ReadDOC(docptr, Mplus_ECCConf);
    777	} else {
    778		dummy = ReadDOC(docptr, ECCConf);
    779		dummy = ReadDOC(docptr, ECCConf);
    780		dummy = ReadDOC(docptr, ECCConf);
    781	}
    782
    783	/* Error occurred ? */
    784	if (dummy & 0x80) {
    785		for (i = 0; i < 6; i++) {
    786			if (DoC_is_MillenniumPlus(doc))
    787				calc_ecc[i] = ReadDOC_(docptr, DoC_Mplus_ECCSyndrome0 + i);
    788			else
    789				calc_ecc[i] = ReadDOC_(docptr, DoC_ECCSyndrome0 + i);
    790		}
    791
    792		ret = doc_ecc_decode(doc->rs_decoder, dat, calc_ecc);
    793		if (ret > 0)
    794			pr_err("doc200x_correct_data corrected %d errors\n",
    795			       ret);
    796	}
    797	if (DoC_is_MillenniumPlus(doc))
    798		WriteDOC(DOC_ECC_DIS, docptr, Mplus_ECCConf);
    799	else
    800		WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
    801	if (no_ecc_failures && mtd_is_eccerr(ret)) {
    802		pr_err("suppressing ECC failure\n");
    803		ret = 0;
    804	}
    805	return ret;
    806}
    807
    808//u_char mydatabuf[528];
    809
    810static int doc200x_ooblayout_ecc(struct mtd_info *mtd, int section,
    811				 struct mtd_oob_region *oobregion)
    812{
    813	if (section)
    814		return -ERANGE;
    815
    816	oobregion->offset = 0;
    817	oobregion->length = 6;
    818
    819	return 0;
    820}
    821
    822static int doc200x_ooblayout_free(struct mtd_info *mtd, int section,
    823				  struct mtd_oob_region *oobregion)
    824{
    825	if (section > 1)
    826		return -ERANGE;
    827
    828	/*
    829	 * The strange out-of-order free bytes definition is a (possibly
    830	 * unneeded) attempt to retain compatibility.  It used to read:
    831	 *	.oobfree = { {8, 8} }
    832	 * Since that leaves two bytes unusable, it was changed.  But the
    833	 * following scheme might affect existing jffs2 installs by moving the
    834	 * cleanmarker:
    835	 *	.oobfree = { {6, 10} }
    836	 * jffs2 seems to handle the above gracefully, but the current scheme
    837	 * seems safer. The only problem with it is that any code retrieving
    838	 * free bytes position must be able to handle out-of-order segments.
    839	 */
    840	if (!section) {
    841		oobregion->offset = 8;
    842		oobregion->length = 8;
    843	} else {
    844		oobregion->offset = 6;
    845		oobregion->length = 2;
    846	}
    847
    848	return 0;
    849}
    850
    851static const struct mtd_ooblayout_ops doc200x_ooblayout_ops = {
    852	.ecc = doc200x_ooblayout_ecc,
    853	.free = doc200x_ooblayout_free,
    854};
    855
    856/* Find the (I)NFTL Media Header, and optionally also the mirror media header.
    857   On successful return, buf will contain a copy of the media header for
    858   further processing.  id is the string to scan for, and will presumably be
    859   either "ANAND" or "BNAND".  If findmirror=1, also look for the mirror media
    860   header.  The page #s of the found media headers are placed in mh0_page and
    861   mh1_page in the DOC private structure. */
    862static int __init find_media_headers(struct mtd_info *mtd, u_char *buf, const char *id, int findmirror)
    863{
    864	struct nand_chip *this = mtd_to_nand(mtd);
    865	struct doc_priv *doc = nand_get_controller_data(this);
    866	unsigned offs;
    867	int ret;
    868	size_t retlen;
    869
    870	for (offs = 0; offs < mtd->size; offs += mtd->erasesize) {
    871		ret = mtd_read(mtd, offs, mtd->writesize, &retlen, buf);
    872		if (retlen != mtd->writesize)
    873			continue;
    874		if (ret) {
    875			pr_warn("ECC error scanning DOC at 0x%x\n", offs);
    876		}
    877		if (memcmp(buf, id, 6))
    878			continue;
    879		pr_info("Found DiskOnChip %s Media Header at 0x%x\n", id, offs);
    880		if (doc->mh0_page == -1) {
    881			doc->mh0_page = offs >> this->page_shift;
    882			if (!findmirror)
    883				return 1;
    884			continue;
    885		}
    886		doc->mh1_page = offs >> this->page_shift;
    887		return 2;
    888	}
    889	if (doc->mh0_page == -1) {
    890		pr_warn("DiskOnChip %s Media Header not found.\n", id);
    891		return 0;
    892	}
    893	/* Only one mediaheader was found.  We want buf to contain a
    894	   mediaheader on return, so we'll have to re-read the one we found. */
    895	offs = doc->mh0_page << this->page_shift;
    896	ret = mtd_read(mtd, offs, mtd->writesize, &retlen, buf);
    897	if (retlen != mtd->writesize) {
    898		/* Insanity.  Give up. */
    899		pr_err("Read DiskOnChip Media Header once, but can't reread it???\n");
    900		return 0;
    901	}
    902	return 1;
    903}
    904
    905static inline int __init nftl_partscan(struct mtd_info *mtd, struct mtd_partition *parts)
    906{
    907	struct nand_chip *this = mtd_to_nand(mtd);
    908	struct doc_priv *doc = nand_get_controller_data(this);
    909	struct nand_memory_organization *memorg;
    910	int ret = 0;
    911	u_char *buf;
    912	struct NFTLMediaHeader *mh;
    913	const unsigned psize = 1 << this->page_shift;
    914	int numparts = 0;
    915	unsigned blocks, maxblocks;
    916	int offs, numheaders;
    917
    918	memorg = nanddev_get_memorg(&this->base);
    919
    920	buf = kmalloc(mtd->writesize, GFP_KERNEL);
    921	if (!buf) {
    922		return 0;
    923	}
    924	if (!(numheaders = find_media_headers(mtd, buf, "ANAND", 1)))
    925		goto out;
    926	mh = (struct NFTLMediaHeader *)buf;
    927
    928	le16_to_cpus(&mh->NumEraseUnits);
    929	le16_to_cpus(&mh->FirstPhysicalEUN);
    930	le32_to_cpus(&mh->FormattedSize);
    931
    932	pr_info("    DataOrgID        = %s\n"
    933		"    NumEraseUnits    = %d\n"
    934		"    FirstPhysicalEUN = %d\n"
    935		"    FormattedSize    = %d\n"
    936		"    UnitSizeFactor   = %d\n",
    937		mh->DataOrgID, mh->NumEraseUnits,
    938		mh->FirstPhysicalEUN, mh->FormattedSize,
    939		mh->UnitSizeFactor);
    940
    941	blocks = mtd->size >> this->phys_erase_shift;
    942	maxblocks = min(32768U, mtd->erasesize - psize);
    943
    944	if (mh->UnitSizeFactor == 0x00) {
    945		/* Auto-determine UnitSizeFactor.  The constraints are:
    946		   - There can be at most 32768 virtual blocks.
    947		   - There can be at most (virtual block size - page size)
    948		   virtual blocks (because MediaHeader+BBT must fit in 1).
    949		 */
    950		mh->UnitSizeFactor = 0xff;
    951		while (blocks > maxblocks) {
    952			blocks >>= 1;
    953			maxblocks = min(32768U, (maxblocks << 1) + psize);
    954			mh->UnitSizeFactor--;
    955		}
    956		pr_warn("UnitSizeFactor=0x00 detected.  Correct value is assumed to be 0x%02x.\n", mh->UnitSizeFactor);
    957	}
    958
    959	/* NOTE: The lines below modify internal variables of the NAND and MTD
    960	   layers; variables with have already been configured by nand_scan.
    961	   Unfortunately, we didn't know before this point what these values
    962	   should be.  Thus, this code is somewhat dependent on the exact
    963	   implementation of the NAND layer.  */
    964	if (mh->UnitSizeFactor != 0xff) {
    965		this->bbt_erase_shift += (0xff - mh->UnitSizeFactor);
    966		memorg->pages_per_eraseblock <<= (0xff - mh->UnitSizeFactor);
    967		mtd->erasesize <<= (0xff - mh->UnitSizeFactor);
    968		pr_info("Setting virtual erase size to %d\n", mtd->erasesize);
    969		blocks = mtd->size >> this->bbt_erase_shift;
    970		maxblocks = min(32768U, mtd->erasesize - psize);
    971	}
    972
    973	if (blocks > maxblocks) {
    974		pr_err("UnitSizeFactor of 0x%02x is inconsistent with device size.  Aborting.\n", mh->UnitSizeFactor);
    975		goto out;
    976	}
    977
    978	/* Skip past the media headers. */
    979	offs = max(doc->mh0_page, doc->mh1_page);
    980	offs <<= this->page_shift;
    981	offs += mtd->erasesize;
    982
    983	if (show_firmware_partition == 1) {
    984		parts[0].name = " DiskOnChip Firmware / Media Header partition";
    985		parts[0].offset = 0;
    986		parts[0].size = offs;
    987		numparts = 1;
    988	}
    989
    990	parts[numparts].name = " DiskOnChip BDTL partition";
    991	parts[numparts].offset = offs;
    992	parts[numparts].size = (mh->NumEraseUnits - numheaders) << this->bbt_erase_shift;
    993
    994	offs += parts[numparts].size;
    995	numparts++;
    996
    997	if (offs < mtd->size) {
    998		parts[numparts].name = " DiskOnChip Remainder partition";
    999		parts[numparts].offset = offs;
   1000		parts[numparts].size = mtd->size - offs;
   1001		numparts++;
   1002	}
   1003
   1004	ret = numparts;
   1005 out:
   1006	kfree(buf);
   1007	return ret;
   1008}
   1009
   1010/* This is a stripped-down copy of the code in inftlmount.c */
   1011static inline int __init inftl_partscan(struct mtd_info *mtd, struct mtd_partition *parts)
   1012{
   1013	struct nand_chip *this = mtd_to_nand(mtd);
   1014	struct doc_priv *doc = nand_get_controller_data(this);
   1015	int ret = 0;
   1016	u_char *buf;
   1017	struct INFTLMediaHeader *mh;
   1018	struct INFTLPartition *ip;
   1019	int numparts = 0;
   1020	int blocks;
   1021	int vshift, lastvunit = 0;
   1022	int i;
   1023	int end = mtd->size;
   1024
   1025	if (inftl_bbt_write)
   1026		end -= (INFTL_BBT_RESERVED_BLOCKS << this->phys_erase_shift);
   1027
   1028	buf = kmalloc(mtd->writesize, GFP_KERNEL);
   1029	if (!buf) {
   1030		return 0;
   1031	}
   1032
   1033	if (!find_media_headers(mtd, buf, "BNAND", 0))
   1034		goto out;
   1035	doc->mh1_page = doc->mh0_page + (4096 >> this->page_shift);
   1036	mh = (struct INFTLMediaHeader *)buf;
   1037
   1038	le32_to_cpus(&mh->NoOfBootImageBlocks);
   1039	le32_to_cpus(&mh->NoOfBinaryPartitions);
   1040	le32_to_cpus(&mh->NoOfBDTLPartitions);
   1041	le32_to_cpus(&mh->BlockMultiplierBits);
   1042	le32_to_cpus(&mh->FormatFlags);
   1043	le32_to_cpus(&mh->PercentUsed);
   1044
   1045	pr_info("    bootRecordID          = %s\n"
   1046		"    NoOfBootImageBlocks   = %d\n"
   1047		"    NoOfBinaryPartitions  = %d\n"
   1048		"    NoOfBDTLPartitions    = %d\n"
   1049		"    BlockMultiplierBits   = %d\n"
   1050		"    FormatFlgs            = %d\n"
   1051		"    OsakVersion           = %d.%d.%d.%d\n"
   1052		"    PercentUsed           = %d\n",
   1053		mh->bootRecordID, mh->NoOfBootImageBlocks,
   1054		mh->NoOfBinaryPartitions,
   1055		mh->NoOfBDTLPartitions,
   1056		mh->BlockMultiplierBits, mh->FormatFlags,
   1057		((unsigned char *) &mh->OsakVersion)[0] & 0xf,
   1058		((unsigned char *) &mh->OsakVersion)[1] & 0xf,
   1059		((unsigned char *) &mh->OsakVersion)[2] & 0xf,
   1060		((unsigned char *) &mh->OsakVersion)[3] & 0xf,
   1061		mh->PercentUsed);
   1062
   1063	vshift = this->phys_erase_shift + mh->BlockMultiplierBits;
   1064
   1065	blocks = mtd->size >> vshift;
   1066	if (blocks > 32768) {
   1067		pr_err("BlockMultiplierBits=%d is inconsistent with device size.  Aborting.\n", mh->BlockMultiplierBits);
   1068		goto out;
   1069	}
   1070
   1071	blocks = doc->chips_per_floor << (this->chip_shift - this->phys_erase_shift);
   1072	if (inftl_bbt_write && (blocks > mtd->erasesize)) {
   1073		pr_err("Writeable BBTs spanning more than one erase block are not yet supported.  FIX ME!\n");
   1074		goto out;
   1075	}
   1076
   1077	/* Scan the partitions */
   1078	for (i = 0; (i < 4); i++) {
   1079		ip = &(mh->Partitions[i]);
   1080		le32_to_cpus(&ip->virtualUnits);
   1081		le32_to_cpus(&ip->firstUnit);
   1082		le32_to_cpus(&ip->lastUnit);
   1083		le32_to_cpus(&ip->flags);
   1084		le32_to_cpus(&ip->spareUnits);
   1085		le32_to_cpus(&ip->Reserved0);
   1086
   1087		pr_info("    PARTITION[%d] ->\n"
   1088			"        virtualUnits    = %d\n"
   1089			"        firstUnit       = %d\n"
   1090			"        lastUnit        = %d\n"
   1091			"        flags           = 0x%x\n"
   1092			"        spareUnits      = %d\n",
   1093			i, ip->virtualUnits, ip->firstUnit,
   1094			ip->lastUnit, ip->flags,
   1095			ip->spareUnits);
   1096
   1097		if ((show_firmware_partition == 1) &&
   1098		    (i == 0) && (ip->firstUnit > 0)) {
   1099			parts[0].name = " DiskOnChip IPL / Media Header partition";
   1100			parts[0].offset = 0;
   1101			parts[0].size = mtd->erasesize * ip->firstUnit;
   1102			numparts = 1;
   1103		}
   1104
   1105		if (ip->flags & INFTL_BINARY)
   1106			parts[numparts].name = " DiskOnChip BDK partition";
   1107		else
   1108			parts[numparts].name = " DiskOnChip BDTL partition";
   1109		parts[numparts].offset = ip->firstUnit << vshift;
   1110		parts[numparts].size = (1 + ip->lastUnit - ip->firstUnit) << vshift;
   1111		numparts++;
   1112		if (ip->lastUnit > lastvunit)
   1113			lastvunit = ip->lastUnit;
   1114		if (ip->flags & INFTL_LAST)
   1115			break;
   1116	}
   1117	lastvunit++;
   1118	if ((lastvunit << vshift) < end) {
   1119		parts[numparts].name = " DiskOnChip Remainder partition";
   1120		parts[numparts].offset = lastvunit << vshift;
   1121		parts[numparts].size = end - parts[numparts].offset;
   1122		numparts++;
   1123	}
   1124	ret = numparts;
   1125 out:
   1126	kfree(buf);
   1127	return ret;
   1128}
   1129
   1130static int __init nftl_scan_bbt(struct mtd_info *mtd)
   1131{
   1132	int ret, numparts;
   1133	struct nand_chip *this = mtd_to_nand(mtd);
   1134	struct doc_priv *doc = nand_get_controller_data(this);
   1135	struct mtd_partition parts[2];
   1136
   1137	memset((char *)parts, 0, sizeof(parts));
   1138	/* On NFTL, we have to find the media headers before we can read the
   1139	   BBTs, since they're stored in the media header eraseblocks. */
   1140	numparts = nftl_partscan(mtd, parts);
   1141	if (!numparts)
   1142		return -EIO;
   1143	this->bbt_td->options = NAND_BBT_ABSPAGE | NAND_BBT_8BIT |
   1144				NAND_BBT_SAVECONTENT | NAND_BBT_WRITE |
   1145				NAND_BBT_VERSION;
   1146	this->bbt_td->veroffs = 7;
   1147	this->bbt_td->pages[0] = doc->mh0_page + 1;
   1148	if (doc->mh1_page != -1) {
   1149		this->bbt_md->options = NAND_BBT_ABSPAGE | NAND_BBT_8BIT |
   1150					NAND_BBT_SAVECONTENT | NAND_BBT_WRITE |
   1151					NAND_BBT_VERSION;
   1152		this->bbt_md->veroffs = 7;
   1153		this->bbt_md->pages[0] = doc->mh1_page + 1;
   1154	} else {
   1155		this->bbt_md = NULL;
   1156	}
   1157
   1158	ret = nand_create_bbt(this);
   1159	if (ret)
   1160		return ret;
   1161
   1162	return mtd_device_register(mtd, parts, no_autopart ? 0 : numparts);
   1163}
   1164
   1165static int __init inftl_scan_bbt(struct mtd_info *mtd)
   1166{
   1167	int ret, numparts;
   1168	struct nand_chip *this = mtd_to_nand(mtd);
   1169	struct doc_priv *doc = nand_get_controller_data(this);
   1170	struct mtd_partition parts[5];
   1171
   1172	if (nanddev_ntargets(&this->base) > doc->chips_per_floor) {
   1173		pr_err("Multi-floor INFTL devices not yet supported.\n");
   1174		return -EIO;
   1175	}
   1176
   1177	if (DoC_is_MillenniumPlus(doc)) {
   1178		this->bbt_td->options = NAND_BBT_2BIT | NAND_BBT_ABSPAGE;
   1179		if (inftl_bbt_write)
   1180			this->bbt_td->options |= NAND_BBT_WRITE;
   1181		this->bbt_td->pages[0] = 2;
   1182		this->bbt_md = NULL;
   1183	} else {
   1184		this->bbt_td->options = NAND_BBT_LASTBLOCK | NAND_BBT_8BIT | NAND_BBT_VERSION;
   1185		if (inftl_bbt_write)
   1186			this->bbt_td->options |= NAND_BBT_WRITE;
   1187		this->bbt_td->offs = 8;
   1188		this->bbt_td->len = 8;
   1189		this->bbt_td->veroffs = 7;
   1190		this->bbt_td->maxblocks = INFTL_BBT_RESERVED_BLOCKS;
   1191		this->bbt_td->reserved_block_code = 0x01;
   1192		this->bbt_td->pattern = "MSYS_BBT";
   1193
   1194		this->bbt_md->options = NAND_BBT_LASTBLOCK | NAND_BBT_8BIT | NAND_BBT_VERSION;
   1195		if (inftl_bbt_write)
   1196			this->bbt_md->options |= NAND_BBT_WRITE;
   1197		this->bbt_md->offs = 8;
   1198		this->bbt_md->len = 8;
   1199		this->bbt_md->veroffs = 7;
   1200		this->bbt_md->maxblocks = INFTL_BBT_RESERVED_BLOCKS;
   1201		this->bbt_md->reserved_block_code = 0x01;
   1202		this->bbt_md->pattern = "TBB_SYSM";
   1203	}
   1204
   1205	ret = nand_create_bbt(this);
   1206	if (ret)
   1207		return ret;
   1208
   1209	memset((char *)parts, 0, sizeof(parts));
   1210	numparts = inftl_partscan(mtd, parts);
   1211	/* At least for now, require the INFTL Media Header.  We could probably
   1212	   do without it for non-INFTL use, since all it gives us is
   1213	   autopartitioning, but I want to give it more thought. */
   1214	if (!numparts)
   1215		return -EIO;
   1216	return mtd_device_register(mtd, parts, no_autopart ? 0 : numparts);
   1217}
   1218
   1219static inline int __init doc2000_init(struct mtd_info *mtd)
   1220{
   1221	struct nand_chip *this = mtd_to_nand(mtd);
   1222	struct doc_priv *doc = nand_get_controller_data(this);
   1223
   1224	doc->late_init = nftl_scan_bbt;
   1225
   1226	doc->CDSNControl = CDSN_CTRL_FLASH_IO | CDSN_CTRL_ECC_IO;
   1227	doc2000_count_chips(mtd);
   1228	mtd->name = "DiskOnChip 2000 (NFTL Model)";
   1229	return (4 * doc->chips_per_floor);
   1230}
   1231
   1232static inline int __init doc2001_init(struct mtd_info *mtd)
   1233{
   1234	struct nand_chip *this = mtd_to_nand(mtd);
   1235	struct doc_priv *doc = nand_get_controller_data(this);
   1236
   1237	ReadDOC(doc->virtadr, ChipID);
   1238	ReadDOC(doc->virtadr, ChipID);
   1239	ReadDOC(doc->virtadr, ChipID);
   1240	if (ReadDOC(doc->virtadr, ChipID) != DOC_ChipID_DocMil) {
   1241		/* It's not a Millennium; it's one of the newer
   1242		   DiskOnChip 2000 units with a similar ASIC.
   1243		   Treat it like a Millennium, except that it
   1244		   can have multiple chips. */
   1245		doc2000_count_chips(mtd);
   1246		mtd->name = "DiskOnChip 2000 (INFTL Model)";
   1247		doc->late_init = inftl_scan_bbt;
   1248		return (4 * doc->chips_per_floor);
   1249	} else {
   1250		/* Bog-standard Millennium */
   1251		doc->chips_per_floor = 1;
   1252		mtd->name = "DiskOnChip Millennium";
   1253		doc->late_init = nftl_scan_bbt;
   1254		return 1;
   1255	}
   1256}
   1257
   1258static inline int __init doc2001plus_init(struct mtd_info *mtd)
   1259{
   1260	struct nand_chip *this = mtd_to_nand(mtd);
   1261	struct doc_priv *doc = nand_get_controller_data(this);
   1262
   1263	doc->late_init = inftl_scan_bbt;
   1264	this->ecc.hwctl = doc2001plus_enable_hwecc;
   1265
   1266	doc->chips_per_floor = 1;
   1267	mtd->name = "DiskOnChip Millennium Plus";
   1268
   1269	return 1;
   1270}
   1271
   1272static int doc200x_attach_chip(struct nand_chip *chip)
   1273{
   1274	if (chip->ecc.engine_type != NAND_ECC_ENGINE_TYPE_ON_HOST)
   1275		return 0;
   1276
   1277	chip->ecc.placement = NAND_ECC_PLACEMENT_INTERLEAVED;
   1278	chip->ecc.size = 512;
   1279	chip->ecc.bytes = 6;
   1280	chip->ecc.strength = 2;
   1281	chip->ecc.options = NAND_ECC_GENERIC_ERASED_CHECK;
   1282	chip->ecc.hwctl = doc200x_enable_hwecc;
   1283	chip->ecc.calculate = doc200x_calculate_ecc;
   1284	chip->ecc.correct = doc200x_correct_data;
   1285
   1286	return 0;
   1287}
   1288
   1289static const struct nand_controller_ops doc200x_ops = {
   1290	.exec_op = doc200x_exec_op,
   1291	.attach_chip = doc200x_attach_chip,
   1292};
   1293
   1294static const struct nand_controller_ops doc2001plus_ops = {
   1295	.exec_op = doc2001plus_exec_op,
   1296	.attach_chip = doc200x_attach_chip,
   1297};
   1298
   1299static int __init doc_probe(unsigned long physadr)
   1300{
   1301	struct nand_chip *nand = NULL;
   1302	struct doc_priv *doc = NULL;
   1303	unsigned char ChipID;
   1304	struct mtd_info *mtd;
   1305	void __iomem *virtadr;
   1306	unsigned char save_control;
   1307	unsigned char tmp, tmpb, tmpc;
   1308	int reg, len, numchips;
   1309	int ret = 0;
   1310
   1311	if (!request_mem_region(physadr, DOC_IOREMAP_LEN, "DiskOnChip"))
   1312		return -EBUSY;
   1313	virtadr = ioremap(physadr, DOC_IOREMAP_LEN);
   1314	if (!virtadr) {
   1315		pr_err("Diskonchip ioremap failed: 0x%x bytes at 0x%lx\n",
   1316		       DOC_IOREMAP_LEN, physadr);
   1317		ret = -EIO;
   1318		goto error_ioremap;
   1319	}
   1320
   1321	/* It's not possible to cleanly detect the DiskOnChip - the
   1322	 * bootup procedure will put the device into reset mode, and
   1323	 * it's not possible to talk to it without actually writing
   1324	 * to the DOCControl register. So we store the current contents
   1325	 * of the DOCControl register's location, in case we later decide
   1326	 * that it's not a DiskOnChip, and want to put it back how we
   1327	 * found it.
   1328	 */
   1329	save_control = ReadDOC(virtadr, DOCControl);
   1330
   1331	/* Reset the DiskOnChip ASIC */
   1332	WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET, virtadr, DOCControl);
   1333	WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET, virtadr, DOCControl);
   1334
   1335	/* Enable the DiskOnChip ASIC */
   1336	WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL, virtadr, DOCControl);
   1337	WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL, virtadr, DOCControl);
   1338
   1339	ChipID = ReadDOC(virtadr, ChipID);
   1340
   1341	switch (ChipID) {
   1342	case DOC_ChipID_Doc2k:
   1343		reg = DoC_2k_ECCStatus;
   1344		break;
   1345	case DOC_ChipID_DocMil:
   1346		reg = DoC_ECCConf;
   1347		break;
   1348	case DOC_ChipID_DocMilPlus16:
   1349	case DOC_ChipID_DocMilPlus32:
   1350	case 0:
   1351		/* Possible Millennium Plus, need to do more checks */
   1352		/* Possibly release from power down mode */
   1353		for (tmp = 0; (tmp < 4); tmp++)
   1354			ReadDOC(virtadr, Mplus_Power);
   1355
   1356		/* Reset the Millennium Plus ASIC */
   1357		tmp = DOC_MODE_RESET | DOC_MODE_MDWREN | DOC_MODE_RST_LAT | DOC_MODE_BDECT;
   1358		WriteDOC(tmp, virtadr, Mplus_DOCControl);
   1359		WriteDOC(~tmp, virtadr, Mplus_CtrlConfirm);
   1360
   1361		usleep_range(1000, 2000);
   1362		/* Enable the Millennium Plus ASIC */
   1363		tmp = DOC_MODE_NORMAL | DOC_MODE_MDWREN | DOC_MODE_RST_LAT | DOC_MODE_BDECT;
   1364		WriteDOC(tmp, virtadr, Mplus_DOCControl);
   1365		WriteDOC(~tmp, virtadr, Mplus_CtrlConfirm);
   1366		usleep_range(1000, 2000);
   1367
   1368		ChipID = ReadDOC(virtadr, ChipID);
   1369
   1370		switch (ChipID) {
   1371		case DOC_ChipID_DocMilPlus16:
   1372			reg = DoC_Mplus_Toggle;
   1373			break;
   1374		case DOC_ChipID_DocMilPlus32:
   1375			pr_err("DiskOnChip Millennium Plus 32MB is not supported, ignoring.\n");
   1376			fallthrough;
   1377		default:
   1378			ret = -ENODEV;
   1379			goto notfound;
   1380		}
   1381		break;
   1382
   1383	default:
   1384		ret = -ENODEV;
   1385		goto notfound;
   1386	}
   1387	/* Check the TOGGLE bit in the ECC register */
   1388	tmp = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
   1389	tmpb = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
   1390	tmpc = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
   1391	if ((tmp == tmpb) || (tmp != tmpc)) {
   1392		pr_warn("Possible DiskOnChip at 0x%lx failed TOGGLE test, dropping.\n", physadr);
   1393		ret = -ENODEV;
   1394		goto notfound;
   1395	}
   1396
   1397	for (mtd = doclist; mtd; mtd = doc->nextdoc) {
   1398		unsigned char oldval;
   1399		unsigned char newval;
   1400		nand = mtd_to_nand(mtd);
   1401		doc = nand_get_controller_data(nand);
   1402		/* Use the alias resolution register to determine if this is
   1403		   in fact the same DOC aliased to a new address.  If writes
   1404		   to one chip's alias resolution register change the value on
   1405		   the other chip, they're the same chip. */
   1406		if (ChipID == DOC_ChipID_DocMilPlus16) {
   1407			oldval = ReadDOC(doc->virtadr, Mplus_AliasResolution);
   1408			newval = ReadDOC(virtadr, Mplus_AliasResolution);
   1409		} else {
   1410			oldval = ReadDOC(doc->virtadr, AliasResolution);
   1411			newval = ReadDOC(virtadr, AliasResolution);
   1412		}
   1413		if (oldval != newval)
   1414			continue;
   1415		if (ChipID == DOC_ChipID_DocMilPlus16) {
   1416			WriteDOC(~newval, virtadr, Mplus_AliasResolution);
   1417			oldval = ReadDOC(doc->virtadr, Mplus_AliasResolution);
   1418			WriteDOC(newval, virtadr, Mplus_AliasResolution);	// restore it
   1419		} else {
   1420			WriteDOC(~newval, virtadr, AliasResolution);
   1421			oldval = ReadDOC(doc->virtadr, AliasResolution);
   1422			WriteDOC(newval, virtadr, AliasResolution);	// restore it
   1423		}
   1424		newval = ~newval;
   1425		if (oldval == newval) {
   1426			pr_debug("Found alias of DOC at 0x%lx to 0x%lx\n",
   1427				 doc->physadr, physadr);
   1428			goto notfound;
   1429		}
   1430	}
   1431
   1432	pr_notice("DiskOnChip found at 0x%lx\n", physadr);
   1433
   1434	len = sizeof(struct nand_chip) + sizeof(struct doc_priv) +
   1435	      (2 * sizeof(struct nand_bbt_descr));
   1436	nand = kzalloc(len, GFP_KERNEL);
   1437	if (!nand) {
   1438		ret = -ENOMEM;
   1439		goto fail;
   1440	}
   1441
   1442	/*
   1443	 * Allocate a RS codec instance
   1444	 *
   1445	 * Symbolsize is 10 (bits)
   1446	 * Primitve polynomial is x^10+x^3+1
   1447	 * First consecutive root is 510
   1448	 * Primitve element to generate roots = 1
   1449	 * Generator polinomial degree = 4
   1450	 */
   1451	doc = (struct doc_priv *) (nand + 1);
   1452	doc->rs_decoder = init_rs(10, 0x409, FCR, 1, NROOTS);
   1453	if (!doc->rs_decoder) {
   1454		pr_err("DiskOnChip: Could not create a RS codec\n");
   1455		ret = -ENOMEM;
   1456		goto fail;
   1457	}
   1458
   1459	nand_controller_init(&doc->base);
   1460	if (ChipID == DOC_ChipID_DocMilPlus16)
   1461		doc->base.ops = &doc2001plus_ops;
   1462	else
   1463		doc->base.ops = &doc200x_ops;
   1464
   1465	mtd			= nand_to_mtd(nand);
   1466	nand->bbt_td		= (struct nand_bbt_descr *) (doc + 1);
   1467	nand->bbt_md		= nand->bbt_td + 1;
   1468
   1469	mtd->owner		= THIS_MODULE;
   1470	mtd_set_ooblayout(mtd, &doc200x_ooblayout_ops);
   1471
   1472	nand->controller	= &doc->base;
   1473	nand_set_controller_data(nand, doc);
   1474	nand->bbt_options	= NAND_BBT_USE_FLASH;
   1475	/* Skip the automatic BBT scan so we can run it manually */
   1476	nand->options		|= NAND_SKIP_BBTSCAN | NAND_NO_BBM_QUIRK;
   1477
   1478	doc->physadr		= physadr;
   1479	doc->virtadr		= virtadr;
   1480	doc->ChipID		= ChipID;
   1481	doc->curfloor		= -1;
   1482	doc->curchip		= -1;
   1483	doc->mh0_page		= -1;
   1484	doc->mh1_page		= -1;
   1485	doc->nextdoc		= doclist;
   1486
   1487	if (ChipID == DOC_ChipID_Doc2k)
   1488		numchips = doc2000_init(mtd);
   1489	else if (ChipID == DOC_ChipID_DocMilPlus16)
   1490		numchips = doc2001plus_init(mtd);
   1491	else
   1492		numchips = doc2001_init(mtd);
   1493
   1494	if ((ret = nand_scan(nand, numchips)) || (ret = doc->late_init(mtd))) {
   1495		/* DBB note: i believe nand_cleanup is necessary here, as
   1496		   buffers may have been allocated in nand_base.  Check with
   1497		   Thomas. FIX ME! */
   1498		nand_cleanup(nand);
   1499		goto fail;
   1500	}
   1501
   1502	/* Success! */
   1503	doclist = mtd;
   1504	return 0;
   1505
   1506 notfound:
   1507	/* Put back the contents of the DOCControl register, in case it's not
   1508	   actually a DiskOnChip.  */
   1509	WriteDOC(save_control, virtadr, DOCControl);
   1510 fail:
   1511	if (doc)
   1512		free_rs(doc->rs_decoder);
   1513	kfree(nand);
   1514	iounmap(virtadr);
   1515
   1516error_ioremap:
   1517	release_mem_region(physadr, DOC_IOREMAP_LEN);
   1518
   1519	return ret;
   1520}
   1521
   1522static void release_nanddoc(void)
   1523{
   1524	struct mtd_info *mtd, *nextmtd;
   1525	struct nand_chip *nand;
   1526	struct doc_priv *doc;
   1527	int ret;
   1528
   1529	for (mtd = doclist; mtd; mtd = nextmtd) {
   1530		nand = mtd_to_nand(mtd);
   1531		doc = nand_get_controller_data(nand);
   1532
   1533		nextmtd = doc->nextdoc;
   1534		ret = mtd_device_unregister(mtd);
   1535		WARN_ON(ret);
   1536		nand_cleanup(nand);
   1537		iounmap(doc->virtadr);
   1538		release_mem_region(doc->physadr, DOC_IOREMAP_LEN);
   1539		free_rs(doc->rs_decoder);
   1540		kfree(nand);
   1541	}
   1542}
   1543
   1544static int __init init_nanddoc(void)
   1545{
   1546	int i, ret = 0;
   1547
   1548	if (doc_config_location) {
   1549		pr_info("Using configured DiskOnChip probe address 0x%lx\n",
   1550			doc_config_location);
   1551		ret = doc_probe(doc_config_location);
   1552		if (ret < 0)
   1553			return ret;
   1554	} else {
   1555		for (i = 0; (doc_locations[i] != 0xffffffff); i++) {
   1556			doc_probe(doc_locations[i]);
   1557		}
   1558	}
   1559	/* No banner message any more. Print a message if no DiskOnChip
   1560	   found, so the user knows we at least tried. */
   1561	if (!doclist) {
   1562		pr_info("No valid DiskOnChip devices found\n");
   1563		ret = -ENODEV;
   1564	}
   1565	return ret;
   1566}
   1567
   1568static void __exit cleanup_nanddoc(void)
   1569{
   1570	/* Cleanup the nand/DoC resources */
   1571	release_nanddoc();
   1572}
   1573
   1574module_init(init_nanddoc);
   1575module_exit(cleanup_nanddoc);
   1576
   1577MODULE_LICENSE("GPL");
   1578MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
   1579MODULE_DESCRIPTION("M-Systems DiskOnChip 2000, Millennium and Millennium Plus device driver");