Patchwork [v9,1/3] MTD : add the common code for GPMI-NAND controller driver

login
register
mail settings
Submitter Huang Shijie
Date Aug. 17, 2011, 11:50 a.m.
Message ID <1313581828-16625-2-git-send-email-b32955@freescale.com>
Download mbox | patch
Permalink /patch/110309/
State New
Headers show

Comments

Huang Shijie - Aug. 17, 2011, 11:50 a.m.
These files contain the common code for the GPMI-NAND driver.

Signed-off-by: Huang Shijie <b32955@freescale.com>
---
 drivers/mtd/nand/gpmi-nand/gpmi-nand.c | 1804 ++++++++++++++++++++++++++++++++
 drivers/mtd/nand/gpmi-nand/gpmi-nand.h |  377 +++++++
 2 files changed, 2181 insertions(+), 0 deletions(-)
 create mode 100644 drivers/mtd/nand/gpmi-nand/gpmi-nand.c
 create mode 100644 drivers/mtd/nand/gpmi-nand/gpmi-nand.h
Huang Shijie - Aug. 18, 2011, 5:55 a.m.
Hi Artem:
> +static int mil_pre_bbt_scan(struct gpmi_nand_data  *this)
> +{
> +	struct nand_chip *nand = &this->mil.nand;
> +	struct mtd_info *mtd = &this->mil.mtd;
> +	struct nand_ecclayout *layout = nand->ecc.layout;
> +	int error;
> +
> +	/*
> +	 *  fix the ECC layout before the scanning.
> +	 *  We will use all the (page + OOB).
> +	 */
> +	layout->eccbytes = 0;
> +	layout->oobavail = 0;
> +
> +	mtd->oobavail = mtd->oobsize;
Buggy?
It seems mtd->oobavail should be zero here.

thanks.


Huang Shijie
> +
> +	/* Set up swap block-mark, must be set before the mil_set_geometry() */
> +	if (GPMI_IS_MX23(this))
> +		this->swap_block_mark = false;
> +	else
> +		this->swap_block_mark = true;
> +
> +	/* Set up the medium geometry */
> +	error = mil_set_geometry(this);
> +	if (error)
> +		return error;
> +
> +	/* NAND boot init, depends on the mil_set_geometry(). */
> +	return nand_boot_init(this);
> +}
> +
> +static int gpmi_scan_bbt(struct mtd_info *mtd)
> +{
> +	struct nand_chip *nand = mtd->priv;
> +	struct gpmi_nand_data *this = nand->priv;
> +	int error;
> +
> +	/* Prepare for the BBT scan. */
> +	error = mil_pre_bbt_scan(this);
> +	if (error)
> +		return error;
> +
> +	/* use the default BBT implementation */
> +	return nand_default_bbt(mtd);
> +}
> +
Artem Bityutskiy - Aug. 20, 2011, 5:35 a.m.
1. You do not need to call parse_mtd_partitions() anymore - we re-worked
the partitions registration in l2-mtd-2.6.git:

http://git.infradead.org/users/dedekind/l2-mtd-2.6.git


> +static void show_bch_geometry(struct bch_geometry *geo)
> +{
> +	pr_info("---------------------------------------\n");
> +	pr_info("	BCH Geometry\n");
> +	pr_info("---------------------------------------\n");

I think these "---" only consume memory in .data. This is the kernel and
I think nice separators like this should be avoided.

> +	pr_info("ECC Algorithm          : %s\n", geo->ecc_algorithm);
> +	pr_info("ECC Strength           : %u\n", geo->ecc_strength);
> +	pr_info("Page Size in Bytes     : %u\n", geo->page_size_in_bytes);
> +	pr_info("Metadata Size in Bytes : %u\n", geo->metadata_size_in_bytes);
> +	pr_info("ECC Chunk Size in Bytes: %u\n", geo->ecc_chunk_size_in_bytes);
> +	pr_info("ECC Chunk Count        : %u\n", geo->ecc_chunk_count);
> +	pr_info("Payload Size in Bytes  : %u\n", geo->payload_size_in_bytes);
> +	pr_info("Auxiliary Size in Bytes: %u\n", geo->auxiliary_size_in_bytes);
> +	pr_info("Auxiliary Status Offset: %u\n", geo->auxiliary_status_offset);
> +	pr_info("Block Mark Byte Offset : %u\n", geo->block_mark_byte_offset);
> +	pr_info("Block Mark Bit Offset  : %u\n", geo->block_mark_bit_offset);
> +}

Isn't it too much info for normal users? Should this be pr_debug()
instead? There is another similar place in your code.

Artem.
Marek Vasut - Aug. 20, 2011, 11:43 a.m.
On Wednesday, August 17, 2011 01:50:26 PM Huang Shijie wrote:
> These files contain the common code for the GPMI-NAND driver.
> 
> Signed-off-by: Huang Shijie <b32955@freescale.com>
> ---
>  drivers/mtd/nand/gpmi-nand/gpmi-nand.c | 1804
> ++++++++++++++++++++++++++++++++ drivers/mtd/nand/gpmi-nand/gpmi-nand.h | 
> 377 +++++++
>  2 files changed, 2181 insertions(+), 0 deletions(-)
>  create mode 100644 drivers/mtd/nand/gpmi-nand/gpmi-nand.c
>  create mode 100644 drivers/mtd/nand/gpmi-nand/gpmi-nand.h
> 
> diff --git a/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
> b/drivers/mtd/nand/gpmi-nand/gpmi-nand.c new file mode 100644
> index 0000000..afeef48
> --- /dev/null
> +++ b/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
> @@ -0,0 +1,1804 @@
> +/*
> + * Freescale GPMI NAND Flash Driver
> + *
> + * Copyright (C) 2010-2011 Freescale Semiconductor, Inc.
> + * Copyright (C) 2008 Embedded Alley Solutions, Inc.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License along
> + * with this program; if not, write to the Free Software Foundation, Inc.,
> + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
> + */
> +#include "gpmi-nand.h"
> +
> +/* add our owner bbt descriptor */
> +static uint8_t scan_ff_pattern[] = { 0xff };
> +static struct nand_bbt_descr gpmi_bbt_descr = {
> +	.options	= 0,
> +	.offs		= 0,
> +	.len		= 1,
> +	.pattern	= scan_ff_pattern
> +};
> +
> +/* debug control */
> +int gpmi_debug;
> +module_param(gpmi_debug, int, S_IRUGO | S_IWUSR);
> +MODULE_PARM_DESC(gpmi_debug, "print out the debug infomation.");
> +
> +static irqreturn_t bch_irq(int irq, void *cookie)
> +{
> +	struct gpmi_nand_data *this = cookie;
> +
> +	gpmi_clear_bch(this);
> +	complete(&this->bch_done);
> +	return IRQ_HANDLED;
> +}
> +
> +/* calculate the ECC strength by hand */
> +static inline int get_ecc_strength(struct gpmi_nand_data *this)
> +{
> +	struct mtd_info	*mtd = &this->mil.mtd;
> +	int ecc_strength = 0;
> +
> +	switch (mtd->writesize) {
> +	case 2048:
> +		ecc_strength = 8;
> +		break;
> +	case 4096:
> +		switch (mtd->oobsize) {
> +		case 128:
> +			ecc_strength = 8;
> +			break;
> +		case 224:
> +		case 218:
> +			ecc_strength = 16;
> +			break;
> +		}
> +		break;
> +	case 8192:
> +		ecc_strength = 24;
> +		break;
> +	}
> +
> +	return ecc_strength;
> +}
> +
> +static inline int get_ecc_chunk_size(struct gpmi_nand_data *this)
> +{
> +	/* for historical reason */
> +	return 512;

Can't we just #define this? Or will there ever be something else possible here ? 
I thought this is the only possible behaviour on MXS.

> +}
> +
> +int common_nfc_set_geometry(struct gpmi_nand_data *this)
> +{
> +	struct bch_geometry *geo = &this->bch_geometry;
> +	struct mtd_info *mtd = &this->mil.mtd;
> +	unsigned int metadata_size;
> +	unsigned int status_size;
> +	unsigned int chunk_data_size_in_bits;
> +	unsigned int chunk_ecc_size_in_bits;
> +	unsigned int chunk_total_size_in_bits;
> +	unsigned int block_mark_chunk_number;
> +	unsigned int block_mark_chunk_bit_offset;
> +	unsigned int block_mark_bit_offset;
> +	int gf_len = 13;/* use GP13 by default */
> +
> +	/* We only support BCH now. */
> +	geo->ecc_algorithm = "BCH";
> +
> +	/*
> +	 * We always choose a metadata size of 10. Don't try to make sense of
> +	 * it -- this is really only for historical compatibility.
> +	 */

Historical compat or you mean "the chip was designed this way, see datasheet 
section x.y.z"? ;-)

> +	geo->metadata_size_in_bytes = 10;
> +
> +	/* ECC chunks */
> +	geo->ecc_chunk_size_in_bytes = get_ecc_chunk_size(this);
> +
> +	/*
> +	 * Compute the total number of ECC chunks in a page. This includes the
> +	 * slightly larger chunk at the beginning of the page, which contains
> +	 * both data and metadata.
> +	 */
> +	geo->ecc_chunk_count = mtd->writesize / geo->ecc_chunk_size_in_bytes;
> +
> +	/*
> +	 * We use the same ECC strength for all chunks, including the first one.
> +	 */
> +	geo->ecc_strength = get_ecc_strength(this);
> +	if (!geo->ecc_strength) {
> +		pr_info("Page size:%d, OOB:%d\n", mtd->writesize, mtd->oobsize);
> +		return -EINVAL;
> +	}
> +
> +	/* Compute the page size, include page and oob. */
> +	geo->page_size_in_bytes = mtd->writesize + mtd->oobsize;
> +	geo->payload_size_in_bytes = mtd->writesize;
> +
> +	/*
> +	 * In principle, computing the auxiliary buffer geometry is NFC
> +	 * version-specific. However, at this writing, all versions share the
> +	 * same model, so this code can also be shared.
> +	 *
> +	 * The auxiliary buffer contains the metadata and the ECC status. The
> +	 * metadata is padded to the nearest 32-bit boundary. The ECC status
> +	 * contains one byte for every ECC chunk, and is also padded to the
> +	 * nearest 32-bit boundary.
> +	 */
> +	metadata_size = ALIGN(geo->metadata_size_in_bytes, 4);
> +	status_size   = ALIGN(geo->ecc_chunk_count, 4);
> +
> +	geo->auxiliary_size_in_bytes = metadata_size + status_size;
> +	geo->auxiliary_status_offset = metadata_size;
> +
> +	/* Check if we're going to do block mark swapping. */
> +	if (!this->swap_block_mark)
> +		return 0;
> +
> +	/*
> +	 * If control arrives here, we're doing block mark swapping, so we need
> +	 * to compute the byte and bit offsets of the physical block mark within
> +	 * the ECC-based view of the page data. In principle, this isn't a
> +	 * difficult computation -- but it's very important and it's easy to get
> +	 * it wrong, so we do it carefully.
> +	 *
> +	 * Note that this calculation is simpler because we use the same ECC
> +	 * strength for all chunks, including the zero'th one, which contains
> +	 * the metadata. The calculation would be slightly more complicated
> +	 * otherwise.
> +	 *
> +	 * We start by computing the physical bit offset of the block mark. We
> +	 * then subtract the number of metadata and ECC bits appearing before
> +	 * the mark to arrive at its bit offset within the data alone.
> +	 */
> +
> +	/* Compute some important facts about chunk geometry. */
> +	chunk_data_size_in_bits = geo->ecc_chunk_size_in_bytes * 8;
> +	chunk_ecc_size_in_bits  = geo->ecc_strength * gf_len;
> +	chunk_total_size_in_bits = chunk_data_size_in_bits
> +					+ chunk_ecc_size_in_bits;
> +
> +	/* Compute the bit offset of the block mark within the physical page. */
> +	block_mark_bit_offset = mtd->writesize * 8;
> +
> +	/* Subtract the metadata bits. */
> +	block_mark_bit_offset -= geo->metadata_size_in_bytes * 8;
> +
> +	/*
> +	 * Compute the chunk number (starting at zero) in which the block mark
> +	 * appears.
> +	 */
> +	block_mark_chunk_number =
> +			block_mark_bit_offset / chunk_total_size_in_bits;
> +
> +	/*
> +	 * Compute the bit offset of the block mark within its chunk, and
> +	 * validate it.
> +	 */
> +	block_mark_chunk_bit_offset =
> +		block_mark_bit_offset -
> +			(block_mark_chunk_number * chunk_total_size_in_bits);
> +
> +	if (block_mark_chunk_bit_offset > chunk_data_size_in_bits) {
> +		/*
> +		 * If control arrives here, the block mark actually appears in
> +		 * the ECC bits of this chunk. This wont' work.
> +		 */
> +		pr_info("Unsupported page geometry : %u:%u\n",
> +				mtd->writesize, mtd->oobsize);
> +		return -EINVAL;
> +	}
> +
> +	/*
> +	 * Now that we know the chunk number in which the block mark appears,
> +	 * we can subtract all the ECC bits that appear before it.
> +	 */
> +	block_mark_bit_offset -=
> +			block_mark_chunk_number * chunk_ecc_size_in_bits;
> +
> +	/*
> +	 * We now know the absolute bit offset of the block mark within the
> +	 * ECC-based data. We can now compute the byte offset and the bit
> +	 * offset within the byte.
> +	 */
> +	geo->block_mark_byte_offset = block_mark_bit_offset / 8;
> +	geo->block_mark_bit_offset  = block_mark_bit_offset % 8;
> +
> +	return 0;
> +}
> +
> +struct dma_chan *get_dma_chan(struct gpmi_nand_data *this)
> +{
> +	int chip = this->mil.current_chip;
> +
> +	BUG_ON(chip < 0);
> +	return this->dma_chans[chip];
> +}
> +
> +/* Can we use the upper's buffer directly for DMA? */
> +void prepare_data_dma(struct gpmi_nand_data *this, enum dma_data_direction
> dr) +{
> +	struct mil *mil = &this->mil;
> +	struct scatterlist *sgl = &mil->data_sgl;

I still see the "MIL" present -- can't we just merge the library and this ?

> +	int ret;
> +
> +	mil->direct_dma_map_ok = true;
> +
> +	/* first try to map the upper buffer directly */
> +	sg_init_one(sgl, mil->upper_buf, mil->upper_len);
> +	ret = dma_map_sg(this->dev, sgl, 1, dr);
> +	if (ret == 0) {
> +		/* We have to use our own DMA buffer. */
> +		sg_init_one(sgl, mil->data_buffer_dma, PAGE_SIZE);
> +
> +		if (dr == DMA_TO_DEVICE)
> +			memcpy(mil->data_buffer_dma, mil->upper_buf,
> +				mil->upper_len);
> +
> +		ret = dma_map_sg(this->dev, sgl, 1, dr);
> +		BUG_ON(ret == 0);
> +
> +		mil->direct_dma_map_ok = false;
> +	}
> +}
> +
> +/* This will be called after the DMA operation is finished. */
> +static void dma_irq_callback(void *param)
> +{
> +	struct gpmi_nand_data *this = param;
> +	struct mil *mil = &this->mil;
> +	struct completion *dma_c = &this->dma_done;
> +
> +	complete(dma_c);
> +
> +	switch (this->dma_type) {
> +	case DMA_FOR_COMMAND:
> +		dma_unmap_sg(this->dev, &mil->cmd_sgl, 1, DMA_TO_DEVICE);
> +		break;
> +
> +	case DMA_FOR_READ_DATA:
> +		dma_unmap_sg(this->dev, &mil->data_sgl, 1, DMA_FROM_DEVICE);
> +		if (mil->direct_dma_map_ok == false)
> +			memcpy(mil->upper_buf, mil->data_buffer_dma,
> +				mil->upper_len);
> +		break;
> +
> +	case DMA_FOR_WRITE_DATA:
> +		dma_unmap_sg(this->dev, &mil->data_sgl, 1, DMA_TO_DEVICE);
> +		break;
> +
> +	case DMA_FOR_READ_ECC_PAGE:
> +	case DMA_FOR_WRITE_ECC_PAGE:
> +		/* We have to wait the BCH interrupt to finish. */
> +		break;
> +
> +	default:
> +		BUG();
> +	}
> +}
> +
> +static void show_bch_geometry(struct bch_geometry *geo)
> +{
> +	pr_info("---------------------------------------\n");
> +	pr_info("	BCH Geometry\n");
> +	pr_info("---------------------------------------\n");
> +	pr_info("ECC Algorithm          : %s\n", geo->ecc_algorithm);
> +	pr_info("ECC Strength           : %u\n", geo->ecc_strength);
> +	pr_info("Page Size in Bytes     : %u\n", geo->page_size_in_bytes);
> +	pr_info("Metadata Size in Bytes : %u\n", geo->metadata_size_in_bytes);
> +	pr_info("ECC Chunk Size in Bytes: %u\n", geo->ecc_chunk_size_in_bytes);
> +	pr_info("ECC Chunk Count        : %u\n", geo->ecc_chunk_count);
> +	pr_info("Payload Size in Bytes  : %u\n", geo->payload_size_in_bytes);
> +	pr_info("Auxiliary Size in Bytes: %u\n", geo->auxiliary_size_in_bytes);
> +	pr_info("Auxiliary Status Offset: %u\n", geo->auxiliary_status_offset);
> +	pr_info("Block Mark Byte Offset : %u\n", geo->block_mark_byte_offset);
> +	pr_info("Block Mark Bit Offset  : %u\n", geo->block_mark_bit_offset);
> +}

We don't need this.

> +
> +int start_dma_without_bch_irq(struct gpmi_nand_data *this,
> +				struct dma_async_tx_descriptor *desc)
> +{
> +	struct completion *dma_c = &this->dma_done;
> +	int err;
> +
> +	init_completion(dma_c);
> +
> +	desc->callback		= dma_irq_callback;
> +	desc->callback_param	= this;
> +	dmaengine_submit(desc);
> +
> +	/* Wait for the interrupt from the DMA block. */
> +	err = wait_for_completion_timeout(dma_c, msecs_to_jiffies(1000));
> +	err = (!err) ? -ETIMEDOUT : 0;
> +	if (err) {
> +		pr_info("DMA timeout, last DMA :%d\n", this->last_dma_type);
> +		if (gpmi_debug & GPMI_DEBUG_CRAZY) {
> +			struct bch_geometry *geo = &this->bch_geometry;
> +
> +			gpmi_show_regs(this);
> +			show_bch_geometry(geo);
> +			panic("-----------DMA FAILED------------------");

No, dev_err() or something.

Also, I don't like you using pr_ stuff, I think you can use dev_ stuff, can't you?

> +		}
> +	}
> +	return err;
> +}
> +
> +/*
> + * This function is used in BCH reading or BCH writing pages.
> + * It will wait for the BCH interrupt as long as ONE second.
> + * Actually, we must wait for two interrupts :
> + *	[1] firstly the DMA interrupt and
> + *	[2] secondly the BCH interrupt.
> + *
> + * @this:	Per-device data structure.
> + * @desc:	DMA channel

Does this conform to kerneldoc ?

> + */
> +int start_dma_with_bch_irq(struct gpmi_nand_data *this,
> +			struct dma_async_tx_descriptor *desc)
> +{
> +	int err;
> +
> +	/* Prepare to receive an interrupt from the BCH block. */
> +	init_completion(&this->bch_done);
> +
> +	/* start the DMA */
> +	start_dma_without_bch_irq(this, desc);
> +
> +	/* Wait for the interrupt from the BCH block. */
> +	err = wait_for_completion_timeout(&this->bch_done,
> +					msecs_to_jiffies(1000));
> +	err = (!err) ? -ETIMEDOUT : 0;
> +	if (err) {
> +		pr_info("BCH timeout!!!\n");

One ! is enough!!!

> +		if (gpmi_debug & GPMI_DEBUG_CRAZY) {

GPMI_DEBUG_CRAZY should probably be GPMI_DEBUG_VERBOSE ?

> +			struct bch_geometry *geo = &this->bch_geometry;
> +
> +			gpmi_show_regs(this);
> +			show_bch_geometry(geo);
> +			panic("-----------BCH FAILED------------------");

dev_err()

> +		}
> +	}
> +	return err;
> +}
> +
> +static int __devinit acquire_register_block(struct gpmi_nand_data *this,
> +			const char *resource_name, void **reg_block_base)
> +{
> +	struct platform_device *pdev = this->pdev;
> +	struct resource *r;
> +	void *p;
> +
> +	r = platform_get_resource_byname(pdev, IORESOURCE_MEM, resource_name);
> +	if (!r) {
> +		pr_info("Can't get resource for %s\n", resource_name);
> +		return -ENXIO;
> +	}
> +
> +	/* remap the register block */
> +	p = ioremap(r->start, resource_size(r));
> +	if (!p) {
> +		pr_info("Can't remap %s\n", resource_name);
> +		return -ENOMEM;
> +	}
> +
> +	*reg_block_base = p;
> +	return 0;
> +}
> +
> +static void release_register_block(struct gpmi_nand_data *this,
> +				void *reg_block_base)
> +{
> +	iounmap(reg_block_base);
> +}
> +
> +static int __devinit acquire_interrupt(struct gpmi_nand_data *this,
> +			const char *resource_name,
> +			irq_handler_t interrupt_handler, int *lno, int *hno)
> +{
> +	struct platform_device *pdev = this->pdev;
> +	struct resource *r;
> +	int err;
> +
> +	r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, resource_name);
> +	if (!r) {
> +		pr_info("Can't get resource for %s\n", resource_name);
> +		return -ENXIO;
> +	}
> +
> +	BUG_ON(r->start != r->end);
> +	err = request_irq(r->start, interrupt_handler, 0, resource_name, this);
> +	if (err) {
> +		pr_info("Can't own %s\n", resource_name);
> +		return err;
> +	}
> +
> +	*lno = r->start;
> +	*hno = r->end;
> +	return 0;
> +}
> +
> +static void release_interrupt(struct gpmi_nand_data *this,
> +			int low_interrupt_number, int high_interrupt_number)
> +{
> +	int i;
> +	for (i = low_interrupt_number; i <= high_interrupt_number; i++)
> +		free_irq(i, this);
> +}
> +
> +static bool gpmi_dma_filter(struct dma_chan *chan, void *param)
> +{
> +	struct gpmi_nand_data *this = param;
> +	struct resource *r = this->private;
> +
> +	if (!mxs_dma_is_apbh(chan))
> +		return false;
> +	/*
> +	 * only catch the GPMI dma channels :
> +	 *	for mx23 :	MX23_DMA_GPMI0 ~ MX23_DMA_GPMI3
> +	 *		(These four channels share the same IRQ!)
> +	 *
> +	 *	for mx28 :	MX28_DMA_GPMI0 ~ MX28_DMA_GPMI7
> +	 *		(These eight channels share the same IRQ!)
> +	 */
> +	if (r->start <= chan->chan_id && chan->chan_id <= r->end) {
> +		chan->private = &this->dma_data;
> +		return true;
> +	}
> +	return false;
> +}
> +
> +static void release_dma_channels(struct gpmi_nand_data *this)
> +{
> +	unsigned int i;
> +	for (i = 0; i < DMA_CHANS; i++)
> +		if (this->dma_chans[i]) {
> +			dma_release_channel(this->dma_chans[i]);
> +			this->dma_chans[i] = NULL;
> +		}
> +}
> +
> +static int __devinit acquire_dma_channels(struct gpmi_nand_data *this,
> +				const char *resource_name,
> +				unsigned *low_channel, unsigned *high_channel)
> +{
> +	struct platform_device *pdev = this->pdev;
> +	struct gpmi_nand_platform_data *pdata = this->pdata;
> +	struct resource *r, *r_dma;
> +	unsigned int i;
> +
> +	r = platform_get_resource_byname(pdev, IORESOURCE_DMA, resource_name);
> +	r_dma = platform_get_resource_byname(pdev, IORESOURCE_IRQ,
> +					GPMI_NAND_DMA_INTERRUPT_RES_NAME);
> +	if (!r || !r_dma) {
> +		pr_info("Can't get resource for DMA\n");
> +		return -ENXIO;
> +	}
> +
> +	/* used in gpmi_dma_filter() */
> +	this->private = r;
> +
> +	for (i = r->start; i <= r->end; i++) {
> +		struct dma_chan *dma_chan;
> +		dma_cap_mask_t mask;
> +
> +		if (i - r->start >= pdata->max_chip_count)
> +			break;
> +
> +		dma_cap_zero(mask);
> +		dma_cap_set(DMA_SLAVE, mask);
> +
> +		/* get the DMA interrupt */
> +		if (r_dma->start == r_dma->end) {
> +			/* only register the first. */
> +			if (i == r->start)
> +				this->dma_data.chan_irq = r_dma->start;
> +			else
> +				this->dma_data.chan_irq = NO_IRQ;
> +		} else
> +			this->dma_data.chan_irq = r_dma->start + (i - r->start);
> +
> +		dma_chan = dma_request_channel(mask, gpmi_dma_filter, this);
> +		if (!dma_chan)
> +			goto acquire_err;
> +
> +		/* fill the first empty item */
> +		this->dma_chans[i - r->start] = dma_chan;
> +	}
> +
> +	*low_channel  = r->start;
> +	*high_channel = i;
> +	return 0;
> +
> +acquire_err:
> +	pr_info("Can't acquire DMA channel %u\n", i);
> +	release_dma_channels(this);
> +	return -EINVAL;
> +}
> +
> +static int __devinit acquire_resources(struct gpmi_nand_data *this)
> +{
> +	struct resources *r = &this->resources;
> +	int error;
> +
> +	/* Attempt to acquire the GPMI register block. */
> +	error = acquire_register_block(this,
> +				GPMI_NAND_GPMI_REGS_ADDR_RES_NAME,
> +				&r->gpmi_regs);

You're already passing "this", why pass r->gpmi_regs? Please fix globally.

> +	if (error)
> +		goto exit_gpmi_regs;
> +
> +	/* Attempt to acquire the BCH register block. */
> +	error = acquire_register_block(this,
> +				GPMI_NAND_BCH_REGS_ADDR_RES_NAME,
> +				&r->bch_regs);
> +	if (error)
> +		goto exit_bch_regs;
> +
> +	/* Attempt to acquire the BCH interrupt. */
> +	error = acquire_interrupt(this,
> +				GPMI_NAND_BCH_INTERRUPT_RES_NAME,
> +				bch_irq,
> +				&r->bch_low_interrupt,
> +				&r->bch_high_interrupt);
> +	if (error)
> +		goto exit_bch_interrupt;
> +
> +	/* Attempt to acquire the DMA channels. */
> +	error = acquire_dma_channels(this,
> +				GPMI_NAND_DMA_CHANNELS_RES_NAME,
> +				&r->dma_low_channel,
> +				&r->dma_high_channel);
> +	if (error)
> +		goto exit_dma_channels;
> +
> +	/* Attempt to acquire our clock. */
> +	r->clock = clk_get(&this->pdev->dev, NULL);
> +	if (IS_ERR(r->clock)) {
> +		pr_info("can not get the clock\n");
> +		error = -ENOENT;
> +		goto exit_clock;
> +	}
> +	return 0;
> +
> +exit_clock:
> +	release_dma_channels(this);
> +exit_dma_channels:
> +	release_interrupt(this, r->bch_low_interrupt, r->bch_high_interrupt);
> +exit_bch_interrupt:
> +	release_register_block(this, r->bch_regs);
> +exit_bch_regs:
> +	release_register_block(this, r->gpmi_regs);
> +exit_gpmi_regs:
> +	return error;
> +}
> +
> +static void release_resources(struct gpmi_nand_data *this)
> +{
> +	struct resources *r = &this->resources;
> +
> +	clk_put(r->clock);
> +	release_register_block(this, r->gpmi_regs);
> +	release_register_block(this, r->bch_regs);
> +	release_interrupt(this, r->bch_low_interrupt, r->bch_low_interrupt);
> +	release_dma_channels(this);
> +}
> +
> +static int __devinit init_hardware(struct gpmi_nand_data *this)
> +{
> +	int error;
> +
> +	/*
> +	 * This structure contains the "safe" GPMI timing that should succeed
> +	 * with any NAND Flash device
> +	 * (although, with less-than-optimal performance).
> +	 */
> +	struct nand_timing  safe_timing = {
> +		.data_setup_in_ns        = 80,
> +		.data_hold_in_ns         = 60,
> +		.address_setup_in_ns     = 25,
> +		.gpmi_sample_delay_in_ns =  6,
> +		.tREA_in_ns              = -1,
> +		.tRLOH_in_ns             = -1,
> +		.tRHOH_in_ns             = -1,
> +	};
> +
> +	/* Initialize the hardwares. */
> +	error = gpmi_init(this);
> +	if (error)
> +		return error;
> +
> +	this->timing = safe_timing;
> +	return 0;
> +}
> +
> +static int read_page_prepare(struct gpmi_nand_data *this,
> +			void *destination, unsigned length,
> +			void *alt_virt, dma_addr_t alt_phys, unsigned alt_size,
> +			void **use_virt, dma_addr_t *use_phys)
> +{
> +	struct device *dev = this->dev;
> +
> +	if (virt_addr_valid(destination)) {
> +		dma_addr_t dest_phys;
> +
> +		dest_phys = dma_map_single(dev, destination,
> +						length, DMA_FROM_DEVICE);
> +		if (dma_mapping_error(dev, dest_phys)) {
> +			if (alt_size < length) {
> +				pr_info("Alternate buffer is too small\n");
> +				return -ENOMEM;
> +			}
> +			goto map_failed;
> +		}
> +		*use_virt = destination;
> +		*use_phys = dest_phys;
> +		this->mil.direct_dma_map_ok = true;
> +		return 0;
> +	}
> +
> +map_failed:
> +	*use_virt = alt_virt;
> +	*use_phys = alt_phys;
> +	this->mil.direct_dma_map_ok = false;
> +	return 0;
> +}
> +
> +static inline void read_page_end(struct gpmi_nand_data *this,
> +			void *destination, unsigned length,
> +			void *alt_virt, dma_addr_t alt_phys, unsigned alt_size,
> +			void *used_virt, dma_addr_t used_phys)
> +{
> +	if (this->mil.direct_dma_map_ok)
> +		dma_unmap_single(this->dev, used_phys, length, DMA_FROM_DEVICE);
> +}
> +
> +static inline void read_page_swap_end(struct gpmi_nand_data *this,
> +			void *destination, unsigned length,
> +			void *alt_virt, dma_addr_t alt_phys, unsigned alt_size,
> +			void *used_virt, dma_addr_t used_phys)
> +{
> +	if (!this->mil.direct_dma_map_ok)
> +		memcpy(destination, alt_virt, length);
> +}
> +
> +static int send_page_prepare(struct gpmi_nand_data *this,
> +			const void *source, unsigned length,
> +			void *alt_virt, dma_addr_t alt_phys, unsigned alt_size,
> +			const void **use_virt, dma_addr_t *use_phys)
> +{
> +	struct device *dev = this->dev;
> +
> +	if (virt_addr_valid(source)) {
> +		dma_addr_t source_phys;
> +
> +		source_phys = dma_map_single(dev, (void *)source, length,
> +						DMA_TO_DEVICE);
> +		if (dma_mapping_error(dev, source_phys)) {
> +			if (alt_size < length) {
> +				pr_info("Alternate buffer is too small\n");
> +				return -ENOMEM;
> +			}
> +			goto map_failed;
> +		}
> +		*use_virt = source;
> +		*use_phys = source_phys;
> +		return 0;
> +	}
> +map_failed:
> +	/*
> +	 * Copy the content of the source buffer into the alternate
> +	 * buffer and set up the return values accordingly.
> +	 */
> +	memcpy(alt_virt, source, length);
> +
> +	*use_virt = alt_virt;
> +	*use_phys = alt_phys;
> +	return 0;
> +}
> +
> +static void send_page_end(struct gpmi_nand_data *this,
> +			const void *source, unsigned length,
> +			void *alt_virt, dma_addr_t alt_phys, unsigned alt_size,
> +			const void *used_virt, dma_addr_t used_phys)
> +{
> +	struct device *dev = this->dev;
> +	if (used_virt == source)
> +		dma_unmap_single(dev, used_phys, length, DMA_TO_DEVICE);
> +}
> +
> +static void mil_free_dma_buffer(struct gpmi_nand_data *this)
> +{
> +	struct device *dev = this->dev;
> +	struct mil *mil	= &this->mil;
> +
> +	if (mil->page_buffer_virt && virt_addr_valid(mil->page_buffer_virt))
> +		dma_free_coherent(dev, mil->page_buffer_size,
> +					mil->page_buffer_virt,
> +					mil->page_buffer_phys);
> +	kfree(mil->cmd_buffer);
> +	kfree(mil->data_buffer_dma);
> +
> +	mil->cmd_buffer		= NULL;
> +	mil->data_buffer_dma	= NULL;
> +	mil->page_buffer_virt	= NULL;
> +	mil->page_buffer_size	=  0;
> +}
> +
> +/* Allocate the DMA buffers */
> +static int mil_alloc_dma_buffer(struct gpmi_nand_data *this)
> +{
> +	struct bch_geometry *geo = &this->bch_geometry;
> +	struct device *dev = this->dev;
> +	struct mil *mil = &this->mil;
> +
> +	/* [1] Allocate a command buffer. PAGE_SIZE is enough. */
> +	mil->cmd_buffer = kzalloc(PAGE_SIZE, GFP_DMA);
> +	if (mil->cmd_buffer == NULL)
> +		goto error_alloc;
> +
> +	/* [2] Allocate a read/write data buffer. PAGE_SIZE is enough. */
> +	mil->data_buffer_dma = kzalloc(PAGE_SIZE, GFP_DMA);
> +	if (mil->data_buffer_dma == NULL)
> +		goto error_alloc;
> +
> +	/*
> +	 * [3] Allocate the page buffer.
> +	 *
> +	 * Both the payload buffer and the auxiliary buffer must appear on
> +	 * 32-bit boundaries. We presume the size of the payload buffer is a
> +	 * power of two and is much larger than four, which guarantees the
> +	 * auxiliary buffer will appear on a 32-bit boundary.
> +	 */
> +	mil->page_buffer_size = geo->payload_size_in_bytes +
> +				geo->auxiliary_size_in_bytes;
> +
> +	mil->page_buffer_virt = dma_alloc_coherent(dev, mil->page_buffer_size,
> +					&mil->page_buffer_phys, GFP_DMA);
> +	if (!mil->page_buffer_virt)
> +		goto error_alloc;
> +
> +
> +	/* Slice up the page buffer. */
> +	mil->payload_virt = mil->page_buffer_virt;
> +	mil->payload_phys = mil->page_buffer_phys;
> +	mil->auxiliary_virt = mil->payload_virt + geo->payload_size_in_bytes;
> +	mil->auxiliary_phys = mil->payload_phys + geo->payload_size_in_bytes;
> +	return 0;
> +
> +error_alloc:
> +	mil_free_dma_buffer(this);
> +	pr_info("allocate DMA buffer error!!\n");
> +	return -ENOMEM;
> +}
> +
> +static void gpmi_cmd_ctrl(struct mtd_info *mtd, int data, unsigned int
> ctrl) +{
> +	struct nand_chip *nand = mtd->priv;
> +	struct gpmi_nand_data *this = nand->priv;
> +	struct mil *mil = &this->mil;
> +	int error;
> +
> +	/*
> +	 * Every operation begins with a command byte and a series of zero or
> +	 * more address bytes. These are distinguished by either the Address
> +	 * Latch Enable (ALE) or Command Latch Enable (CLE) signals being
> +	 * asserted. When MTD is ready to execute the command, it will deassert
> +	 * both latch enables.
> +	 *
> +	 * Rather than run a separate DMA operation for every single byte, we
> +	 * queue them up and run a single DMA operation for the entire series
> +	 * of command and data bytes. NAND_CMD_NONE means the END of the queue.
> +	 */
> +	if ((ctrl & (NAND_ALE | NAND_CLE))) {
> +		if (data != NAND_CMD_NONE)
> +			mil->cmd_buffer[mil->command_length++] = data;
> +		return;
> +	}
> +
> +	if (!mil->command_length)
> +		return;
> +
> +	error = gpmi_send_command(this);
> +	if (error)
> +		pr_info("Chip: %u, Error %d\n", mil->current_chip, error);
> +
> +	mil->command_length = 0;
> +}
> +
> +static int gpmi_dev_ready(struct mtd_info *mtd)
> +{
> +	struct nand_chip *nand = mtd->priv;
> +	struct gpmi_nand_data *this = nand->priv;
> +	struct mil *mil = &this->mil;
> +
> +	return gpmi_is_ready(this, mil->current_chip);
> +}
> +
> +static void gpmi_select_chip(struct mtd_info *mtd, int chip)
> +{
> +	struct nand_chip *nand = mtd->priv;
> +	struct gpmi_nand_data *this = nand->priv;
> +	struct mil *mil = &this->mil;
> +
> +	if ((mil->current_chip < 0) && (chip >= 0))
> +		gpmi_begin(this);
> +	else if ((mil->current_chip >= 0) && (chip < 0))
> +		gpmi_end(this);
> +	else
> +		;

Do you need this else branch at all?

> +
> +	mil->current_chip = chip;
> +}
> +
> +static void gpmi_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
> +{
> +	struct nand_chip *nand = mtd->priv;
> +	struct gpmi_nand_data *this = nand->priv;
> +	struct mil *mil = &this->mil;
> +
> +	logio(GPMI_DEBUG_READ);
> +	/* save the info in mil{} for future */
> +	mil->upper_buf	= buf;
> +	mil->upper_len	= len;
> +
> +	gpmi_read_data(this);
> +}
> +
> +static void gpmi_write_buf(struct mtd_info *mtd, const uint8_t *buf, int
> len) +{
> +	struct nand_chip *nand = mtd->priv;
> +	struct gpmi_nand_data *this = nand->priv;
> +	struct mil *mil = &this->mil;
> +
> +	logio(GPMI_DEBUG_WRITE);
> +	/* save the info in mil{} for future */
> +	mil->upper_buf	= (uint8_t *)buf;
> +	mil->upper_len	= len;
> +
> +	gpmi_send_data(this);
> +}
> +
> +static uint8_t gpmi_read_byte(struct mtd_info *mtd)
> +{
> +	struct nand_chip *nand = mtd->priv;
> +	struct gpmi_nand_data *this = nand->priv;
> +	struct mil *mil = &this->mil;
> +	uint8_t *buf = mil->data_buffer_dma;
> +
> +	gpmi_read_buf(mtd, buf, 1);
> +	return buf[0];
> +}
> +
> +/**
> + * mil_handle_block_mark_swapping() - Handles block mark swapping.
> + *
> + * Note that, when this function is called, it doesn't know whether it's
> + * swapping the block mark, or swapping it *back* -- but it doesn't matter
> + * because the the operation is the same.
> + *
> + * @this:       Per-device data.
> + * @payload:    A pointer to the payload buffer.
> + * @auxiliary:  A pointer to the auxiliary buffer.
> + */
> +static void mil_handle_block_mark_swapping(struct gpmi_nand_data *this,
> +						void *payload, void *auxiliary)
> +{
> +	struct bch_geometry *nfc_geo = &this->bch_geometry;
> +	unsigned char *p;
> +	unsigned char *a;
> +	unsigned int  bit;
> +	unsigned char mask;
> +	unsigned char from_data;
> +	unsigned char from_oob;
> +
> +	/* Check if we're doing block mark swapping. */
> +	if (!this->swap_block_mark)
> +		return;
> +
> +	/*
> +	 * If control arrives here, we're swapping. Make some convenience
> +	 * variables.
> +	 */
> +	bit = nfc_geo->block_mark_bit_offset;
> +	p   = payload + nfc_geo->block_mark_byte_offset;
> +	a   = auxiliary;
> +
> +	/*
> +	 * Get the byte from the data area that overlays the block mark. Since
> +	 * the ECC engine applies its own view to the bits in the page, the
> +	 * physical block mark won't (in general) appear on a byte boundary in
> +	 * the data.
> +	 */
> +	from_data = (p[0] >> bit) | (p[1] << (8 - bit));
> +
> +	/* Get the byte from the OOB. */
> +	from_oob = a[0];
> +
> +	/* Swap them. */
> +	a[0] = from_data;
> +
> +	mask = (0x1 << bit) - 1;
> +	p[0] = (p[0] & mask) | (from_oob << bit);
> +
> +	mask = ~0 << bit;
> +	p[1] = (p[1] & mask) | (from_oob >> (8 - bit));
> +}
> +
> +static int gpmi_ecc_read_page(struct mtd_info *mtd, struct nand_chip
> *nand, +				uint8_t *buf, int page)
> +{
> +	struct gpmi_nand_data *this = nand->priv;
> +	struct bch_geometry *nfc_geo = &this->bch_geometry;
> +	struct mil *mil = &this->mil;
> +	void          *payload_virt;
> +	dma_addr_t    payload_phys;
> +	void          *auxiliary_virt;
> +	dma_addr_t    auxiliary_phys;
> +	unsigned int  i;
> +	unsigned char *status;
> +	unsigned int  failed;
> +	unsigned int  corrected;
> +	int           error;
> +
> +	logio(GPMI_DEBUG_ECC_READ);
> +	error = read_page_prepare(this, buf, mtd->writesize,
> +					mil->payload_virt, mil->payload_phys,
> +					nfc_geo->payload_size_in_bytes,
> +					&payload_virt, &payload_phys);
> +	if (error) {
> +		pr_info("Inadequate DMA buffer\n");
> +		error = -ENOMEM;
> +		return error;
> +	}
> +	auxiliary_virt = mil->auxiliary_virt;
> +	auxiliary_phys = mil->auxiliary_phys;
> +
> +	/* go! */
> +	error = gpmi_read_page(this, payload_phys, auxiliary_phys);
> +	read_page_end(this, buf, mtd->writesize,
> +			mil->payload_virt, mil->payload_phys,
> +			nfc_geo->payload_size_in_bytes,
> +			payload_virt, payload_phys);
> +	if (error) {
> +		pr_info("Error in ECC-based read: %d\n", error);
> +		goto exit_nfc;
> +	}
> +
> +	/* handle the block mark swapping */
> +	mil_handle_block_mark_swapping(this, payload_virt, auxiliary_virt);
> +
> +	/* Loop over status bytes, accumulating ECC status. */
> +	failed		= 0;
> +	corrected	= 0;
> +	status		= auxiliary_virt + nfc_geo->auxiliary_status_offset;
> +
> +	for (i = 0; i < nfc_geo->ecc_chunk_count; i++, status++) {
> +		if ((*status == STATUS_GOOD) || (*status == STATUS_ERASED))
> +			continue;
> +
> +		if (*status == STATUS_UNCORRECTABLE) {
> +			failed++;
> +			continue;
> +		}
> +		corrected += *status;
> +	}
> +
> +	/*
> +	 * Propagate ECC status to the owning MTD only when failed or
> +	 * corrected times nearly reaches our ECC correction threshold.
> +	 */
> +	if (failed || corrected >= (nfc_geo->ecc_strength - 1)) {
> +		mtd->ecc_stats.failed    += failed;
> +		mtd->ecc_stats.corrected += corrected;
> +	}
> +
> +	/*
> +	 * It's time to deliver the OOB bytes. See gpmi_ecc_read_oob() for
> +	 * details about our policy for delivering the OOB.
> +	 *
> +	 * We fill the caller's buffer with set bits, and then copy the block
> +	 * mark to th caller's buffer. Note that, if block mark swapping was
> +	 * necessary, it has already been done, so we can rely on the first
> +	 * byte of the auxiliary buffer to contain the block mark.
> +	 */
> +	memset(nand->oob_poi, ~0, mtd->oobsize);
> +	nand->oob_poi[0] = ((uint8_t *) auxiliary_virt)[0];
> +
> +	read_page_swap_end(this, buf, mtd->writesize,
> +			mil->payload_virt, mil->payload_phys,
> +			nfc_geo->payload_size_in_bytes,
> +			payload_virt, payload_phys);
> +exit_nfc:
> +	return error;
> +}
> +
> +static void gpmi_ecc_write_page(struct mtd_info *mtd,
> +				struct nand_chip *nand, const uint8_t *buf)
> +{
> +	struct gpmi_nand_data *this = nand->priv;
> +	struct bch_geometry *nfc_geo = &this->bch_geometry;
> +	struct mil *mil = &this->mil;
> +	const void *payload_virt;
> +	dma_addr_t payload_phys;
> +	const void *auxiliary_virt;
> +	dma_addr_t auxiliary_phys;
> +	int        error;
> +
> +	logio(GPMI_DEBUG_ECC_WRITE);
> +	if (this->swap_block_mark) {
> +		/*
> +		 * If control arrives here, we're doing block mark swapping.
> +		 * Since we can't modify the caller's buffers, we must copy them
> +		 * into our own.
> +		 */
> +		memcpy(mil->payload_virt, buf, mtd->writesize);
> +		payload_virt = mil->payload_virt;
> +		payload_phys = mil->payload_phys;
> +
> +		memcpy(mil->auxiliary_virt, nand->oob_poi,
> +				nfc_geo->auxiliary_size_in_bytes);
> +		auxiliary_virt = mil->auxiliary_virt;
> +		auxiliary_phys = mil->auxiliary_phys;
> +
> +		/* Handle block mark swapping. */
> +		mil_handle_block_mark_swapping(this,
> +				(void *) payload_virt, (void *) auxiliary_virt);
> +	} else {
> +		/*
> +		 * If control arrives here, we're not doing block mark swapping,
> +		 * so we can to try and use the caller's buffers.
> +		 */
> +		error = send_page_prepare(this,
> +				buf, mtd->writesize,
> +				mil->payload_virt, mil->payload_phys,
> +				nfc_geo->payload_size_in_bytes,
> +				&payload_virt, &payload_phys);
> +		if (error) {
> +			pr_info("Inadequate payload DMA buffer\n");
> +			return;
> +		}
> +
> +		error = send_page_prepare(this,
> +				nand->oob_poi, mtd->oobsize,
> +				mil->auxiliary_virt, mil->auxiliary_phys,
> +				nfc_geo->auxiliary_size_in_bytes,
> +				&auxiliary_virt, &auxiliary_phys);
> +		if (error) {
> +			pr_info("Inadequate auxiliary DMA buffer\n");
> +			goto exit_auxiliary;
> +		}
> +	}
> +
> +	/* Ask the NFC. */
> +	error = gpmi_send_page(this, payload_phys, auxiliary_phys);
> +	if (error)
> +		pr_info("Error in ECC-based write: %d\n", error);
> +
> +	if (!this->swap_block_mark) {
> +		send_page_end(this, nand->oob_poi, mtd->oobsize,
> +				mil->auxiliary_virt, mil->auxiliary_phys,
> +				nfc_geo->auxiliary_size_in_bytes,
> +				auxiliary_virt, auxiliary_phys);
> +exit_auxiliary:
> +		send_page_end(this, buf, mtd->writesize,
> +				mil->payload_virt, mil->payload_phys,
> +				nfc_geo->payload_size_in_bytes,
> +				payload_virt, payload_phys);
> +	}
> +}
> +
> +/**
> + * gpmi_ecc_read_oob() - MTD Interface ecc.read_oob().
> + *
> + * There are several places in this driver where we have to handle the OOB
> and + * block marks. This is the function where things are the most
> complicated, so + * this is where we try to explain it all. All the other
> places refer back to + * here.
> + *
> + * These are the rules, in order of decreasing importance:
> + *
> + * 1) Nothing the caller does can be allowed to imperil the block mark, so
> all + *    write operations take measures to protect it.
> + *
> + * 2) In read operations, the first byte of the OOB we return must reflect
> the + *    true state of the block mark, no matter where that block mark
> appears in + *    the physical page.
> + *
> + * 3) ECC-based read operations return an OOB full of set bits (since we
> never + *    allow ECC-based writes to the OOB, it doesn't matter what
> ECC-based reads + *    return).
> + *
> + * 4) "Raw" read operations return a direct view of the physical bytes in
> the + *    page, using the conventional definition of which bytes are data
> and which + *    are OOB. This gives the caller a way to see the actual,
> physical bytes + *    in the page, without the distortions applied by our
> ECC engine. + *
> + *
> + * What we do for this specific read operation depends on two questions:
> + *
> + * 1) Are we doing a "raw" read, or an ECC-based read?
> + *
> + * 2) Are we using block mark swapping or transcription?
> + *
> + * There are four cases, illustrated by the following Karnaugh map:
> + *
> + *                    |           Raw           |         ECC-based      
> | + *      
> -------------+-------------------------+-------------------------+ + *    
>                | Read the conventional   |                         | + *  
>                  | OOB at the end of the   |                         | + *
>       Swapping     | page and return it. It  |                         | +
> *                    | contains exactly what   |                         |
> + *                    | we want.                | Read the block mark and
> | + *       -------------+-------------------------+ return it in a buffer
>   | + *                    | Read the conventional   | full of set bits.  
>     | + *                    | OOB at the end of the   |                  
>       | + *                    | page and also the block |                
>         | + *       Transcribing | mark in the metadata.   |              
>           | + *                    | Copy the block mark     |            
>             | + *                    | into the first byte of  |          
>               | + *                    | the OOB.                |        
>                 | + *      
> -------------+-------------------------+-------------------------+ + *
> + * Note that we break rule #4 in the Transcribing/Raw case because we're
> not + * giving an accurate view of the actual, physical bytes in the page
> (we're + * overwriting the block mark). That's OK because it's more
> important to follow + * rule #2.
> + *
> + * It turns out that knowing whether we want an "ECC-based" or "raw" read
> is not + * easy. When reading a page, for example, the NAND Flash MTD code
> calls our + * ecc.read_page or ecc.read_page_raw function. Thus, the fact
> that MTD wants an + * ECC-based or raw view of the page is implicit in
> which function it calls + * (there is a similar pair of ECC-based/raw
> functions for writing). + *
> + * Since MTD assumes the OOB is not covered by ECC, there is no pair of
> + * ECC-based/raw functions for reading or or writing the OOB. The fact
> that the + * caller wants an ECC-based or raw view of the page is not
> propagated down to + * this driver.
> + *
> + * @mtd:     A pointer to the owning MTD.
> + * @nand:    A pointer to the owning NAND Flash MTD.
> + * @page:    The page number to read.
> + * @sndcmd:  Indicates this function should send a command to the chip
> before + *           reading the out-of-band bytes. This is only false for
> small page + *           chips that support auto-increment.
> + */
> +static int gpmi_ecc_read_oob(struct mtd_info *mtd, struct nand_chip *nand,
> +							int page, int sndcmd)
> +{
> +	struct gpmi_nand_data *this = nand->priv;
> +
> +	/* clear the OOB buffer */
> +	memset(nand->oob_poi, ~0, mtd->oobsize);
> +
> +	/* Read out the conventional OOB. */
> +	nand->cmdfunc(mtd, NAND_CMD_READ0, mtd->writesize, page);
> +	nand->read_buf(mtd, nand->oob_poi, mtd->oobsize);
> +
> +	/*
> +	 * Now, we want to make sure the block mark is correct. In the
> +	 * Swapping/Raw case, we already have it. Otherwise, we need to
> +	 * explicitly read it.
> +	 */
> +	if (!this->swap_block_mark) {
> +		/* Read the block mark into the first byte of the OOB buffer. */
> +		nand->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
> +		nand->oob_poi[0] = nand->read_byte(mtd);
> +	}
> +
> +	/*
> +	 * Return true, indicating that the next call to this function must send
> +	 * a command.
> +	 */
> +	return true;
> +}
> +
> +static int gpmi_block_markbad(struct mtd_info *mtd, loff_t ofs)
> +{
> +	struct nand_chip *nand = mtd->priv;
> +	struct gpmi_nand_data *this = nand->priv;
> +	int block, ret = 0;
> +
> +	/* Get block number */
> +	block = (int)(ofs >> nand->bbt_erase_shift);
> +	if (nand->bbt)
> +		nand->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
> +
> +	/* Do we have a flash based bad block table ? */
> +	if (nand->options & NAND_USE_FLASH_BBT)
> +		ret = nand_update_bbt(mtd, ofs);

if (stuff)
	return nand_update_bbt();

stuff from else branch
.
.
.

Besides, please don't declare variables in the middle of code.

> +	else {
> +		struct mil *mil	= &this->mil;
> +		uint8_t *block_mark;
> +		int column, page, status, chipnr;
> +
> +		chipnr = (int)(ofs >> nand->chip_shift);
> +		nand->select_chip(mtd, chipnr);
> +
> +		column = this->swap_block_mark ? mtd->writesize : 0;
> +
> +		/* Write the block mark. */
> +		block_mark = mil->data_buffer_dma;
> +		block_mark[0] = 0; /* bad block marker */
> +
> +		/* Shift to get page */
> +		page = (int)(ofs >> nand->page_shift);
> +
> +		nand->cmdfunc(mtd, NAND_CMD_SEQIN, column, page);
> +		nand->write_buf(mtd, block_mark, 1);
> +		nand->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
> +
> +		status = nand->waitfunc(mtd, nand);
> +		if (status & NAND_STATUS_FAIL)
> +			ret = -EIO;
> +
> +		nand->select_chip(mtd, -1);
> +	}
> +	if (!ret)
> +		mtd->ecc_stats.badblocks++;
> +
> +	return ret;
> +}
> +
> +static int __devinit nand_boot_set_geometry(struct gpmi_nand_data *this)
> +{
> +	struct boot_rom_geometry *geometry = &this->rom_geometry;
> +
> +	/*
> +	 * Set the boot block stride size.
> +	 *
> +	 * In principle, we should be reading this from the OTP bits, since
> +	 * that's where the ROM is going to get it. In fact, we don't have any
> +	 * way to read the OTP bits, so we go with the default and hope for the
> +	 * best.
> +	 */
> +	geometry->stride_size_in_pages = 64;
> +
> +	/*
> +	 * Set the search area stride exponent.
> +	 *
> +	 * In principle, we should be reading this from the OTP bits, since
> +	 * that's where the ROM is going to get it. In fact, we don't have any
> +	 * way to read the OTP bits, so we go with the default and hope for the
> +	 * best.
> +	 */
> +	geometry->search_area_stride_exponent = 2;
> +
> +	if (gpmi_debug & GPMI_DEBUG_INIT)
> +		pr_info("stride size in page : %d, search areas : %d\n",
> +			geometry->stride_size_in_pages,
> +			geometry->search_area_stride_exponent);
> +	return 0;
> +}
> +
> +static const char  *fingerprint = "STMP";
> +static int __devinit mx23_check_transcription_stamp(struct gpmi_nand_data
> *this) +{
> +	struct boot_rom_geometry *rom_geo = &this->rom_geometry;
> +	struct mil *mil = &this->mil;
> +	struct mtd_info *mtd = &mil->mtd;
> +	struct nand_chip *nand = &mil->nand;
> +	unsigned int search_area_size_in_strides;
> +	unsigned int stride;
> +	unsigned int page;
> +	loff_t byte;
> +	uint8_t *buffer = nand->buffers->databuf;
> +	int saved_chip_number;
> +	int found_an_ncb_fingerprint = false;
> +
> +	/* Compute the number of strides in a search area. */
> +	search_area_size_in_strides = 1 << rom_geo->search_area_stride_exponent;
> +
> +	/* Select chip 0. */
> +	saved_chip_number = mil->current_chip;
> +	nand->select_chip(mtd, 0);
> +
> +	/*
> +	 * Loop through the first search area, looking for the NCB fingerprint.
> +	 */
> +	pr_info("Scanning for an NCB fingerprint...\n");
> +
> +	for (stride = 0; stride < search_area_size_in_strides; stride++) {
> +		/* Compute the page and byte addresses. */
> +		page = stride * rom_geo->stride_size_in_pages;
> +		byte = page   * mtd->writesize;
> +
> +		pr_info("  Looking for a fingerprint in page 0x%x\n", page);

pr_info? Why, who cares, I'd prefer dev_dbg()?

> +
> +		/*
> +		 * Read the NCB fingerprint. The fingerprint is four bytes long
> +		 * and starts in the 12th byte of the page.
> +		 */
> +		nand->cmdfunc(mtd, NAND_CMD_READ0, 12, page);
> +		nand->read_buf(mtd, buffer, strlen(fingerprint));
> +
> +		/* Look for the fingerprint. */
> +		if (!memcmp(buffer, fingerprint, strlen(fingerprint))) {
> +			found_an_ncb_fingerprint = true;
> +			break;
> +		}
> +
> +	}
> +
> +	/* Deselect chip 0. */
> +	nand->select_chip(mtd, saved_chip_number);
> +
> +	if (found_an_ncb_fingerprint)
> +		pr_info("  Found a fingerprint\n");
> +	else
> +		pr_info("  No fingerprint found\n");
> +	return found_an_ncb_fingerprint;
> +}
> +
> +/* Writes a transcription stamp. */
> +static int __devinit mx23_write_transcription_stamp(struct gpmi_nand_data
> *this) +{
> +	struct device *dev = this->dev;
> +	struct boot_rom_geometry *rom_geo = &this->rom_geometry;
> +	struct mil *mil = &this->mil;
> +	struct mtd_info *mtd = &mil->mtd;
> +	struct nand_chip *nand = &mil->nand;
> +	unsigned int block_size_in_pages;
> +	unsigned int search_area_size_in_strides;
> +	unsigned int search_area_size_in_pages;
> +	unsigned int search_area_size_in_blocks;
> +	unsigned int block;
> +	unsigned int stride;
> +	unsigned int page;
> +	loff_t       byte;
> +	uint8_t      *buffer = nand->buffers->databuf;
> +	int saved_chip_number;
> +	int status;
> +
> +	/* Compute the search area geometry. */
> +	block_size_in_pages = mtd->erasesize / mtd->writesize;
> +	search_area_size_in_strides = 1 << rom_geo->search_area_stride_exponent;
> +	search_area_size_in_pages = search_area_size_in_strides *
> +					rom_geo->stride_size_in_pages;
> +	search_area_size_in_blocks =
> +		  (search_area_size_in_pages + (block_size_in_pages - 1)) /
> +				    block_size_in_pages;
> +
> +	pr_info("-------------------------------------------\n");
> +	pr_info("Search Area Geometry\n");
> +	pr_info("-------------------------------------------\n");
> +	pr_info("Search Area in Blocks : %u\n", search_area_size_in_blocks);
> +	pr_info("Search Area in Strides: %u\n", search_area_size_in_strides);
> +	pr_info("Search Area in Pages  : %u\n", search_area_size_in_pages);

Maybe if you debug it, yes ... but I certainly don't want such ascii-art in my 
log during normal operation.

> +
> +	/* Select chip 0. */
> +	saved_chip_number = mil->current_chip;
> +	nand->select_chip(mtd, 0);
> +
> +	/* Loop over blocks in the first search area, erasing them. */
> +	pr_info("Erasing the search area...\n");
> +
> +	for (block = 0; block < search_area_size_in_blocks; block++) {
> +		/* Compute the page address. */
> +		page = block * block_size_in_pages;
> +
> +		/* Erase this block. */
> +		pr_info("  Erasing block 0x%x\n", block);
> +		nand->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
> +		nand->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
> +
> +		/* Wait for the erase to finish. */
> +		status = nand->waitfunc(mtd, nand);
> +		if (status & NAND_STATUS_FAIL)
> +			dev_err(dev, "[%s] Erase failed.\n", __func__);
> +	}
> +
> +	/* Write the NCB fingerprint into the page buffer. */
> +	memset(buffer, ~0, mtd->writesize);
> +	memset(nand->oob_poi, ~0, mtd->oobsize);
> +	memcpy(buffer + 12, fingerprint, strlen(fingerprint));
> +
> +	/* Loop through the first search area, writing NCB fingerprints. */
> +	pr_info("Writing NCB fingerprints...\n");
> +	for (stride = 0; stride < search_area_size_in_strides; stride++) {
> +		/* Compute the page and byte addresses. */
> +		page = stride * rom_geo->stride_size_in_pages;
> +		byte = page   * mtd->writesize;
> +
> +		/* Write the first page of the current stride. */
> +		pr_info("  Writing an NCB fingerprint in page 0x%x\n", page);
> +		nand->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
> +		nand->ecc.write_page_raw(mtd, nand, buffer);
> +		nand->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
> +
> +		/* Wait for the write to finish. */
> +		status = nand->waitfunc(mtd, nand);
> +		if (status & NAND_STATUS_FAIL)
> +			dev_err(dev, "[%s] Write failed.\n", __func__);
> +	}
> +
> +	/* Deselect chip 0. */
> +	nand->select_chip(mtd, saved_chip_number);
> +	return 0;
> +}
> +
> +static int __devinit mx23_boot_init(struct gpmi_nand_data  *this)
> +{
> +	struct device *dev = this->dev;
> +	struct mil *mil = &this->mil;
> +	struct nand_chip *nand = &mil->nand;
> +	struct mtd_info *mtd = &mil->mtd;
> +	unsigned int block_count;
> +	unsigned int block;
> +	int     chip;
> +	int     page;
> +	loff_t  byte;
> +	uint8_t block_mark;
> +	int     error = 0;
> +
> +	/*
> +	 * If control arrives here, we can't use block mark swapping, which
> +	 * means we're forced to use transcription. First, scan for the
> +	 * transcription stamp. If we find it, then we don't have to do
> +	 * anything -- the block marks are already transcribed.
> +	 */
> +	if (mx23_check_transcription_stamp(this))
> +		return 0;
> +
> +	/*
> +	 * If control arrives here, we couldn't find a transcription stamp, so
> +	 * so we presume the block marks are in the conventional location.
> +	 */
> +	pr_info("Transcribing bad block marks...\n");
> +
> +	/* Compute the number of blocks in the entire medium. */
> +	block_count = nand->chipsize >> nand->phys_erase_shift;
> +
> +	/*
> +	 * Loop over all the blocks in the medium, transcribing block marks as
> +	 * we go.
> +	 */
> +	for (block = 0; block < block_count; block++) {
> +		/*
> +		 * Compute the chip, page and byte addresses for this block's
> +		 * conventional mark.
> +		 */
> +		chip = block >> (nand->chip_shift - nand->phys_erase_shift);
> +		page = block << (nand->phys_erase_shift - nand->page_shift);
> +		byte = block <<  nand->phys_erase_shift;
> +
> +		/* Send the command to read the conventional block mark. */
> +		nand->select_chip(mtd, chip);
> +		nand->cmdfunc(mtd, NAND_CMD_READ0, mtd->writesize, page);
> +		block_mark = nand->read_byte(mtd);
> +		nand->select_chip(mtd, -1);
> +
> +		/*
> +		 * Check if the block is marked bad. If so, we need to mark it
> +		 * again, but this time the result will be a mark in the
> +		 * location where we transcribe block marks.
> +		 */
> +		if (block_mark != 0xff) {
> +			pr_info("Transcribing mark in block %u\n", block);
> +			error = nand->block_markbad(mtd, byte);
> +			if (error)
> +				dev_err(dev, "Failed to mark block bad with "
> +							"error %d\n", error);
> +		}
> +	}
> +
> +	/* Write the stamp that indicates we've transcribed the block marks. */
> +	mx23_write_transcription_stamp(this);
> +	return 0;
> +}
> +
> +static int __devinit nand_boot_init(struct gpmi_nand_data  *this)
> +{
> +	nand_boot_set_geometry(this);
> +
> +	/* This is ROM arch-specific initilization before the BBT scanning. */
> +	if (GPMI_IS_MX23(this))
> +		return mx23_boot_init(this);
> +	return 0;
> +}
> +
> +static int __devinit mil_set_geometry(struct gpmi_nand_data *this)
> +{
> +	int error;
> +
> +	/* Free the temporary DMA memory for reading ID. */
> +	mil_free_dma_buffer(this);
> +
> +	/* Set up the NFC geometry which is used by BCH. */
> +	error = bch_set_geometry(this);
> +	if (error) {
> +		pr_info("set geometry error : %d\n", error);
> +		return error;
> +	}
> +
> +	/* Alloc the new DMA buffers according to the pagesize and oobsize */
> +	return mil_alloc_dma_buffer(this);
> +}
> +
> +static int mil_pre_bbt_scan(struct gpmi_nand_data  *this)
> +{
> +	struct nand_chip *nand = &this->mil.nand;
> +	struct mtd_info *mtd = &this->mil.mtd;
> +	struct nand_ecclayout *layout = nand->ecc.layout;
> +	int error;
> +
> +	/*
> +	 *  fix the ECC layout before the scanning.
> +	 *  We will use all the (page + OOB).
> +	 */
> +	layout->eccbytes = 0;
> +	layout->oobavail = 0;
> +
> +	mtd->oobavail = mtd->oobsize;
> +
> +	/* Set up swap block-mark, must be set before the mil_set_geometry() */
> +	if (GPMI_IS_MX23(this))
> +		this->swap_block_mark = false;
> +	else
> +		this->swap_block_mark = true;
> +
> +	/* Set up the medium geometry */
> +	error = mil_set_geometry(this);
> +	if (error)
> +		return error;
> +
> +	/* NAND boot init, depends on the mil_set_geometry(). */
> +	return nand_boot_init(this);
> +}
> +
> +static int gpmi_scan_bbt(struct mtd_info *mtd)
> +{
> +	struct nand_chip *nand = mtd->priv;
> +	struct gpmi_nand_data *this = nand->priv;
> +	int error;
> +
> +	/* Prepare for the BBT scan. */
> +	error = mil_pre_bbt_scan(this);
> +	if (error)
> +		return error;
> +
> +	/* use the default BBT implementation */
> +	return nand_default_bbt(mtd);
> +}
> +
> +static const char *cmd_parse[] = {"cmdlinepart", NULL};
> +static int __devinit mil_partitions_init(struct gpmi_nand_data *this)
> +{
> +	struct gpmi_nand_platform_data *pdata = this->pdata;
> +	struct mil *mil = &this->mil;
> +	struct mtd_info *mtd = &mil->mtd;
> +
> +	/* use the command line for simple partitions layout */
> +	mil->partition_count = parse_mtd_partitions(mtd, cmd_parse,
> +						&mil->partitions, 0);
> +	if (mil->partition_count)
> +		return mtd_device_register(mtd, mil->partitions,
> +					mil->partition_count);
> +
> +	/* The complicated partitions layout uses this. */
> +	if (pdata->partitions && pdata->partition_count > 0)
> +		return mtd_device_register(mtd, pdata->partitions,
> +					pdata->partition_count);
> +	return mtd_device_register(mtd, NULL, 0);
> +}
> +
> +static void mil_partitions_exit(struct gpmi_nand_data *this)
> +{
> +	struct mil *mil = &this->mil;
> +	struct mtd_info *mtd = &mil->mtd;
> +
> +	mtd_device_unregister(mtd);
> +	kfree(mil->partitions);
> +	mil->partition_count = 0;
> +}
> +
> +/* Initializes the MTD Interface Layer */
> +static int __devinit gpmi_nfc_mil_init(struct gpmi_nand_data *this)
> +{
> +	struct gpmi_nand_platform_data *pdata = this->pdata;
> +	struct mil *mil = &this->mil;
> +	struct mtd_info  *mtd = &mil->mtd;
> +	struct nand_chip *nand = &mil->nand;
> +	int error;
> +
> +	/* Initialize data */
> +	mil->current_chip	= -1;
> +
> +	/* Initialize the MTD data structures */
> +	mtd->priv		= nand;
> +	mtd->name		= "gpmi-nand";
> +	mtd->owner		= THIS_MODULE;
> +	nand->priv		= this;
> +
> +	/* Controls */
> +	nand->select_chip	= gpmi_select_chip;
> +	nand->cmd_ctrl		= gpmi_cmd_ctrl;
> +	nand->dev_ready		= gpmi_dev_ready;
> +
> +	/*
> +	 * Low-level I/O :
> +	 *	We don't support a 16-bit NAND Flash bus,
> +	 *	so we don't implement read_word.
> +	 */
> +	nand->read_byte		= gpmi_read_byte;
> +	nand->read_buf		= gpmi_read_buf;
> +	nand->write_buf		= gpmi_write_buf;
> +
> +	/* ECC-aware I/O */
> +	nand->ecc.read_page	= gpmi_ecc_read_page;
> +	nand->ecc.write_page	= gpmi_ecc_write_page;
> +
> +	/* High-level I/O */
> +	nand->ecc.read_oob	= gpmi_ecc_read_oob;
> +
> +	/* Bad Block Management */
> +	nand->scan_bbt		= gpmi_scan_bbt;
> +	nand->badblock_pattern	= &gpmi_bbt_descr;
> +	nand->block_markbad	= gpmi_block_markbad;
> +
> +	/* Disallow partial page writes */
> +	nand->options		|= NAND_NO_SUBPAGE_WRITE;
> +
> +	/*
> +	 * Tell the NAND Flash MTD system that we'll be handling ECC with our
> +	 * own hardware. It turns out that we still have to fill in the ECC size
> +	 * because the MTD code will divide by it -- even though it doesn't
> +	 * actually care.
> +	 */
> +	nand->ecc.mode		= NAND_ECC_HW;
> +	nand->ecc.size		= 1;
> +
> +	/* use our layout */
> +	nand->ecc.layout = &mil->oob_layout;
> +
> +	/* Allocate a temporary DMA buffer for reading ID in the nand_scan() */
> +	this->bch_geometry.payload_size_in_bytes	= 1024;
> +	this->bch_geometry.auxiliary_size_in_bytes	= 128;
> +	error = mil_alloc_dma_buffer(this);
> +	if (error)
> +		goto exit_dma_allocation;
> +
> +	printk(KERN_INFO "GPMI-NAND : Scanning for NAND Flash chips...\n");
> +	error = nand_scan(mtd, pdata->max_chip_count);
> +	if (error) {
> +		pr_info("Chip scan failed\n");
> +		goto exit_nand_scan;
> +	}
> +
> +	/* Construct partitions as necessary. */
> +	error = mil_partitions_init(this);
> +	if (error)
> +		goto exit_partitions;
> +	return 0;
> +
> +exit_partitions:
> +	nand_release(&mil->mtd);
> +exit_nand_scan:
> +	mil_free_dma_buffer(this);
> +exit_dma_allocation:
> +	return error;
> +}
> +
> +void gpmi_nand_mil_exit(struct gpmi_nand_data *this)
> +{
> +	struct mil *mil = &this->mil;
> +
> +	mil_partitions_exit(this);
> +	nand_release(&mil->mtd);
> +	mil_free_dma_buffer(this);
> +}
> +
> +static int __devinit gpmi_nand_probe(struct platform_device *pdev)
> +{
> +	struct gpmi_nand_platform_data *pdata = pdev->dev.platform_data;
> +	struct gpmi_nand_data *this;
> +	int error;
> +
> +	this = kzalloc(sizeof(*this), GFP_KERNEL);
> +	if (!this) {
> +		pr_info("Failed to allocate per-device memory\n");
> +		return -ENOMEM;
> +	}
> +
> +	/* Set up our data structures. */
> +	platform_set_drvdata(pdev, this);
> +	this->pdev  = pdev;
> +	this->dev   = &pdev->dev;
> +	this->pdata = pdata;
> +
> +	/* setup the platform */
> +	if (pdata->platform_init) {
> +		error = pdata->platform_init();
> +		if (error)
> +			goto platform_init_error;
> +	}
> +
> +	/* Acquire the resources we need. */
> +	error = acquire_resources(this);
> +	if (error)
> +		goto exit_acquire_resources;
> +
> +	/* Set up the GPMI/BCH hardware. */
> +	error = init_hardware(this);
> +	if (error)
> +		goto exit_nfc_init;
> +
> +	/* Initialize the MTD Interface Layer. */
> +	error = gpmi_nfc_mil_init(this);
> +	if (error)
> +		goto exit_mil_init;
> +
> +	return 0;
> +
> +exit_mil_init:
> +exit_nfc_init:
> +	release_resources(this);
> +platform_init_error:
> +exit_acquire_resources:
> +	platform_set_drvdata(pdev, NULL);
> +	kfree(this);
> +	return error;
> +}
> +
> +static int __exit gpmi_nand_remove(struct platform_device *pdev)
> +{
> +	struct gpmi_nand_data *this = platform_get_drvdata(pdev);
> +
> +	gpmi_nand_mil_exit(this);
> +	release_resources(this);
> +	platform_set_drvdata(pdev, NULL);
> +	kfree(this);
> +	return 0;
> +}
> +
> +static const struct platform_device_id gpmi_ids[] = {
> +	{
> +		.name = "imx23-gpmi-nand",
> +		.driver_data = IS_MX23,
> +	}, {
> +		.name = "imx28-gpmi-nand",
> +		.driver_data = IS_MX28,
> +	}, {},
> +};
> +
> +/* This structure represents this driver to the platform management
> system. */ +static struct platform_driver gpmi_nand_driver = {
> +	.driver = {
> +		.name = "gpmi-nand",
> +	},
> +	.probe   = gpmi_nand_probe,
> +	.remove  = __exit_p(gpmi_nand_remove),
> +	.id_table = gpmi_ids,
> +};
> +
> +static int __init gpmi_nand_init(void)
> +{
> +	int err;
> +
> +	err = platform_driver_register(&gpmi_nand_driver);
> +	if (err == 0)
> +		printk(KERN_INFO "GPMI NAND driver registered. (IMX)\n");
> +	else
> +		pr_err("i.MX GPMI NAND driver registration failed\n");
> +	return err;
> +}
> +
> +static void __exit gpmi_nand_exit(void)
> +{
> +	platform_driver_unregister(&gpmi_nand_driver);
> +}
> +
> +module_init(gpmi_nand_init);
> +module_exit(gpmi_nand_exit);
> +
> +MODULE_AUTHOR("Freescale Semiconductor, Inc.");
> +MODULE_DESCRIPTION("i.MX GPMI NAND Flash Controller Driver");
> +MODULE_LICENSE("GPL");
> diff --git a/drivers/mtd/nand/gpmi-nand/gpmi-nand.h
> b/drivers/mtd/nand/gpmi-nand/gpmi-nand.h new file mode 100644
> index 0000000..daab719
> --- /dev/null
> +++ b/drivers/mtd/nand/gpmi-nand/gpmi-nand.h
> @@ -0,0 +1,377 @@
> +/*
> + * Freescale GPMI NAND Flash Driver
> + *
> + * Copyright (C) 2010-2011 Freescale Semiconductor, Inc.
> + * Copyright (C) 2008 Embedded Alley Solutions, Inc.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + */
> +#ifndef __DRIVERS_MTD_NAND_GPMI_NAND_H
> +#define __DRIVERS_MTD_NAND_GPMI_NAND_H
> +
> +#include <linux/err.h>
> +#include <linux/init.h>
> +#include <linux/module.h>
> +#include <linux/io.h>
> +#include <linux/interrupt.h>
> +#include <linux/clk.h>
> +#include <linux/delay.h>
> +#include <linux/slab.h>
> +#include <linux/platform_device.h>
> +#include <linux/dma-mapping.h>
> +#include <linux/mtd/mtd.h>
> +#include <linux/mtd/nand.h>
> +#include <linux/mtd/partitions.h>
> +#include <linux/mtd/concat.h>
> +#include <linux/dmaengine.h>
> +#include <asm/sizes.h>
> +
> +#include <mach/common.h>
> +#include <mach/dma.h>
> +#include <linux/mtd/gpmi-nand.h>
> +#include <mach/system.h>
> +#include <mach/clock.h>
> +
> +/* The collection of resources the driver needs. */
> +struct resources {
> +	void          *gpmi_regs;
> +	void          *bch_regs;
> +	unsigned int  bch_low_interrupt;
> +	unsigned int  bch_high_interrupt;
> +	unsigned int  dma_low_channel;
> +	unsigned int  dma_high_channel;
> +	struct clk    *clock;
> +};
> +
> +/**
> + * struct mil - State for the MTD Interface Layer.
> + *
> + * @nand:                    The NAND Flash MTD data structure that
> represents + *                           the NAND Flash medium.
> + * @mtd:                     The MTD data structure that represents the
> NAND + *                           Flash medium.
> + * @oob_layout:              A structure that describes how bytes are laid
> out + *                           in the OOB.
> + * @partitions:              A pointer to a set of partitions.
> + * @partition_count:         The number of partitions.
> + * @current_chip:            The chip currently selected by the NAND Fash
> MTD + *                           code. A negative value indicates that no
> chip is + *                           selected.
> + * @command_length:          The length of the command that appears in the
> + *                           command buffer (see cmd_virt, below).
> + * @ignore_bad_block_marks:  Indicates we are ignoring bad block marks.
> + * @upper_buf:               The buffer passed from upper layer.
> + * @upper_len:               The buffer len passed from upper layer.
> + * @direct_dma_map_ok:       Is the direct DMA map is good for the
> upper_buf? + * @cmd_sgl/cmd_buffer:      For NAND command.
> + * @data_sgl/data_buffer_dma:For NAND DATA ops.
> + * @page_buffer_virt:        A pointer to a DMA-coherent buffer we use for
> + *                           reading and writing pages. This buffer
> includes + *                           space for both the payload data and
> the auxiliary + *                           data (including status bytes,
> but not syndrome + *                           bytes).
> + * @page_buffer_phys:        The physical address for the page_buffer_virt
> + *                           buffer.
> + * @page_buffer_size:        The size of the page buffer.
> + * @payload_virt:            A pointer to a location in the page buffer
> used + *                           for payload bytes. The size of this
> buffer is + *                           determined by struct bch_geometry.
> + * @payload_phys:            The physical address for payload_virt.
> + * @auxiliary_virt:          A pointer to a location in the page buffer
> used + *                           for auxiliary bytes. The size of this
> buffer is + *                           determined by struct bch_geometry.
> + * @auxiliary_phys:          The physical address for auxiliary_virt.
> + */
> +struct mil {
> +	/* MTD Data Structures */
> +	struct nand_chip       nand;
> +	struct mtd_info        mtd;
> +	struct nand_ecclayout  oob_layout;
> +
> +	/* Partitions*/
> +	struct mtd_partition   *partitions;
> +	unsigned int           partition_count;
> +
> +	/* General-use Variables */
> +	int                    current_chip;
> +	unsigned int           command_length;
> +	int                    ignore_bad_block_marks;
> +
> +	/* from upper layer */
> +	uint8_t			*upper_buf;
> +	int			upper_len;
> +
> +	/* DMA */
> +	bool			direct_dma_map_ok;
> +
> +	struct scatterlist	cmd_sgl;
> +	char			*cmd_buffer;
> +
> +	struct scatterlist	data_sgl;
> +	char			*data_buffer_dma;
> +
> +	void                   *page_buffer_virt;
> +	dma_addr_t             page_buffer_phys;
> +	unsigned int           page_buffer_size;
> +
> +	void                   *payload_virt;
> +	dma_addr_t             payload_phys;
> +
> +	void                   *auxiliary_virt;
> +	dma_addr_t             auxiliary_phys;
> +};
> +
> +/**
> + * struct bch_geometry - NFC geometry description.
> + *
> + * This structure describes the NFC's view of the medium geometry.
> + *
> + * @ecc_algorithm:            The human-readable name of the ECC algorithm
> + *                            (e.g., "Reed-Solomon" or "BCH").
> + * @ecc_strength:             A number that describes the strength of the
> ECC + *                            algorithm.
> + * @page_size_in_bytes:       The size, in bytes, of a physical page,
> including + *                            both data and OOB.
> + * @metadata_size_in_bytes:   The size, in bytes, of the metadata.
> + * @ecc_chunk_size_in_bytes:  The size, in bytes, of a single ECC chunk.
> Note + *                            the first chunk in the page includes
> both data and + *                            metadata, so it's a bit
> larger than this value. + * @ecc_chunk_count:          The number of ECC
> chunks in the page, + * @payload_size_in_bytes:    The size, in bytes, of
> the payload buffer. + * @auxiliary_size_in_bytes:  The size, in bytes, of
> the auxiliary buffer. + * @auxiliary_status_offset:  The offset into the
> auxiliary buffer at which + *                            the ECC status
> appears.
> + * @block_mark_byte_offset:   The byte offset in the ECC-based page view
> at + *                            which the underlying physical block mark
> appears. + * @block_mark_bit_offset:    The bit offset into the ECC-based
> page view at + *                            which the underlying physical
> block mark appears. + */
> +struct bch_geometry {
> +	char          *ecc_algorithm;
> +	unsigned int  ecc_strength;
> +	unsigned int  page_size_in_bytes;
> +	unsigned int  metadata_size_in_bytes;
> +	unsigned int  ecc_chunk_size_in_bytes;
> +	unsigned int  ecc_chunk_count;
> +	unsigned int  payload_size_in_bytes;
> +	unsigned int  auxiliary_size_in_bytes;
> +	unsigned int  auxiliary_status_offset;
> +	unsigned int  block_mark_byte_offset;
> +	unsigned int  block_mark_bit_offset;
> +};
> +
> +/**
> + * struct boot_rom_geometry - Boot ROM geometry description.
> + *
> + * @stride_size_in_pages:        The size of a boot block stride, in
> pages. + * @search_area_stride_exponent: The logarithm to base 2 of the
> size of a + *                               search area in boot block
> strides. + */
> +struct boot_rom_geometry {
> +	unsigned int  stride_size_in_pages;
> +	unsigned int  search_area_stride_exponent;
> +};
> +
> +/* DMA operations types */
> +enum dma_ops_type {
> +	DMA_FOR_COMMAND = 1,
> +	DMA_FOR_READ_DATA,
> +	DMA_FOR_WRITE_DATA,
> +	DMA_FOR_READ_ECC_PAGE,
> +	DMA_FOR_WRITE_ECC_PAGE
> +};
> +
> +/**
> + * This structure contains the fundamental timing attributes for NAND.
> + *
> + * @data_setup_in_ns:         The data setup time, in nanoseconds. Usually
> the + *                            maximum of tDS and tWP. A negative
> value + *                            indicates this characteristic isn't
> known. + * @data_hold_in_ns:          The data hold time, in nanoseconds.
> Usually the + *                            maximum of tDH, tWH and tREH. A
> negative value + *                            indicates this
> characteristic isn't known. + * @address_setup_in_ns:      The address
> setup time, in nanoseconds. Usually + *                            the
> maximum of tCLS, tCS and tALS. A negative + *                           
> value indicates this characteristic isn't known. + *
> @gpmi_sample_delay_in_ns:  A GPMI-specific timing parameter. A negative
> value + *                            indicates this characteristic isn't
> known. + * @tREA_in_ns:               tREA, in nanoseconds, from the data
> sheet. A + *                            negative value indicates this
> characteristic isn't + *                            known.
> + * @tRLOH_in_ns:              tRLOH, in nanoseconds, from the data sheet.
> A + *                            negative value indicates this
> characteristic isn't + *                            known.
> + * @tRHOH_in_ns:              tRHOH, in nanoseconds, from the data sheet.
> A + *                            negative value indicates this
> characteristic isn't + *                            known.
> + */
> +struct nand_timing {
> +	int8_t  data_setup_in_ns;
> +	int8_t  data_hold_in_ns;
> +	int8_t  address_setup_in_ns;
> +	int8_t  gpmi_sample_delay_in_ns;
> +	int8_t  tREA_in_ns;
> +	int8_t  tRLOH_in_ns;
> +	int8_t  tRHOH_in_ns;
> +};
> +
> +struct gpmi_nand_data {
> +	/* System Interface */
> +	struct device			*dev;
> +	struct platform_device		*pdev;
> +	struct gpmi_nand_platform_data	*pdata;
> +
> +	/* Resources */
> +	struct resources		resources;
> +
> +	/* Flash Hardware */
> +	struct nand_timing		timing;
> +
> +	/* BCH */
> +	struct bch_geometry		bch_geometry;
> +	struct completion		bch_done;
> +
> +	/* NAND Boot issue */
> +	bool				swap_block_mark;
> +	struct boot_rom_geometry	rom_geometry;
> +
> +	/* MTD Interface Layer */
> +	struct mil			mil;
> +
> +	/* DMA channels */
> +#define DMA_CHANS			8
> +	struct dma_chan			*dma_chans[DMA_CHANS];
> +	struct mxs_dma_data		dma_data;
> +	enum dma_ops_type		last_dma_type;
> +	enum dma_ops_type		dma_type;
> +	struct completion		dma_done;
> +
> +	/* private */
> +	void				*private;
> +};
> +
> +/**
> + * struct gpmi_nfc_hardware_timing - GPMI hardware timing parameters.
> + *
> + * This structure contains timing information expressed in a form directly
> + * usable by the GPMI hardware.
> + *
> + * @data_setup_in_cycles:      The data setup time, in cycles.
> + * @data_hold_in_cycles:       The data hold time, in cycles.
> + * @address_setup_in_cycles:   The address setup time, in cycles.
> + * @use_half_periods:          Indicates the clock is running slowly, so
> the + *                             NFC DLL should use half-periods.
> + * @sample_delay_factor:       The sample delay factor.
> + */
> +struct gpmi_nfc_hardware_timing {
> +	uint8_t  data_setup_in_cycles;
> +	uint8_t  data_hold_in_cycles;
> +	uint8_t  address_setup_in_cycles;
> +	bool     use_half_periods;
> +	uint8_t  sample_delay_factor;
> +};
> +
> +/**
> + * struct timing_threshod - timing threshold
> + *
> + * @max_data_setup_cycles:       The maximum number of data setup cycles
> that + *                               can be expressed in the hardware. +
> * @internal_data_setup_in_ns:   The time, in ns, that the NFC hardware
> requires + *                               for data read internal setup.
> In the Reference + *                               Manual, see the chapter
> "High-Speed NAND + *                               Timing" for more
> details.
> + * @max_sample_delay_factor:     The maximum sample delay factor that can
> be + *                               expressed in the hardware.
> + * @max_dll_clock_period_in_ns:  The maximum period of the GPMI clock that
> the + *                               sample delay DLL hardware can
> possibly work + *                               with (the DLL is unusable
> with longer periods). + *                               If the full-cycle
> period is greater than HALF + *                               this value,
> the DLL must be configured to use + *                              
> half-periods.
> + * @max_dll_delay_in_ns:         The maximum amount of delay, in ns, that
> the + *                               DLL can implement.
> + * @clock_frequency_in_hz:       The clock frequency, in Hz, during the
> current + *                               I/O transaction. If no I/O
> transaction is in + *                               progress, this is the
> clock frequency during + *                               the most recent
> I/O transaction. + */
> +struct timing_threshod {
> +	const unsigned int      max_chip_count;
> +	const unsigned int      max_data_setup_cycles;
> +	const unsigned int      internal_data_setup_in_ns;
> +	const unsigned int      max_sample_delay_factor;
> +	const unsigned int      max_dll_clock_period_in_ns;
> +	const unsigned int      max_dll_delay_in_ns;
> +	unsigned long           clock_frequency_in_hz;
> +
> +};
> +
> +/* Common Services */
> +extern int common_nfc_set_geometry(struct gpmi_nand_data *);
> +extern struct dma_chan *get_dma_chan(struct gpmi_nand_data *);
> +extern void prepare_data_dma(struct gpmi_nand_data *,
> +				enum dma_data_direction dr);
> +extern int start_dma_without_bch_irq(struct gpmi_nand_data *,
> +				struct dma_async_tx_descriptor *);
> +extern int start_dma_with_bch_irq(struct gpmi_nand_data *,
> +				struct dma_async_tx_descriptor *);
> +
> +/* GPMI-NAND helper function library */
> +extern int gpmi_init(struct gpmi_nand_data *);
> +extern void gpmi_clear_bch(struct gpmi_nand_data *);
> +extern void gpmi_show_regs(struct gpmi_nand_data *);
> +extern int bch_set_geometry(struct gpmi_nand_data *);
> +extern int gpmi_is_ready(struct gpmi_nand_data *, unsigned chip);
> +extern int gpmi_send_command(struct gpmi_nand_data *);
> +extern void gpmi_begin(struct gpmi_nand_data *);
> +extern void gpmi_end(struct gpmi_nand_data *);
> +extern int gpmi_read_data(struct gpmi_nand_data *);
> +extern int gpmi_send_data(struct gpmi_nand_data *);
> +extern int gpmi_send_page(struct gpmi_nand_data *,
> +			dma_addr_t payload, dma_addr_t auxiliary);
> +extern int gpmi_read_page(struct gpmi_nand_data *,
> +			dma_addr_t payload, dma_addr_t auxiliary);
> +
> +/* ONFI or TOGGLE nand */
> +bool is_ddr_nand(struct gpmi_nand_data *);
> +
> +/* for log */
> +extern int gpmi_debug;

Why this extern ?

> +#define GPMI_DEBUG_INIT		0x0001
> +#define GPMI_DEBUG_READ		0x0002
> +#define GPMI_DEBUG_WRITE	0x0004
> +#define GPMI_DEBUG_ECC_READ	0x0008
> +#define GPMI_DEBUG_ECC_WRITE	0x0010
> +#define GPMI_DEBUG_CRAZY	0x0020
> +
> +#ifdef pr_fmt
> +#undef pr_fmt
> +#endif
> +
> +#define pr_fmt(fmt) "[ %s : %.3d ] " fmt, __func__, __LINE__
> +
> +#define logio(level)				\
> +		do {				\
> +			if (gpmi_debug & level)	\
> +				pr_info("\n");	\
> +		} while (0)

Do you really need this ?

> +
> +/* BCH : Status Block Completion Codes */
> +#define STATUS_GOOD		0x00
> +#define STATUS_ERASED		0xff
> +#define STATUS_UNCORRECTABLE	0xfe
> +
> +/* Use the platform_id to distinguish different Archs. */
> +#define IS_MX23			0x1
> +#define IS_MX28			0x2
> +#define GPMI_IS_MX23(x)		((x)->pdev->id_entry->driver_data == IS_MX23)
> +#define GPMI_IS_MX28(x)		((x)->pdev->id_entry->driver_data == IS_MX28)
> +#endif

Cheers
Huang Shijie - Aug. 22, 2011, 4:34 a.m.
Hi,
> 1. You do not need to call parse_mtd_partitions() anymore - we re-worked
> the partitions registration in l2-mtd-2.6.git:
>
> http://git.infradead.org/users/dedekind/l2-mtd-2.6.git
>
thanks.
>> +static void show_bch_geometry(struct bch_geometry *geo)
>> +{
>> +	pr_info("---------------------------------------\n");
>> +	pr_info("	BCH Geometry\n");
>> +	pr_info("---------------------------------------\n");
> I think these "---" only consume memory in .data. This is the kernel and
> I think nice separators like this should be avoided.
>
ok. got it.
>> +	pr_info("ECC Algorithm          : %s\n", geo->ecc_algorithm);
>> +	pr_info("ECC Strength           : %u\n", geo->ecc_strength);
>> +	pr_info("Page Size in Bytes     : %u\n", geo->page_size_in_bytes);
>> +	pr_info("Metadata Size in Bytes : %u\n", geo->metadata_size_in_bytes);
>> +	pr_info("ECC Chunk Size in Bytes: %u\n", geo->ecc_chunk_size_in_bytes);
>> +	pr_info("ECC Chunk Count        : %u\n", geo->ecc_chunk_count);
>> +	pr_info("Payload Size in Bytes  : %u\n", geo->payload_size_in_bytes);
>> +	pr_info("Auxiliary Size in Bytes: %u\n", geo->auxiliary_size_in_bytes);
>> +	pr_info("Auxiliary Status Offset: %u\n", geo->auxiliary_status_offset);
>> +	pr_info("Block Mark Byte Offset : %u\n", geo->block_mark_byte_offset);
>> +	pr_info("Block Mark Bit Offset  : %u\n", geo->block_mark_bit_offset);
>> +}
> Isn't it too much info for normal users? Should this be pr_debug()
the log is only printed out when the bug occurs.
so it's not for normal users.
> instead? There is another similar place in your code.
>
ok, I will change to pr_debug().

thanks
Huang Shijie
> Artem.
>
>
Huang Shijie - Aug. 22, 2011, 4:59 a.m.
Hi,

thanks for your comments.
>> +
>> +static inline int get_ecc_chunk_size(struct gpmi_nand_data *this)
>> +{
>> +	/* for historical reason */
>> +	return 512;
>
> Can't we just #define this? Or will there ever be something else possible here ?
> I thought this is the only possible behaviour on MXS.
>
Please keep it here, it maybe changed in the future.
It ever had some code for ONFI nand, but i removed it.
>> +}
>> +
>> +int common_nfc_set_geometry(struct gpmi_nand_data *this)
>> +{
>> +	struct bch_geometry *geo =&this->bch_geometry;
>> +	struct mtd_info *mtd =&this->mil.mtd;
>> +	unsigned int metadata_size;
>> +	unsigned int status_size;
>> +	unsigned int chunk_data_size_in_bits;
>> +	unsigned int chunk_ecc_size_in_bits;
>> +	unsigned int chunk_total_size_in_bits;
>> +	unsigned int block_mark_chunk_number;
>> +	unsigned int block_mark_chunk_bit_offset;
>> +	unsigned int block_mark_bit_offset;
>> +	int gf_len = 13;/* use GP13 by default */
>> +
>> +	/* We only support BCH now. */
>> +	geo->ecc_algorithm = "BCH";
>> +
>> +	/*
>> +	 * We always choose a metadata size of 10. Don't try to make sense of
>> +	 * it -- this is really only for historical compatibility.
>> +	 */
> Historical compat or you mean "the chip was designed this way, see datasheet
> section x.y.z"? ;-)
>
Just for historical compatibility.
it's better to keep it as now, there is no need to change it.
>> +	geo->metadata_size_in_bytes = 10;
>> +
>> +	/* ECC chunks */
>> +	geo->ecc_chunk_size_in_bytes = get_ecc_chunk_size(this);
>> +
>> +	/*
>> +	 * Compute the total number of ECC chunks in a page. This includes the
>> +	 * slightly larger chunk at the beginning of the page, which contains
>> +	 * both data and metadata.
>> +	 */
>> +	geo->ecc_chunk_count = mtd->writesize / geo->ecc_chunk_size_in_bytes;
>> +
>> +	/*
>> +	 * We use the same ECC strength for all chunks, including the first one.
>> +	 */
>> +	geo->ecc_strength = get_ecc_strength(this);
>> +	if (!geo->ecc_strength) {
>> +		pr_info("Page size:%d, OOB:%d\n", mtd->writesize, mtd->oobsize);
>> +		return -EINVAL;
>> +	}
>> +
>> +	/* Compute the page size, include page and oob. */
>> +	geo->page_size_in_bytes = mtd->writesize + mtd->oobsize;
>> +	geo->payload_size_in_bytes = mtd->writesize;
>> +
>> +	/*
>> +	 * In principle, computing the auxiliary buffer geometry is NFC
>> +	 * version-specific. However, at this writing, all versions share the
>> +	 * same model, so this code can also be shared.
>> +	 *
>> +	 * The auxiliary buffer contains the metadata and the ECC status. The
>> +	 * metadata is padded to the nearest 32-bit boundary. The ECC status
>> +	 * contains one byte for every ECC chunk, and is also padded to the
>> +	 * nearest 32-bit boundary.
>> +	 */
>> +	metadata_size = ALIGN(geo->metadata_size_in_bytes, 4);
>> +	status_size   = ALIGN(geo->ecc_chunk_count, 4);
>> +
>> +	geo->auxiliary_size_in_bytes = metadata_size + status_size;
>> +	geo->auxiliary_status_offset = metadata_size;
>> +
>> +	/* Check if we're going to do block mark swapping. */
>> +	if (!this->swap_block_mark)
>> +		return 0;
>> +
>> +	/*
>> +	 * If control arrives here, we're doing block mark swapping, so we need
>> +	 * to compute the byte and bit offsets of the physical block mark within
>> +	 * the ECC-based view of the page data. In principle, this isn't a
>> +	 * difficult computation -- but it's very important and it's easy to get
>> +	 * it wrong, so we do it carefully.
>> +	 *
>> +	 * Note that this calculation is simpler because we use the same ECC
>> +	 * strength for all chunks, including the zero'th one, which contains
>> +	 * the metadata. The calculation would be slightly more complicated
>> +	 * otherwise.
>> +	 *
>> +	 * We start by computing the physical bit offset of the block mark. We
>> +	 * then subtract the number of metadata and ECC bits appearing before
>> +	 * the mark to arrive at its bit offset within the data alone.
>> +	 */
>> +
>> +	/* Compute some important facts about chunk geometry. */
>> +	chunk_data_size_in_bits = geo->ecc_chunk_size_in_bytes * 8;
>> +	chunk_ecc_size_in_bits  = geo->ecc_strength * gf_len;
>> +	chunk_total_size_in_bits = chunk_data_size_in_bits
>> +					+ chunk_ecc_size_in_bits;
>> +
>> +	/* Compute the bit offset of the block mark within the physical page. */
>> +	block_mark_bit_offset = mtd->writesize * 8;
>> +
>> +	/* Subtract the metadata bits. */
>> +	block_mark_bit_offset -= geo->metadata_size_in_bytes * 8;
>> +
>> +	/*
>> +	 * Compute the chunk number (starting at zero) in which the block mark
>> +	 * appears.
>> +	 */
>> +	block_mark_chunk_number =
>> +			block_mark_bit_offset / chunk_total_size_in_bits;
>> +
>> +	/*
>> +	 * Compute the bit offset of the block mark within its chunk, and
>> +	 * validate it.
>> +	 */
>> +	block_mark_chunk_bit_offset =
>> +		block_mark_bit_offset -
>> +			(block_mark_chunk_number * chunk_total_size_in_bits);
>> +
>> +	if (block_mark_chunk_bit_offset>  chunk_data_size_in_bits) {
>> +		/*
>> +		 * If control arrives here, the block mark actually appears in
>> +		 * the ECC bits of this chunk. This wont' work.
>> +		 */
>> +		pr_info("Unsupported page geometry : %u:%u\n",
>> +				mtd->writesize, mtd->oobsize);
>> +		return -EINVAL;
>> +	}
>> +
>> +	/*
>> +	 * Now that we know the chunk number in which the block mark appears,
>> +	 * we can subtract all the ECC bits that appear before it.
>> +	 */
>> +	block_mark_bit_offset -=
>> +			block_mark_chunk_number * chunk_ecc_size_in_bits;
>> +
>> +	/*
>> +	 * We now know the absolute bit offset of the block mark within the
>> +	 * ECC-based data. We can now compute the byte offset and the bit
>> +	 * offset within the byte.
>> +	 */
>> +	geo->block_mark_byte_offset = block_mark_bit_offset / 8;
>> +	geo->block_mark_bit_offset  = block_mark_bit_offset % 8;
>> +
>> +	return 0;
>> +}
>> +
>> +struct dma_chan *get_dma_chan(struct gpmi_nand_data *this)
>> +{
>> +	int chip = this->mil.current_chip;
>> +
>> +	BUG_ON(chip<  0);
>> +	return this->dma_chans[chip];
>> +}
>> +
>> +/* Can we use the upper's buffer directly for DMA? */
>> +void prepare_data_dma(struct gpmi_nand_data *this, enum dma_data_direction
>> dr) +{
>> +	struct mil *mil =&this->mil;
>> +	struct scatterlist *sgl =&mil->data_sgl;
> I still see the "MIL" present -- can't we just merge the library and this ?
>
the   `mil` is just a data structure to contain the fields now.
Maybe I should change the name of it.

>> +	int ret;
>> +
>> +	mil->direct_dma_map_ok = true;
>> +
>> +	/* first try to map the upper buffer directly */
>> +	sg_init_one(sgl, mil->upper_buf, mil->upper_len);
>> +	ret = dma_map_sg(this->dev, sgl, 1, dr);
>> +	if (ret == 0) {
>> +		/* We have to use our own DMA buffer. */
>> +		sg_init_one(sgl, mil->data_buffer_dma, PAGE_SIZE);
>> +
>> +		if (dr == DMA_TO_DEVICE)
>> +			memcpy(mil->data_buffer_dma, mil->upper_buf,
>> +				mil->upper_len);
>> +
>> +		ret = dma_map_sg(this->dev, sgl, 1, dr);
>> +		BUG_ON(ret == 0);
>> +
>> +		mil->direct_dma_map_ok = false;
>> +	}
>> +}
>> +
>> +/* This will be called after the DMA operation is finished. */
>> +static void dma_irq_callback(void *param)
>> +{
>> +	struct gpmi_nand_data *this = param;
>> +	struct mil *mil =&this->mil;
>> +	struct completion *dma_c =&this->dma_done;
>> +
>> +	complete(dma_c);
>> +
>> +	switch (this->dma_type) {
>> +	case DMA_FOR_COMMAND:
>> +		dma_unmap_sg(this->dev,&mil->cmd_sgl, 1, DMA_TO_DEVICE);
>> +		break;
>> +
>> +	case DMA_FOR_READ_DATA:
>> +		dma_unmap_sg(this->dev,&mil->data_sgl, 1, DMA_FROM_DEVICE);
>> +		if (mil->direct_dma_map_ok == false)
>> +			memcpy(mil->upper_buf, mil->data_buffer_dma,
>> +				mil->upper_len);
>> +		break;
>> +
>> +	case DMA_FOR_WRITE_DATA:
>> +		dma_unmap_sg(this->dev,&mil->data_sgl, 1, DMA_TO_DEVICE);
>> +		break;
>> +
>> +	case DMA_FOR_READ_ECC_PAGE:
>> +	case DMA_FOR_WRITE_ECC_PAGE:
>> +		/* We have to wait the BCH interrupt to finish. */
>> +		break;
>> +
>> +	default:
>> +		BUG();
>> +	}
>> +}
>> +
>> +static void show_bch_geometry(struct bch_geometry *geo)
>> +{
>> +	pr_info("---------------------------------------\n");
>> +	pr_info("	BCH Geometry\n");
>> +	pr_info("---------------------------------------\n");
>> +	pr_info("ECC Algorithm          : %s\n", geo->ecc_algorithm);
>> +	pr_info("ECC Strength           : %u\n", geo->ecc_strength);
>> +	pr_info("Page Size in Bytes     : %u\n", geo->page_size_in_bytes);
>> +	pr_info("Metadata Size in Bytes : %u\n", geo->metadata_size_in_bytes);
>> +	pr_info("ECC Chunk Size in Bytes: %u\n", geo->ecc_chunk_size_in_bytes);
>> +	pr_info("ECC Chunk Count        : %u\n", geo->ecc_chunk_count);
>> +	pr_info("Payload Size in Bytes  : %u\n", geo->payload_size_in_bytes);
>> +	pr_info("Auxiliary Size in Bytes: %u\n", geo->auxiliary_size_in_bytes);
>> +	pr_info("Auxiliary Status Offset: %u\n", geo->auxiliary_status_offset);
>> +	pr_info("Block Mark Byte Offset : %u\n", geo->block_mark_byte_offset);
>> +	pr_info("Block Mark Bit Offset  : %u\n", geo->block_mark_bit_offset);
>> +}
> We don't need this.
>
I just use it for debug.
Why do not need it? :)
I think it's useful to debug.
>> +
>> +int start_dma_without_bch_irq(struct gpmi_nand_data *this,
>> +				struct dma_async_tx_descriptor *desc)
>> +{
>> +	struct completion *dma_c =&this->dma_done;
>> +	int err;
>> +
>> +	init_completion(dma_c);
>> +
>> +	desc->callback		= dma_irq_callback;
>> +	desc->callback_param	= this;
>> +	dmaengine_submit(desc);
>> +
>> +	/* Wait for the interrupt from the DMA block. */
>> +	err = wait_for_completion_timeout(dma_c, msecs_to_jiffies(1000));
>> +	err = (!err) ? -ETIMEDOUT : 0;
>> +	if (err) {
>> +		pr_info("DMA timeout, last DMA :%d\n", this->last_dma_type);
>> +		if (gpmi_debug&  GPMI_DEBUG_CRAZY) {
>> +			struct bch_geometry *geo =&this->bch_geometry;
>> +
>> +			gpmi_show_regs(this);
>> +			show_bch_geometry(geo);
>> +			panic("-----------DMA FAILED------------------");
> No, dev_err() or something.
> \
ok, no problem.
> Also, I don't like you using pr_ stuff, I think you can use dev_ stuff, can't you?
>
>> +		}
>> +	}
>> +	return err;
>> +}
>> +
>> +/*
>> + * This function is used in BCH reading or BCH writing pages.
>> + * It will wait for the BCH interrupt as long as ONE second.
>> + * Actually, we must wait for two interrupts :
>> + *	[1] firstly the DMA interrupt and
>> + *	[2] secondly the BCH interrupt.
>> + *
>> + * @this:	Per-device data structure.
>> + * @desc:	DMA channel
> Does this conform to kerneldoc ?
>
it's redundant, i will remove the description for the parameters.
But keep the description for the function.
>> + */
>> +int start_dma_with_bch_irq(struct gpmi_nand_data *this,
>> +			struct dma_async_tx_descriptor *desc)
>> +{
>> +	int err;
>> +
>> +	/* Prepare to receive an interrupt from the BCH block. */
>> +	init_completion(&this->bch_done);
>> +
>> +	/* start the DMA */
>> +	start_dma_without_bch_irq(this, desc);
>> +
>> +	/* Wait for the interrupt from the BCH block. */
>> +	err = wait_for_completion_timeout(&this->bch_done,
>> +					msecs_to_jiffies(1000));
>> +	err = (!err) ? -ETIMEDOUT : 0;
>> +	if (err) {
>> +		pr_info("BCH timeout!!!\n");
> One ! is enough!!!
ok.
>> +		if (gpmi_debug&  GPMI_DEBUG_CRAZY) {
> GPMI_DEBUG_CRAZY should probably be GPMI_DEBUG_VERBOSE ?
>
ok, thanks
>> +			struct bch_geometry *geo =&this->bch_geometry;
>> +
>> +			gpmi_show_regs(this);
>> +			show_bch_geometry(geo);
>> +			panic("-----------BCH FAILED------------------");
> dev_err()
>
>> +		}
>> +	}
>> +	return err;
>> +}
>> +
>> +static int __devinit acquire_register_block(struct gpmi_nand_data *this,
>> +			const char *resource_name, void **reg_block_base)
>> +{
>> +	struct platform_device *pdev = this->pdev;
>> +	struct resource *r;
>> +	void *p;
>> +
>> +	r = platform_get_resource_byname(pdev, IORESOURCE_MEM, resource_name);
>> +	if (!r) {
>> +		pr_info("Can't get resource for %s\n", resource_name);
>> +		return -ENXIO;
>> +	}
>> +
>> +	/* remap the register block */
>> +	p = ioremap(r->start, resource_size(r));
>> +	if (!p) {
>> +		pr_info("Can't remap %s\n", resource_name);
>> +		return -ENOMEM;
>> +	}
>> +
>> +	*reg_block_base = p;
>> +	return 0;
>> +}
>> +
>> +static void release_register_block(struct gpmi_nand_data *this,
>> +				void *reg_block_base)
>> +{
>> +	iounmap(reg_block_base);
>> +}
>> +
>> +static int __devinit acquire_interrupt(struct gpmi_nand_data *this,
>> +			const char *resource_name,
>> +			irq_handler_t interrupt_handler, int *lno, int *hno)
>> +{
>> +	struct platform_device *pdev = this->pdev;
>> +	struct resource *r;
>> +	int err;
>> +
>> +	r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, resource_name);
>> +	if (!r) {
>> +		pr_info("Can't get resource for %s\n", resource_name);
>> +		return -ENXIO;
>> +	}
>> +
>> +	BUG_ON(r->start != r->end);
>> +	err = request_irq(r->start, interrupt_handler, 0, resource_name, this);
>> +	if (err) {
>> +		pr_info("Can't own %s\n", resource_name);
>> +		return err;
>> +	}
>> +
>> +	*lno = r->start;
>> +	*hno = r->end;
>> +	return 0;
>> +}
>> +
>>
>> +
>> +static int __devinit acquire_resources(struct gpmi_nand_data *this)
>> +{
>> +	struct resources *r =&this->resources;
>> +	int error;
>> +
>> +	/* Attempt to acquire the GPMI register block. */
>> +	error = acquire_register_block(this,
>> +				GPMI_NAND_GPMI_REGS_ADDR_RES_NAME,
>> +				&r->gpmi_regs);
> You're already passing "this", why pass r->gpmi_regs? Please fix globally.
>
ok, thanks
>
>> +static int gpmi_dev_ready(struct mtd_info *mtd)
>> +{
>> +	struct nand_chip *nand = mtd->priv;
>> +	struct gpmi_nand_data *this = nand->priv;
>> +	struct mil *mil =&this->mil;
>> +
>> +	return gpmi_is_ready(this, mil->current_chip);
>> +}
>> +
>> +static void gpmi_select_chip(struct mtd_info *mtd, int chip)
>> +{
>> +	struct nand_chip *nand = mtd->priv;
>> +	struct gpmi_nand_data *this = nand->priv;
>> +	struct mil *mil =&this->mil;
>> +
>> +	if ((mil->current_chip<  0)&&  (chip>= 0))
>> +		gpmi_begin(this);
>> +	else if ((mil->current_chip>= 0)&&  (chip<  0))
>> +		gpmi_end(this);
>> +	else
>> +		;
> Do you need this else branch at all?
>
It needs a warning here.
>> +
>> +	mil->current_chip = chip;
>> +}
>> +
>> +static void gpmi_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
>> +{
>> +	struct nand_chip *nand = mtd->priv;
>> +	struct gpmi_nand_data *this = nand->priv;
>> +	struct mil *mil =&this->mil;
>> +
>> +	logio(GPMI_DEBUG_READ);
>> +	/* save the info in mil{} for future */
>> +	mil->upper_buf	= buf;
>> +	mil->upper_len	= len;
>> +
>> +	gpmi_read_data(this);
>> +}
>> +
>> +static void gpmi_write_buf(struct mtd_info *mtd, const uint8_t *buf, int
>> len) +{
>> +	struct nand_chip *nand = mtd->priv;
>> +	struct gpmi_nand_data *this = nand->priv;
>> +	struct mil *mil =&this->mil;
>> +
>> +	logio(GPMI_DEBUG_WRITE);
>> +	/* save the info in mil{} for future */
>> +	mil->upper_buf	= (uint8_t *)buf;
>> +	mil->upper_len	= len;
>> +
>> +	gpmi_send_data(this);
>> +}
>> +
>> +static uint8_t gpmi_read_byte(struct mtd_info *mtd)
>> +{
>> +	struct nand_chip *nand = mtd->priv;
>> +	struct gpmi_nand_data *this = nand->priv;
>> +	struct mil *mil =&this->mil;
>> +	uint8_t *buf = mil->data_buffer_dma;
>> +
>> +	gpmi_read_buf(mtd, buf, 1);
>> +	return buf[0];
>> +}
>> +
>>
>> +static int gpmi_block_markbad(struct mtd_info *mtd, loff_t ofs)
>> +{
>> +	struct nand_chip *nand = mtd->priv;
>> +	struct gpmi_nand_data *this = nand->priv;
>> +	int block, ret = 0;
>> +
>> +	/* Get block number */
>> +	block = (int)(ofs>>  nand->bbt_erase_shift);
>> +	if (nand->bbt)
>> +		nand->bbt[block>>  2] |= 0x01<<  ((block&  0x03)<<  1);
>> +
>> +	/* Do we have a flash based bad block table ? */
>> +	if (nand->options&  NAND_USE_FLASH_BBT)
>> +		ret = nand_update_bbt(mtd, ofs);
> if (stuff)
> 	return nand_update_bbt();
>
I can not return it here, I need to update the ecc_stats too.
> stuff from else branch
> .
> .
> .
>
> Besides, please don't declare variables in the middle of code.
>
why?
it's no harm to declare the variables in the {}.

>> +	else {
>> +		struct mil *mil	=&this->mil;
>> +		uint8_t *block_mark;
>> +		int column, page, status, chipnr;
>> +
>> +		chipnr = (int)(ofs>>  nand->chip_shift);
>> +		nand->select_chip(mtd, chipnr);
>> +
>> +		column = this->swap_block_mark ? mtd->writesize : 0;
>> +
>> +		/* Write the block mark. */
>> +		block_mark = mil->data_buffer_dma;
>> +		block_mark[0] = 0; /* bad block marker */
>> +
>> +		/* Shift to get page */
>> +		page = (int)(ofs>>  nand->page_shift);
>> +
>> +		nand->cmdfunc(mtd, NAND_CMD_SEQIN, column, page);
>> +		nand->write_buf(mtd, block_mark, 1);
>> +		nand->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
>> +
>> +		status = nand->waitfunc(mtd, nand);
>> +		if (status&  NAND_STATUS_FAIL)
>> +			ret = -EIO;
>> +
>> +		nand->select_chip(mtd, -1);
>> +	}
>> +	if (!ret)
>> +		mtd->ecc_stats.badblocks++;
>> +
>> +	return ret;
>> +}
>> +
>> +static int __devinit nand_boot_set_geometry(struct gpmi_nand_data *this)
>> +{
>> +	struct boot_rom_geometry *geometry =&this->rom_geometry;
>> +
>> +	/*
>> +	 * Set the boot block stride size.
>> +	 *
>> +	 * In principle, we should be reading this from the OTP bits, since
>> +	 * that's where the ROM is going to get it. In fact, we don't have any
>> +	 * way to read the OTP bits, so we go with the default and hope for the
>> +	 * best.
>> +	 */
>> +	geometry->stride_size_in_pages = 64;
>> +
>> +	/*
>> +	 * Set the search area stride exponent.
>> +	 *
>> +	 * In principle, we should be reading this from the OTP bits, since
>> +	 * that's where the ROM is going to get it. In fact, we don't have any
>> +	 * way to read the OTP bits, so we go with the default and hope for the
>> +	 * best.
>> +	 */
>> +	geometry->search_area_stride_exponent = 2;
>> +
>> +	if (gpmi_debug&  GPMI_DEBUG_INIT)
>> +		pr_info("stride size in page : %d, search areas : %d\n",
>> +			geometry->stride_size_in_pages,
>> +			geometry->search_area_stride_exponent);
>> +	return 0;
>> +}
>> +
>> +static const char  *fingerprint = "STMP";
>> +static int __devinit mx23_check_transcription_stamp(struct gpmi_nand_data
>> *this) +{
>> +	struct boot_rom_geometry *rom_geo =&this->rom_geometry;
>> +	struct mil *mil =&this->mil;
>> +	struct mtd_info *mtd =&mil->mtd;
>> +	struct nand_chip *nand =&mil->nand;
>> +	unsigned int search_area_size_in_strides;
>> +	unsigned int stride;
>> +	unsigned int page;
>> +	loff_t byte;
>> +	uint8_t *buffer = nand->buffers->databuf;
>> +	int saved_chip_number;
>> +	int found_an_ncb_fingerprint = false;
>> +
>> +	/* Compute the number of strides in a search area. */
>> +	search_area_size_in_strides = 1<<  rom_geo->search_area_stride_exponent;
>> +
>> +	/* Select chip 0. */
>> +	saved_chip_number = mil->current_chip;
>> +	nand->select_chip(mtd, 0);
>> +
>> +	/*
>> +	 * Loop through the first search area, looking for the NCB fingerprint.
>> +	 */
>> +	pr_info("Scanning for an NCB fingerprint...\n");
>> +
>> +	for (stride = 0; stride<  search_area_size_in_strides; stride++) {
>> +		/* Compute the page and byte addresses. */
>> +		page = stride * rom_geo->stride_size_in_pages;
>> +		byte = page   * mtd->writesize;
>> +
>> +		pr_info("  Looking for a fingerprint in page 0x%x\n", page);
> pr_info? Why, who cares, I'd prefer dev_dbg()?
>
thanks
>> +
>> +		/*
>> +		 * Read the NCB fingerprint. The fingerprint is four bytes long
>> +		 * and starts in the 12th byte of the page.
>> +		 */
>> +		nand->cmdfunc(mtd, NAND_CMD_READ0, 12, page);
>> +		nand->read_buf(mtd, buffer, strlen(fingerprint));
>> +
>> +		/* Look for the fingerprint. */
>> +		if (!memcmp(buffer, fingerprint, strlen(fingerprint))) {
>> +			found_an_ncb_fingerprint = true;
>> +			break;
>> +		}
>> +
>> +	}
>> +
>> +	/* Deselect chip 0. */
>> +	nand->select_chip(mtd, saved_chip_number);
>> +
>> +	if (found_an_ncb_fingerprint)
>> +		pr_info("  Found a fingerprint\n");
>> +	else
>> +		pr_info("  No fingerprint found\n");
>> +	return found_an_ncb_fingerprint;
>> +}
>> +
>> +/* Writes a transcription stamp. */
>> +static int __devinit mx23_write_transcription_stamp(struct gpmi_nand_data
>> *this) +{
>> +	struct device *dev = this->dev;
>> +	struct boot_rom_geometry *rom_geo =&this->rom_geometry;
>> +	struct mil *mil =&this->mil;
>> +	struct mtd_info *mtd =&mil->mtd;
>> +	struct nand_chip *nand =&mil->nand;
>> +	unsigned int block_size_in_pages;
>> +	unsigned int search_area_size_in_strides;
>> +	unsigned int search_area_size_in_pages;
>> +	unsigned int search_area_size_in_blocks;
>> +	unsigned int block;
>> +	unsigned int stride;
>> +	unsigned int page;
>> +	loff_t       byte;
>> +	uint8_t      *buffer = nand->buffers->databuf;
>> +	int saved_chip_number;
>> +	int status;
>> +
>> +	/* Compute the search area geometry. */
>> +	block_size_in_pages = mtd->erasesize / mtd->writesize;
>> +	search_area_size_in_strides = 1<<  rom_geo->search_area_stride_exponent;
>> +	search_area_size_in_pages = search_area_size_in_strides *
>> +					rom_geo->stride_size_in_pages;
>> +	search_area_size_in_blocks =
>> +		  (search_area_size_in_pages + (block_size_in_pages - 1)) /
>> +				    block_size_in_pages;
>> +
>> +	pr_info("-------------------------------------------\n");
>> +	pr_info("Search Area Geometry\n");
>> +	pr_info("-------------------------------------------\n");
>> +	pr_info("Search Area in Blocks : %u\n", search_area_size_in_blocks);
>> +	pr_info("Search Area in Strides: %u\n", search_area_size_in_strides);
>> +	pr_info("Search Area in Pages  : %u\n", search_area_size_in_pages);
> Maybe if you debug it, yes ... but I certainly don't want such ascii-art in my
> log during normal operation.
>
ok.
>> addr_t auxiliary);
>> +
>> +/* ONFI or TOGGLE nand */
>> +bool is_ddr_nand(struct gpmi_nand_data *);
>> +
>> +/* for log */
>> +extern int gpmi_debug;
> Why this extern ?
>
this header can be included by gpmi-nand.c and gpmi-lib.c.

>> +#define GPMI_DEBUG_INIT		0x0001
>> +#define GPMI_DEBUG_READ		0x0002
>> +#define GPMI_DEBUG_WRITE	0x0004
>> +#define GPMI_DEBUG_ECC_READ	0x0008
>> +#define GPMI_DEBUG_ECC_WRITE	0x0010
>> +#define GPMI_DEBUG_CRAZY	0x0020
>> +
>> +#ifdef pr_fmt
>> +#undef pr_fmt
>> +#endif
>> +
>> +#define pr_fmt(fmt) "[ %s : %.3d ] " fmt, __func__, __LINE__
>> +
>> +#define logio(level)				\
>> +		do {				\
>> +			if (gpmi_debug&  level)	\
>> +				pr_info("\n");	\
>> +		} while (0)
> Do you really need this ?
>
not really.

thanks

Huang Shijie
Artem Bityutskiy - Aug. 22, 2011, 6:26 a.m.
On Mon, 2011-08-22 at 12:34 +0800, Huang Shijie wrote:
> >> +	pr_info("ECC Algorithm          : %s\n", geo->ecc_algorithm);
> >> +	pr_info("ECC Strength           : %u\n", geo->ecc_strength);
> >> +	pr_info("Page Size in Bytes     : %u\n", geo->page_size_in_bytes);
> >> +	pr_info("Metadata Size in Bytes : %u\n", geo->metadata_size_in_bytes);
> >> +	pr_info("ECC Chunk Size in Bytes: %u\n", geo->ecc_chunk_size_in_bytes);
> >> +	pr_info("ECC Chunk Count        : %u\n", geo->ecc_chunk_count);
> >> +	pr_info("Payload Size in Bytes  : %u\n", geo->payload_size_in_bytes);
> >> +	pr_info("Auxiliary Size in Bytes: %u\n", geo->auxiliary_size_in_bytes);
> >> +	pr_info("Auxiliary Status Offset: %u\n", geo->auxiliary_status_offset);
> >> +	pr_info("Block Mark Byte Offset : %u\n", geo->block_mark_byte_offset);
> >> +	pr_info("Block Mark Bit Offset  : %u\n", geo->block_mark_bit_offset);
> >> +}
> > Isn't it too much info for normal users? Should this be pr_debug()
> the log is only printed out when the bug occurs.
> so it's not for normal users.
> > instead? There is another similar place in your code.
> >
> ok, I will change to pr_debug().

I did not read the driver code carefully, so did not realize this is
printed only in case of a bug - I thought this is printed on every boot
up. For the bug case it may be OK to use pr_info as well, so I take back
by comment about using pr_debug(), apologies.
Huang Shijie - Aug. 22, 2011, 6:45 a.m.
Hi Artem:
> On Mon, 2011-08-22 at 12:34 +0800, Huang Shijie wrote:
>>>> +	pr_info("ECC Algorithm          : %s\n", geo->ecc_algorithm);
>>>> +	pr_info("ECC Strength           : %u\n", geo->ecc_strength);
>>>> +	pr_info("Page Size in Bytes     : %u\n", geo->page_size_in_bytes);
>>>> +	pr_info("Metadata Size in Bytes : %u\n", geo->metadata_size_in_bytes);
>>>> +	pr_info("ECC Chunk Size in Bytes: %u\n", geo->ecc_chunk_size_in_bytes);
>>>> +	pr_info("ECC Chunk Count        : %u\n", geo->ecc_chunk_count);
>>>> +	pr_info("Payload Size in Bytes  : %u\n", geo->payload_size_in_bytes);
>>>> +	pr_info("Auxiliary Size in Bytes: %u\n", geo->auxiliary_size_in_bytes);
>>>> +	pr_info("Auxiliary Status Offset: %u\n", geo->auxiliary_status_offset);
>>>> +	pr_info("Block Mark Byte Offset : %u\n", geo->block_mark_byte_offset);
>>>> +	pr_info("Block Mark Bit Offset  : %u\n", geo->block_mark_bit_offset);
>>>> +}
>>> Isn't it too much info for normal users? Should this be pr_debug()
>> the log is only printed out when the bug occurs.
>> so it's not for normal users.
>>> instead? There is another similar place in your code.
>>>
>> ok, I will change to pr_debug().
> I did not read the driver code carefully, so did not realize this is
> printed only in case of a bug - I thought this is printed on every boot
> up. For the bug case it may be OK to use pr_info as well, so I take back
> by comment about using pr_debug(), apologies.
>
thank you all the same :)

Huang Shijie
Marek Vasut - Aug. 22, 2011, 1:09 p.m.
On Monday, August 22, 2011 06:59:11 AM Huang Shijie wrote:
> Hi,
> 
> thanks for your comments.
> 
> >> +
> >> +static inline int get_ecc_chunk_size(struct gpmi_nand_data *this)
> >> +{
> >> +	/* for historical reason */
> >> +	return 512;
> > 
> > Can't we just #define this? Or will there ever be something else possible
> > here ? I thought this is the only possible behaviour on MXS.
> 
> Please keep it here, it maybe changed in the future.
> It ever had some code for ONFI nand, but i removed it.

well if you #define it now, you can always replace the defined value with a 
function later.

> 
> >> +}
> >> +
> >> +int common_nfc_set_geometry(struct gpmi_nand_data *this)
> >> +{
> >> +	struct bch_geometry *geo =&this->bch_geometry;
> >> +	struct mtd_info *mtd =&this->mil.mtd;
> >> +	unsigned int metadata_size;
> >> +	unsigned int status_size;
> >> +	unsigned int chunk_data_size_in_bits;
> >> +	unsigned int chunk_ecc_size_in_bits;
> >> +	unsigned int chunk_total_size_in_bits;
> >> +	unsigned int block_mark_chunk_number;
> >> +	unsigned int block_mark_chunk_bit_offset;
> >> +	unsigned int block_mark_bit_offset;
> >> +	int gf_len = 13;/* use GP13 by default */
> >> +
> >> +	/* We only support BCH now. */
> >> +	geo->ecc_algorithm = "BCH";
> >> +
> >> +	/*
> >> +	 * We always choose a metadata size of 10. Don't try to make sense of
> >> +	 * it -- this is really only for historical compatibility.
> >> +	 */
> > 
> > Historical compat or you mean "the chip was designed this way, see
> > datasheet section x.y.z"? ;-)
> 
> Just for historical compatibility.
> it's better to keep it as now, there is no need to change it.

I'm just trying to make sense of it ... from the docs, it seems like a chip 
design thing. So this is compat with STMP37xx and 36xx ? Or even something older 
and more obscure ?

> 
> >> +	geo->metadata_size_in_bytes = 10;
> >> +
> >> +	/* ECC chunks */
> >> +	geo->ecc_chunk_size_in_bytes = get_ecc_chunk_size(this);

 [ ... ] 

> >> +
> >> +/* Can we use the upper's buffer directly for DMA? */
> >> +void prepare_data_dma(struct gpmi_nand_data *this, enum
> >> dma_data_direction dr) +{
> >> +	struct mil *mil =&this->mil;
> >> +	struct scatterlist *sgl =&mil->data_sgl;
> > 
> > I still see the "MIL" present -- can't we just merge the library and this
> > ?
> 
> the   `mil` is just a data structure to contain the fields now.
> Maybe I should change the name of it.

Probably, I still have a feeling of this like it's the old freescale driver 
heritage and doesn't make sense now.

> 
> >> +	int ret;
> >> +
> >> +	mil->direct_dma_map_ok = true;

> >> +static void show_bch_geometry(struct bch_geometry *geo)
> >> +{
> >> +	pr_info("---------------------------------------\n");
> >> +	pr_info("	BCH Geometry\n");
> >> +	pr_info("---------------------------------------\n");
> >> +	pr_info("ECC Algorithm          : %s\n", geo->ecc_algorithm);
> >> +	pr_info("ECC Strength           : %u\n", geo->ecc_strength);
> >> +	pr_info("Page Size in Bytes     : %u\n", geo->page_size_in_bytes);
> >> +	pr_info("Metadata Size in Bytes : %u\n", geo->metadata_size_in_bytes);
> >> +	pr_info("ECC Chunk Size in Bytes: %u\n",
> >> geo->ecc_chunk_size_in_bytes); +	pr_info("ECC Chunk Count        :
> >> %u\n", geo->ecc_chunk_count); +	pr_info("Payload Size in Bytes  :
> >> %u\n", geo->payload_size_in_bytes); +	pr_info("Auxiliary Size in Bytes:
> >> %u\n", geo->auxiliary_size_in_bytes); +	pr_info("Auxiliary Status
> >> Offset: %u\n", geo->auxiliary_status_offset); +	pr_info("Block Mark
> >> Byte Offset : %u\n", geo->block_mark_byte_offset); +	pr_info("Block
> >> Mark Bit Offset  : %u\n", geo->block_mark_bit_offset); +}
> > 
> > We don't need this.
> 
> I just use it for debug.
> Why do not need it? :)
> I think it's useful to debug.

I want to use it, not debug it. I don't want to have it in dmesg. pr_info() is 
really unsuitable. Remove it, use pr_debug(), #define it in 
MXS_NAND_VERBOSE_DEBUG, which will be undefined at the begining of the file by 
default (probably the best approach). Someone who wants to debug this thing will 
just enable it.

> 
> >> +
> >> +int start_dma_without_bch_irq(struct gpmi_nand_data *this,
> >> +				struct dma_async_tx_descriptor *desc)
> >> +{
> >> +	struct completion *dma_c =&this->dma_done;
> >> +	int err;

[...]

> >> +
> >> +	if ((mil->current_chip<  0)&&  (chip>= 0))

btw. is the indent here OK?

> >> +		gpmi_begin(this);
> >> +	else if ((mil->current_chip>= 0)&&  (chip<  0))
> >> +		gpmi_end(this);
> >> +	else
> >> +		;
> > 
> > Do you need this else branch at all?
> 
> It needs a warning here.
> 
> >> +
> >> +	mil->current_chip = chip;
> >> +}
> >> +
> >> +static void gpmi_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
> >> +{
> >> +	struct nand_chip *nand = mtd->priv;
> >> +	struct gpmi_nand_data *this = nand->priv;
> >> +	struct mil *mil =&this->mil;
> >> +
> >> +	logio(GPMI_DEBUG_READ);
> >> +	/* save the info in mil{} for future */
> >> +	mil->upper_buf	= buf;
> >> +	mil->upper_len	= len;
> >> +
> >> +	gpmi_read_data(this);
> >> +}
> >> +
> >> +static void gpmi_write_buf(struct mtd_info *mtd, const uint8_t *buf,
> >> int len) +{
> >> +	struct nand_chip *nand = mtd->priv;
> >> +	struct gpmi_nand_data *this = nand->priv;
> >> +	struct mil *mil =&this->mil;
> >> +
> >> +	logio(GPMI_DEBUG_WRITE);
> >> +	/* save the info in mil{} for future */
> >> +	mil->upper_buf	= (uint8_t *)buf;
> >> +	mil->upper_len	= len;
> >> +
> >> +	gpmi_send_data(this);
> >> +}
> >> +
> >> +static uint8_t gpmi_read_byte(struct mtd_info *mtd)
> >> +{
> >> +	struct nand_chip *nand = mtd->priv;
> >> +	struct gpmi_nand_data *this = nand->priv;
> >> +	struct mil *mil =&this->mil;
> >> +	uint8_t *buf = mil->data_buffer_dma;
> >> +
> >> +	gpmi_read_buf(mtd, buf, 1);
> >> +	return buf[0];
> >> +}
> >> +
> >> 
> >> +static int gpmi_block_markbad(struct mtd_info *mtd, loff_t ofs)
> >> +{
> >> +	struct nand_chip *nand = mtd->priv;
> >> +	struct gpmi_nand_data *this = nand->priv;
> >> +	int block, ret = 0;
> >> +
> >> +	/* Get block number */
> >> +	block = (int)(ofs>>  nand->bbt_erase_shift);
> >> +	if (nand->bbt)
> >> +		nand->bbt[block>>  2] |= 0x01<<  ((block&  0x03)<<  1);
> >> +
> >> +	/* Do we have a flash based bad block table ? */
> >> +	if (nand->options&  NAND_USE_FLASH_BBT)
> >> +		ret = nand_update_bbt(mtd, ofs);
> > 
> > if (stuff)
> > 
> > 	return nand_update_bbt();
> 
> I can not return it here, I need to update the ecc_stats too.

You're right.

> 
> > stuff from else branch
> > .
> > .
> > .
> > 
> > Besides, please don't declare variables in the middle of code.
> 
> why?
> it's no harm to declare the variables in the {}.

And to find out what kind of variable it is, you can't just jump at the begining 
of the function, you need to navigate through the code ... that's bad and 
additional work for other people.

> 
> >> +	else {
> >> +		struct mil *mil	=&this->mil;
> >> +		uint8_t *block_mark;
> >> +		int column, page, status, chipnr;
> >> +
> >> +		chipnr = (int)(ofs>>  nand->chip_shift);
> >> +		nand->select_chip(mtd, chipnr);
> >> +
> >> +		column = this->swap_block_mark ? mtd->writesize : 0;
> >> +
> >> +		/* Write the block mark. */
> >> +		block_mark = mil->data_buffer_dma;
> >> +		block_mark[0] = 0; /* bad block marker */
> >> +
> >> +		/* Shift to get page */
> >> +		page = (int)(ofs>>  nand->page_shift);
> >> +
> >> +		nand->cmdfunc(mtd, NAND_CMD_SEQIN, column, page);
> >> +		nand->write_buf(mtd, block_mark, 1);
> >> +		nand->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
> >> +
> >> +		status = nand->waitfunc(mtd, nand);
> >> +		if (status&  NAND_STATUS_FAIL)
> >> +			ret = -EIO;
> >> +
> >> +		nand->select_chip(mtd, -1);
> >> +	}
> >> +	if (!ret)
> >> +		mtd->ecc_stats.badblocks++;
> >> +
> >> +	return ret;
> >> +}

[...]

> >> addr_t auxiliary);
> >> +
> >> +/* ONFI or TOGGLE nand */
> >> +bool is_ddr_nand(struct gpmi_nand_data *);
> >> +
> >> +/* for log */
> >> +extern int gpmi_debug;
> > 
> > Why this extern ?
> 
> this header can be included by gpmi-nand.c and gpmi-lib.c.

This is a peculiar one ... can't you -- for example -- hide this into driver 
data?

> 
> >> +#define GPMI_DEBUG_INIT		0x0001
> >> +#define GPMI_DEBUG_READ		0x0002
> >> +#define GPMI_DEBUG_WRITE	0x0004
> >> +#define GPMI_DEBUG_ECC_READ	0x0008
> >> +#define GPMI_DEBUG_ECC_WRITE	0x0010
> >> +#define GPMI_DEBUG_CRAZY	0x0020
> >> +
> >> +#ifdef pr_fmt
> >> +#undef pr_fmt
> >> +#endif
> >> +
> >> +#define pr_fmt(fmt) "[ %s : %.3d ] " fmt, __func__, __LINE__
> >> +
> >> +#define logio(level)				\
> >> +		do {				\
> >> +			if (gpmi_debug&  level)	\
> >> +				pr_info("\n");	\
> >> +		} while (0)
> > 
> > Do you really need this ?
> 
> not really.
> 
> thanks
> 
> Huang Shijie

Thanks! You're a great help with this driver. Please don't take my shouting at 
you personally ;-)

Cheers!
> 
> 
> _______________________________________________
> linux-arm-kernel mailing list
> linux-arm-kernel@lists.infradead.org
> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Marek Vasut - Aug. 22, 2011, 1:11 p.m.
On Monday, August 22, 2011 08:45:01 AM Huang Shijie wrote:
> Hi Artem:
> > On Mon, 2011-08-22 at 12:34 +0800, Huang Shijie wrote:
> >>>> +	pr_info("ECC Algorithm          : %s\n", geo->ecc_algorithm);
> >>>> +	pr_info("ECC Strength           : %u\n", geo->ecc_strength);
> >>>> +	pr_info("Page Size in Bytes     : %u\n", geo->page_size_in_bytes);
> >>>> +	pr_info("Metadata Size in Bytes : %u\n",
> >>>> geo->metadata_size_in_bytes); +	pr_info("ECC Chunk Size in Bytes:
> >>>> %u\n", geo->ecc_chunk_size_in_bytes); +	pr_info("ECC Chunk Count     
> >>>>   : %u\n", geo->ecc_chunk_count); +	pr_info("Payload Size in Bytes  :
> >>>> %u\n", geo->payload_size_in_bytes); +	pr_info("Auxiliary Size in
> >>>> Bytes: %u\n", geo->auxiliary_size_in_bytes); +	pr_info("Auxiliary
> >>>> Status Offset: %u\n", geo->auxiliary_status_offset); +	pr_info("Block
> >>>> Mark Byte Offset : %u\n", geo->block_mark_byte_offset);
> >>>> +	pr_info("Block Mark Bit Offset  : %u\n",
> >>>> geo->block_mark_bit_offset); +}
> >>> 
> >>> Isn't it too much info for normal users? Should this be pr_debug()
> >> 
> >> the log is only printed out when the bug occurs.
> >> so it's not for normal users.
> >> 
> >>> instead? There is another similar place in your code.
> >> 
> >> ok, I will change to pr_debug().
> > 
> > I did not read the driver code carefully, so did not realize this is
> > printed only in case of a bug - I thought this is printed on every boot
> > up. For the bug case it may be OK to use pr_info as well, so I take back
> > by comment about using pr_debug(), apologies.
> 
> thank you all the same :)

If this is printed only in case of bug, I agree with Artem.

Sorry Huang, cheers!

> 
> Huang Shijie
> 
> 
> 
> _______________________________________________
> linux-arm-kernel mailing list
> linux-arm-kernel@lists.infradead.org
> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Marek Vasut - Aug. 22, 2011, 1:11 p.m.
On Monday, August 22, 2011 03:11:16 PM Marek Vasut wrote:
> On Monday, August 22, 2011 08:45:01 AM Huang Shijie wrote:
> > Hi Artem:
> > > On Mon, 2011-08-22 at 12:34 +0800, Huang Shijie wrote:
> > >>>> +	pr_info("ECC Algorithm          : %s\n", geo->ecc_algorithm);
> > >>>> +	pr_info("ECC Strength           : %u\n", geo->ecc_strength);
> > >>>> +	pr_info("Page Size in Bytes     : %u\n", geo->page_size_in_bytes);
> > >>>> +	pr_info("Metadata Size in Bytes : %u\n",
> > >>>> geo->metadata_size_in_bytes); +	pr_info("ECC Chunk Size in Bytes:
> > >>>> %u\n", geo->ecc_chunk_size_in_bytes); +	pr_info("ECC Chunk Count
> > >>>> 
> > >>>>   : %u\n", geo->ecc_chunk_count); +	pr_info("Payload Size in Bytes  
:
> > >>>> %u\n", geo->payload_size_in_bytes); +	pr_info("Auxiliary Size in
> > >>>> Bytes: %u\n", geo->auxiliary_size_in_bytes); +	pr_info("Auxiliary
> > >>>> Status Offset: %u\n", geo->auxiliary_status_offset);
> > >>>> +	pr_info("Block Mark Byte Offset : %u\n",
> > >>>> geo->block_mark_byte_offset);
> > >>>> +	pr_info("Block Mark Bit Offset  : %u\n",
> > >>>> geo->block_mark_bit_offset); +}
> > >>> 
> > >>> Isn't it too much info for normal users? Should this be pr_debug()
> > >> 
> > >> the log is only printed out when the bug occurs.
> > >> so it's not for normal users.
> > >> 
> > >>> instead? There is another similar place in your code.
> > >> 
> > >> ok, I will change to pr_debug().
> > > 
> > > I did not read the driver code carefully, so did not realize this is
> > > printed only in case of a bug - I thought this is printed on every boot
> > > up. For the bug case it may be OK to use pr_info as well, so I take
> > > back by comment about using pr_debug(), apologies.
> > 
> > thank you all the same :)
> 
> If this is printed only in case of bug, I agree with Artem.

Maybe though, dev_err() would be more suitable.

> 
> Sorry Huang, cheers!
> 
> > Huang Shijie
> > 
> > 
> > 
> > _______________________________________________
> > linux-arm-kernel mailing list
> > linux-arm-kernel@lists.infradead.org
> > http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Huang Shijie - Aug. 22, 2011, 2 p.m.
hi,

On Mon, Aug 22, 2011 at 9:09 AM, Marek Vasut <marek.vasut@gmail.com> wrote:
> On Monday, August 22, 2011 06:59:11 AM Huang Shijie wrote:
>> Hi,
>>
>> thanks for your comments.
>>
>> >> +
>> >> +static inline int get_ecc_chunk_size(struct gpmi_nand_data *this)
>> >> +{
>> >> +  /* for historical reason */
>> >> +  return 512;
>> >
>> > Can't we just #define this? Or will there ever be something else possible
>> > here ? I thought this is the only possible behaviour on MXS.
>>
>> Please keep it here, it maybe changed in the future.
>> It ever had some code for ONFI nand, but i removed it.
>
> well if you #define it now, you can always replace the defined value with a
> function later.

ok.
>
>>
>> >> +}
>> >> +
>> >> +int common_nfc_set_geometry(struct gpmi_nand_data *this)
>> >> +{
>> >> +  struct bch_geometry *geo =&this->bch_geometry;
>> >> +  struct mtd_info *mtd =&this->mil.mtd;
>> >> +  unsigned int metadata_size;
>> >> +  unsigned int status_size;
>> >> +  unsigned int chunk_data_size_in_bits;
>> >> +  unsigned int chunk_ecc_size_in_bits;
>> >> +  unsigned int chunk_total_size_in_bits;
>> >> +  unsigned int block_mark_chunk_number;
>> >> +  unsigned int block_mark_chunk_bit_offset;
>> >> +  unsigned int block_mark_bit_offset;
>> >> +  int gf_len = 13;/* use GP13 by default */
>> >> +
>> >> +  /* We only support BCH now. */
>> >> +  geo->ecc_algorithm = "BCH";
>> >> +
>> >> +  /*
>> >> +   * We always choose a metadata size of 10. Don't try to make sense of
>> >> +   * it -- this is really only for historical compatibility.
>> >> +   */
>> >
>> > Historical compat or you mean "the chip was designed this way, see
>> > datasheet section x.y.z"? ;-)
>>
>> Just for historical compatibility.
>> it's better to keep it as now, there is no need to change it.
>
> I'm just trying to make sense of it ... from the docs, it seems like a chip
> design thing. So this is compat with STMP37xx and 36xx ? Or even something older
> and more obscure ?
>
it  seems the rom of the chip use the value.  I will check it tomorrow.

>>
>> >> +  geo->metadata_size_in_bytes = 10;
>> >> +
>> >> +  /* ECC chunks */
>> >> +  geo->ecc_chunk_size_in_bytes = get_ecc_chunk_size(this);
>
>  [ ... ]
>
>> >> +
>> >> +/* Can we use the upper's buffer directly for DMA? */
>> >> +void prepare_data_dma(struct gpmi_nand_data *this, enum
>> >> dma_data_direction dr) +{
>> >> +  struct mil *mil =&this->mil;
>> >> +  struct scatterlist *sgl =&mil->data_sgl;
>> >
>> > I still see the "MIL" present -- can't we just merge the library and this
>> > ?
>>
>> the   `mil` is just a data structure to contain the fields now.
>> Maybe I should change the name of it.
>
> Probably, I still have a feeling of this like it's the old freescale driver
> heritage and doesn't make sense now.

ok, I will change the name.

>
>>
>> >> +  int ret;
>> >> +
>> >> +  mil->direct_dma_map_ok = true;
>
>> >> +static void show_bch_geometry(struct bch_geometry *geo)
>> >> +{
>> >> +  pr_info("---------------------------------------\n");
>> >> +  pr_info("       BCH Geometry\n");
>> >> +  pr_info("---------------------------------------\n");
>> >> +  pr_info("ECC Algorithm          : %s\n", geo->ecc_algorithm);
>> >> +  pr_info("ECC Strength           : %u\n", geo->ecc_strength);
>> >> +  pr_info("Page Size in Bytes     : %u\n", geo->page_size_in_bytes);
>> >> +  pr_info("Metadata Size in Bytes : %u\n", geo->metadata_size_in_bytes);
>> >> +  pr_info("ECC Chunk Size in Bytes: %u\n",
>> >> geo->ecc_chunk_size_in_bytes); +   pr_info("ECC Chunk Count        :
>> >> %u\n", geo->ecc_chunk_count); +    pr_info("Payload Size in Bytes  :
>> >> %u\n", geo->payload_size_in_bytes); +      pr_info("Auxiliary Size in Bytes:
>> >> %u\n", geo->auxiliary_size_in_bytes); +    pr_info("Auxiliary Status
>> >> Offset: %u\n", geo->auxiliary_status_offset); +    pr_info("Block Mark
>> >> Byte Offset : %u\n", geo->block_mark_byte_offset); +       pr_info("Block
>> >> Mark Bit Offset  : %u\n", geo->block_mark_bit_offset); +}
>> >
>> > We don't need this.
>>
>> I just use it for debug.
>> Why do not need it? :)
>> I think it's useful to debug.
>
> I want to use it, not debug it. I don't want to have it in dmesg. pr_info() is
> really unsuitable. Remove it, use pr_debug(), #define it in
> MXS_NAND_VERBOSE_DEBUG, which will be undefined at the begining of the file by
> default (probably the best approach). Someone who wants to debug this thing will
> just enable it.
>
>>
>> >> +
>> >> +int start_dma_without_bch_irq(struct gpmi_nand_data *this,
>> >> +                          struct dma_async_tx_descriptor *desc)
>> >> +{
>> >> +  struct completion *dma_c =&this->dma_done;
>> >> +  int err;
>
> [...]
>
>> >> +
>> >> +  if ((mil->current_chip<  0)&&  (chip>= 0))
>
> btw. is the indent here OK?

I checked with the script ./script/checkpatch.
there is no error.

It's ok.

>
>> >> +          gpmi_begin(this);
>> >> +  else if ((mil->current_chip>= 0)&&  (chip<  0))
>> >> +          gpmi_end(this);
>> >> +  else
>> >> +          ;
>> >
>> > Do you need this else branch at all?
>>
>> It needs a warning here.
>>
>> >> +
>> >> +  mil->current_chip = chip;
>> >> +}
>> >> +
>> >> +static void gpmi_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
>> >> +{
>> >> +  struct nand_chip *nand = mtd->priv;
>> >> +  struct gpmi_nand_data *this = nand->priv;
>> >> +  struct mil *mil =&this->mil;
>> >> +
>> >> +  logio(GPMI_DEBUG_READ);
>> >> +  /* save the info in mil{} for future */
>> >> +  mil->upper_buf  = buf;
>> >> +  mil->upper_len  = len;
>> >> +
>> >> +  gpmi_read_data(this);
>> >> +}
>> >> +
>> >> +static void gpmi_write_buf(struct mtd_info *mtd, const uint8_t *buf,
>> >> int len) +{
>> >> +  struct nand_chip *nand = mtd->priv;
>> >> +  struct gpmi_nand_data *this = nand->priv;
>> >> +  struct mil *mil =&this->mil;
>> >> +
>> >> +  logio(GPMI_DEBUG_WRITE);
>> >> +  /* save the info in mil{} for future */
>> >> +  mil->upper_buf  = (uint8_t *)buf;
>> >> +  mil->upper_len  = len;
>> >> +
>> >> +  gpmi_send_data(this);
>> >> +}
>> >> +
>> >> +static uint8_t gpmi_read_byte(struct mtd_info *mtd)
>> >> +{
>> >> +  struct nand_chip *nand = mtd->priv;
>> >> +  struct gpmi_nand_data *this = nand->priv;
>> >> +  struct mil *mil =&this->mil;
>> >> +  uint8_t *buf = mil->data_buffer_dma;
>> >> +
>> >> +  gpmi_read_buf(mtd, buf, 1);
>> >> +  return buf[0];
>> >> +}
>> >> +
>> >>
>> >> +static int gpmi_block_markbad(struct mtd_info *mtd, loff_t ofs)
>> >> +{
>> >> +  struct nand_chip *nand = mtd->priv;
>> >> +  struct gpmi_nand_data *this = nand->priv;
>> >> +  int block, ret = 0;
>> >> +
>> >> +  /* Get block number */
>> >> +  block = (int)(ofs>>  nand->bbt_erase_shift);
>> >> +  if (nand->bbt)
>> >> +          nand->bbt[block>>  2] |= 0x01<<  ((block&  0x03)<<  1);
>> >> +
>> >> +  /* Do we have a flash based bad block table ? */
>> >> +  if (nand->options&  NAND_USE_FLASH_BBT)
>> >> +          ret = nand_update_bbt(mtd, ofs);
>> >
>> > if (stuff)
>> >
>> >     return nand_update_bbt();
>>
>> I can not return it here, I need to update the ecc_stats too.
>
> You're right.
>
>>
>> > stuff from else branch
>> > .
>> > .
>> > .
>> >
>> > Besides, please don't declare variables in the middle of code.
>>
>> why?
>> it's no harm to declare the variables in the {}.
>
> And to find out what kind of variable it is, you can't just jump at the begining
> of the function, you need to navigate through the code ... that's bad and
> additional work for other people.
>
thanks, got it.

>>
>> >> +  else {
>> >> +          struct mil *mil =&this->mil;
>> >> +          uint8_t *block_mark;
>> >> +          int column, page, status, chipnr;
>> >> +
>> >> +          chipnr = (int)(ofs>>  nand->chip_shift);
>> >> +          nand->select_chip(mtd, chipnr);
>> >> +
>> >> +          column = this->swap_block_mark ? mtd->writesize : 0;
>> >> +
>> >> +          /* Write the block mark. */
>> >> +          block_mark = mil->data_buffer_dma;
>> >> +          block_mark[0] = 0; /* bad block marker */
>> >> +
>> >> +          /* Shift to get page */
>> >> +          page = (int)(ofs>>  nand->page_shift);
>> >> +
>> >> +          nand->cmdfunc(mtd, NAND_CMD_SEQIN, column, page);
>> >> +          nand->write_buf(mtd, block_mark, 1);
>> >> +          nand->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
>> >> +
>> >> +          status = nand->waitfunc(mtd, nand);
>> >> +          if (status&  NAND_STATUS_FAIL)
>> >> +                  ret = -EIO;
>> >> +
>> >> +          nand->select_chip(mtd, -1);
>> >> +  }
>> >> +  if (!ret)
>> >> +          mtd->ecc_stats.badblocks++;
>> >> +
>> >> +  return ret;
>> >> +}
>
> [...]
>
>> >> addr_t auxiliary);
>> >> +
>> >> +/* ONFI or TOGGLE nand */
>> >> +bool is_ddr_nand(struct gpmi_nand_data *);
>> >> +
>> >> +/* for log */
>> >> +extern int gpmi_debug;
>> >
>> > Why this extern ?
>>
>> this header can be included by gpmi-nand.c and gpmi-lib.c.
>
> This is a peculiar one ... can't you -- for example -- hide this into driver
> data?
It's a parameter of the driver.
I use it to show different log.
I think it can not be hide into driver data :(

thanks

Huang Shijie
Marek Vasut - Aug. 22, 2011, 2:02 p.m.
On Monday, August 22, 2011 04:00:46 PM Huang Shijie wrote:
> hi,
> 
> On Mon, Aug 22, 2011 at 9:09 AM, Marek Vasut <marek.vasut@gmail.com> wrote:
> > On Monday, August 22, 2011 06:59:11 AM Huang Shijie wrote:
> >> Hi,
> >> 
> >> thanks for your comments.
> >> 
> >> >> +
> >> >> +static inline int get_ecc_chunk_size(struct gpmi_nand_data *this)
> >> >> +{
> >> >> +  /* for historical reason */
> >> >> +  return 512;
> >> > 
> >> > Can't we just #define this? Or will there ever be something else
> >> > possible here ? I thought this is the only possible behaviour on MXS.
> >> 
> >> Please keep it here, it maybe changed in the future.
> >> It ever had some code for ONFI nand, but i removed it.
> > 
> > well if you #define it now, you can always replace the defined value with
> > a function later.
> 
> ok.
> 
> >> >> +}
> >> >> +
> >> >> +int common_nfc_set_geometry(struct gpmi_nand_data *this)
> >> >> +{
> >> >> +  struct bch_geometry *geo =&this->bch_geometry;
> >> >> +  struct mtd_info *mtd =&this->mil.mtd;
> >> >> +  unsigned int metadata_size;
> >> >> +  unsigned int status_size;
> >> >> +  unsigned int chunk_data_size_in_bits;
> >> >> +  unsigned int chunk_ecc_size_in_bits;
> >> >> +  unsigned int chunk_total_size_in_bits;
> >> >> +  unsigned int block_mark_chunk_number;
> >> >> +  unsigned int block_mark_chunk_bit_offset;
> >> >> +  unsigned int block_mark_bit_offset;
> >> >> +  int gf_len = 13;/* use GP13 by default */
> >> >> +
> >> >> +  /* We only support BCH now. */
> >> >> +  geo->ecc_algorithm = "BCH";
> >> >> +
> >> >> +  /*
> >> >> +   * We always choose a metadata size of 10. Don't try to make sense
> >> >> of +   * it -- this is really only for historical compatibility. +  
> >> >> */
> >> > 
> >> > Historical compat or you mean "the chip was designed this way, see
> >> > datasheet section x.y.z"? ;-)
> >> 
> >> Just for historical compatibility.
> >> it's better to keep it as now, there is no need to change it.
> > 
> > I'm just trying to make sense of it ... from the docs, it seems like a
> > chip design thing. So this is compat with STMP37xx and 36xx ? Or even
> > something older and more obscure ?
> 
> it  seems the rom of the chip use the value.  I will check it tomorrow.
> 
> >> >> +  geo->metadata_size_in_bytes = 10;
> >> >> +
> >> >> +  /* ECC chunks */
> >> >> +  geo->ecc_chunk_size_in_bytes = get_ecc_chunk_size(this);
> > 
> >  [ ... ]
> > 
> >> >> +
> >> >> +/* Can we use the upper's buffer directly for DMA? */
> >> >> +void prepare_data_dma(struct gpmi_nand_data *this, enum
> >> >> dma_data_direction dr) +{
> >> >> +  struct mil *mil =&this->mil;
> >> >> +  struct scatterlist *sgl =&mil->data_sgl;
> >> > 
> >> > I still see the "MIL" present -- can't we just merge the library and
> >> > this ?
> >> 
> >> the   `mil` is just a data structure to contain the fields now.
> >> Maybe I should change the name of it.
> > 
> > Probably, I still have a feeling of this like it's the old freescale
> > driver heritage and doesn't make sense now.
> 
> ok, I will change the name.
> 
> >> >> +  int ret;
> >> >> +
> >> >> +  mil->direct_dma_map_ok = true;
> >> >> 
> >> >> +static void show_bch_geometry(struct bch_geometry *geo)
> >> >> +{
> >> >> +  pr_info("---------------------------------------\n");
> >> >> +  pr_info("       BCH Geometry\n");
> >> >> +  pr_info("---------------------------------------\n");
> >> >> +  pr_info("ECC Algorithm          : %s\n", geo->ecc_algorithm);
> >> >> +  pr_info("ECC Strength           : %u\n", geo->ecc_strength);
> >> >> +  pr_info("Page Size in Bytes     : %u\n", geo->page_size_in_bytes);
> >> >> +  pr_info("Metadata Size in Bytes : %u\n",
> >> >> geo->metadata_size_in_bytes); +  pr_info("ECC Chunk Size in Bytes:
> >> >> %u\n",
> >> >> geo->ecc_chunk_size_in_bytes); +   pr_info("ECC Chunk Count        :
> >> >> %u\n", geo->ecc_chunk_count); +    pr_info("Payload Size in Bytes  :
> >> >> %u\n", geo->payload_size_in_bytes); +      pr_info("Auxiliary Size in
> >> >> Bytes: %u\n", geo->auxiliary_size_in_bytes); +    pr_info("Auxiliary
> >> >> Status Offset: %u\n", geo->auxiliary_status_offset); +  
> >> >>  pr_info("Block Mark Byte Offset : %u\n",
> >> >> geo->block_mark_byte_offset); +       pr_info("Block Mark Bit Offset
> >> >>  : %u\n", geo->block_mark_bit_offset); +}
> >> > 
> >> > We don't need this.
> >> 
> >> I just use it for debug.
> >> Why do not need it? :)
> >> I think it's useful to debug.
> > 
> > I want to use it, not debug it. I don't want to have it in dmesg.
> > pr_info() is really unsuitable. Remove it, use pr_debug(), #define it in
> > MXS_NAND_VERBOSE_DEBUG, which will be undefined at the begining of the
> > file by default (probably the best approach). Someone who wants to debug
> > this thing will just enable it.
> > 
> >> >> +
> >> >> +int start_dma_without_bch_irq(struct gpmi_nand_data *this,
> >> >> +                          struct dma_async_tx_descriptor *desc)
> >> >> +{
> >> >> +  struct completion *dma_c =&this->dma_done;
> >> >> +  int err;
> > 
> > [...]
> > 
> >> >> +
> >> >> +  if ((mil->current_chip<  0)&&  (chip>= 0))
> > 
> > btw. is the indent here OK?
> 
> I checked with the script ./script/checkpatch.
> there is no error.
> 
> It's ok.
> 
> >> >> +          gpmi_begin(this);
> >> >> +  else if ((mil->current_chip>= 0)&&  (chip<  0))
> >> >> +          gpmi_end(this);
> >> >> +  else
> >> >> +          ;
> >> > 
> >> > Do you need this else branch at all?
> >> 
> >> It needs a warning here.
> >> 
> >> >> +
> >> >> +  mil->current_chip = chip;
> >> >> +}
> >> >> +
> >> >> +static void gpmi_read_buf(struct mtd_info *mtd, uint8_t *buf, int
> >> >> len) +{
> >> >> +  struct nand_chip *nand = mtd->priv;
> >> >> +  struct gpmi_nand_data *this = nand->priv;
> >> >> +  struct mil *mil =&this->mil;
> >> >> +
> >> >> +  logio(GPMI_DEBUG_READ);
> >> >> +  /* save the info in mil{} for future */
> >> >> +  mil->upper_buf  = buf;
> >> >> +  mil->upper_len  = len;
> >> >> +
> >> >> +  gpmi_read_data(this);
> >> >> +}
> >> >> +
> >> >> +static void gpmi_write_buf(struct mtd_info *mtd, const uint8_t *buf,
> >> >> int len) +{
> >> >> +  struct nand_chip *nand = mtd->priv;
> >> >> +  struct gpmi_nand_data *this = nand->priv;
> >> >> +  struct mil *mil =&this->mil;
> >> >> +
> >> >> +  logio(GPMI_DEBUG_WRITE);
> >> >> +  /* save the info in mil{} for future */
> >> >> +  mil->upper_buf  = (uint8_t *)buf;
> >> >> +  mil->upper_len  = len;
> >> >> +
> >> >> +  gpmi_send_data(this);
> >> >> +}
> >> >> +
> >> >> +static uint8_t gpmi_read_byte(struct mtd_info *mtd)
> >> >> +{
> >> >> +  struct nand_chip *nand = mtd->priv;
> >> >> +  struct gpmi_nand_data *this = nand->priv;
> >> >> +  struct mil *mil =&this->mil;
> >> >> +  uint8_t *buf = mil->data_buffer_dma;
> >> >> +
> >> >> +  gpmi_read_buf(mtd, buf, 1);
> >> >> +  return buf[0];
> >> >> +}
> >> >> +
> >> >> 
> >> >> +static int gpmi_block_markbad(struct mtd_info *mtd, loff_t ofs)
> >> >> +{
> >> >> +  struct nand_chip *nand = mtd->priv;
> >> >> +  struct gpmi_nand_data *this = nand->priv;
> >> >> +  int block, ret = 0;
> >> >> +
> >> >> +  /* Get block number */
> >> >> +  block = (int)(ofs>>  nand->bbt_erase_shift);
> >> >> +  if (nand->bbt)
> >> >> +          nand->bbt[block>>  2] |= 0x01<<  ((block&  0x03)<<  1);
> >> >> +
> >> >> +  /* Do we have a flash based bad block table ? */
> >> >> +  if (nand->options&  NAND_USE_FLASH_BBT)
> >> >> +          ret = nand_update_bbt(mtd, ofs);
> >> > 
> >> > if (stuff)
> >> > 
> >> >     return nand_update_bbt();
> >> 
> >> I can not return it here, I need to update the ecc_stats too.
> > 
> > You're right.
> > 
> >> > stuff from else branch
> >> > .
> >> > .
> >> > .
> >> > 
> >> > Besides, please don't declare variables in the middle of code.
> >> 
> >> why?
> >> it's no harm to declare the variables in the {}.
> > 
> > And to find out what kind of variable it is, you can't just jump at the
> > begining of the function, you need to navigate through the code ...
> > that's bad and additional work for other people.
> 
> thanks, got it.
> 
> >> >> +  else {
> >> >> +          struct mil *mil =&this->mil;
> >> >> +          uint8_t *block_mark;
> >> >> +          int column, page, status, chipnr;
> >> >> +
> >> >> +          chipnr = (int)(ofs>>  nand->chip_shift);
> >> >> +          nand->select_chip(mtd, chipnr);
> >> >> +
> >> >> +          column = this->swap_block_mark ? mtd->writesize : 0;
> >> >> +
> >> >> +          /* Write the block mark. */
> >> >> +          block_mark = mil->data_buffer_dma;
> >> >> +          block_mark[0] = 0; /* bad block marker */
> >> >> +
> >> >> +          /* Shift to get page */
> >> >> +          page = (int)(ofs>>  nand->page_shift);
> >> >> +
> >> >> +          nand->cmdfunc(mtd, NAND_CMD_SEQIN, column, page);
> >> >> +          nand->write_buf(mtd, block_mark, 1);
> >> >> +          nand->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
> >> >> +
> >> >> +          status = nand->waitfunc(mtd, nand);
> >> >> +          if (status&  NAND_STATUS_FAIL)
> >> >> +                  ret = -EIO;
> >> >> +
> >> >> +          nand->select_chip(mtd, -1);
> >> >> +  }
> >> >> +  if (!ret)
> >> >> +          mtd->ecc_stats.badblocks++;
> >> >> +
> >> >> +  return ret;
> >> >> +}
> > 
> > [...]
> > 
> >> >> addr_t auxiliary);
> >> >> +
> >> >> +/* ONFI or TOGGLE nand */
> >> >> +bool is_ddr_nand(struct gpmi_nand_data *);
> >> >> +
> >> >> +/* for log */
> >> >> +extern int gpmi_debug;
> >> > 
> >> > Why this extern ?
> >> 
> >> this header can be included by gpmi-nand.c and gpmi-lib.c.
> > 
> > This is a peculiar one ... can't you -- for example -- hide this into
> > driver data?
> 
> It's a parameter of the driver.
> I use it to show different log.
> I think it can not be hide into driver data :(

You can set up a variable in the driver data (the internal state of the driver) 
according to this parameter, no problem.

> 
> thanks
> 
> Huang Shijie
Huang Shijie - Aug. 22, 2011, 2:12 p.m.
Hi,

On Mon, Aug 22, 2011 at 10:02 AM, Marek Vasut <marek.vasut@gmail.com> wrote:
> On Monday, August 22, 2011 04:00:46 PM Huang Shijie wrote:
>> hi,
>>
>> On Mon, Aug 22, 2011 at 9:09 AM, Marek Vasut <marek.vasut@gmail.com> wrote:
>> > On Monday, August 22, 2011 06:59:11 AM Huang Shijie wrote:
>> >> Hi,
>> >>
>> >> thanks for your comments.
>> >>
>> >> >> +
>> >> >> +static inline int get_ecc_chunk_size(struct gpmi_nand_data *this)
>> >> >> +{
>> >> >> +  /* for historical reason */
>> >> >> +  return 512;
>> >> >
>> >> > Can't we just #define this? Or will there ever be something else
>> >> > possible here ? I thought this is the only possible behaviour on MXS.
>> >>
>> >> Please keep it here, it maybe changed in the future.
>> >> It ever had some code for ONFI nand, but i removed it.
>> >
>> > well if you #define it now, you can always replace the defined value with
>> > a function later.
>>
>> ok.
>>
>> >> >> +}
>> >> >> +
>> >> >> +int common_nfc_set_geometry(struct gpmi_nand_data *this)
>> >> >> +{
>> >> >> +  struct bch_geometry *geo =&this->bch_geometry;
>> >> >> +  struct mtd_info *mtd =&this->mil.mtd;
>> >> >> +  unsigned int metadata_size;
>> >> >> +  unsigned int status_size;
>> >> >> +  unsigned int chunk_data_size_in_bits;
>> >> >> +  unsigned int chunk_ecc_size_in_bits;
>> >> >> +  unsigned int chunk_total_size_in_bits;
>> >> >> +  unsigned int block_mark_chunk_number;
>> >> >> +  unsigned int block_mark_chunk_bit_offset;
>> >> >> +  unsigned int block_mark_bit_offset;
>> >> >> +  int gf_len = 13;/* use GP13 by default */
>> >> >> +
>> >> >> +  /* We only support BCH now. */
>> >> >> +  geo->ecc_algorithm = "BCH";
>> >> >> +
>> >> >> +  /*
>> >> >> +   * We always choose a metadata size of 10. Don't try to make sense
>> >> >> of +   * it -- this is really only for historical compatibility. +
>> >> >> */
>> >> >
>> >> > Historical compat or you mean "the chip was designed this way, see
>> >> > datasheet section x.y.z"? ;-)
>> >>
>> >> Just for historical compatibility.
>> >> it's better to keep it as now, there is no need to change it.
>> >
>> > I'm just trying to make sense of it ... from the docs, it seems like a
>> > chip design thing. So this is compat with STMP37xx and 36xx ? Or even
>> > something older and more obscure ?
>>
>> it  seems the rom of the chip use the value.  I will check it tomorrow.
>>
>> >> >> +  geo->metadata_size_in_bytes = 10;
>> >> >> +
>> >> >> +  /* ECC chunks */
>> >> >> +  geo->ecc_chunk_size_in_bytes = get_ecc_chunk_size(this);
>> >
>> >  [ ... ]
>> >
>> >> >> +
>> >> >> +/* Can we use the upper's buffer directly for DMA? */
>> >> >> +void prepare_data_dma(struct gpmi_nand_data *this, enum
>> >> >> dma_data_direction dr) +{
>> >> >> +  struct mil *mil =&this->mil;
>> >> >> +  struct scatterlist *sgl =&mil->data_sgl;
>> >> >
>> >> > I still see the "MIL" present -- can't we just merge the library and
>> >> > this ?
>> >>
>> >> the   `mil` is just a data structure to contain the fields now.
>> >> Maybe I should change the name of it.
>> >
>> > Probably, I still have a feeling of this like it's the old freescale
>> > driver heritage and doesn't make sense now.
>>
>> ok, I will change the name.
>>
>> >> >> +  int ret;
>> >> >> +
>> >> >> +  mil->direct_dma_map_ok = true;
>> >> >>
>> >> >> +static void show_bch_geometry(struct bch_geometry *geo)
>> >> >> +{
>> >> >> +  pr_info("---------------------------------------\n");
>> >> >> +  pr_info("       BCH Geometry\n");
>> >> >> +  pr_info("---------------------------------------\n");
>> >> >> +  pr_info("ECC Algorithm          : %s\n", geo->ecc_algorithm);
>> >> >> +  pr_info("ECC Strength           : %u\n", geo->ecc_strength);
>> >> >> +  pr_info("Page Size in Bytes     : %u\n", geo->page_size_in_bytes);
>> >> >> +  pr_info("Metadata Size in Bytes : %u\n",
>> >> >> geo->metadata_size_in_bytes); +  pr_info("ECC Chunk Size in Bytes:
>> >> >> %u\n",
>> >> >> geo->ecc_chunk_size_in_bytes); +   pr_info("ECC Chunk Count        :
>> >> >> %u\n", geo->ecc_chunk_count); +    pr_info("Payload Size in Bytes  :
>> >> >> %u\n", geo->payload_size_in_bytes); +      pr_info("Auxiliary Size in
>> >> >> Bytes: %u\n", geo->auxiliary_size_in_bytes); +    pr_info("Auxiliary
>> >> >> Status Offset: %u\n", geo->auxiliary_status_offset); +
>> >> >>  pr_info("Block Mark Byte Offset : %u\n",
>> >> >> geo->block_mark_byte_offset); +       pr_info("Block Mark Bit Offset
>> >> >>  : %u\n", geo->block_mark_bit_offset); +}
>> >> >
>> >> > We don't need this.
>> >>
>> >> I just use it for debug.
>> >> Why do not need it? :)
>> >> I think it's useful to debug.
>> >
>> > I want to use it, not debug it. I don't want to have it in dmesg.
>> > pr_info() is really unsuitable. Remove it, use pr_debug(), #define it in
>> > MXS_NAND_VERBOSE_DEBUG, which will be undefined at the begining of the
>> > file by default (probably the best approach). Someone who wants to debug
>> > this thing will just enable it.
>> >
>> >> >> +
>> >> >> +int start_dma_without_bch_irq(struct gpmi_nand_data *this,
>> >> >> +                          struct dma_async_tx_descriptor *desc)
>> >> >> +{
>> >> >> +  struct completion *dma_c =&this->dma_done;
>> >> >> +  int err;
>> >
>> > [...]
>> >
>> >> >> +
>> >> >> +  if ((mil->current_chip<  0)&&  (chip>= 0))
>> >
>> > btw. is the indent here OK?
>>
>> I checked with the script ./script/checkpatch.
>> there is no error.
>>
>> It's ok.
>>
>> >> >> +          gpmi_begin(this);
>> >> >> +  else if ((mil->current_chip>= 0)&&  (chip<  0))
>> >> >> +          gpmi_end(this);
>> >> >> +  else
>> >> >> +          ;
>> >> >
>> >> > Do you need this else branch at all?
>> >>
>> >> It needs a warning here.
>> >>
>> >> >> +
>> >> >> +  mil->current_chip = chip;
>> >> >> +}
>> >> >> +
>> >> >> +static void gpmi_read_buf(struct mtd_info *mtd, uint8_t *buf, int
>> >> >> len) +{
>> >> >> +  struct nand_chip *nand = mtd->priv;
>> >> >> +  struct gpmi_nand_data *this = nand->priv;
>> >> >> +  struct mil *mil =&this->mil;
>> >> >> +
>> >> >> +  logio(GPMI_DEBUG_READ);
>> >> >> +  /* save the info in mil{} for future */
>> >> >> +  mil->upper_buf  = buf;
>> >> >> +  mil->upper_len  = len;
>> >> >> +
>> >> >> +  gpmi_read_data(this);
>> >> >> +}
>> >> >> +
>> >> >> +static void gpmi_write_buf(struct mtd_info *mtd, const uint8_t *buf,
>> >> >> int len) +{
>> >> >> +  struct nand_chip *nand = mtd->priv;
>> >> >> +  struct gpmi_nand_data *this = nand->priv;
>> >> >> +  struct mil *mil =&this->mil;
>> >> >> +
>> >> >> +  logio(GPMI_DEBUG_WRITE);
>> >> >> +  /* save the info in mil{} for future */
>> >> >> +  mil->upper_buf  = (uint8_t *)buf;
>> >> >> +  mil->upper_len  = len;
>> >> >> +
>> >> >> +  gpmi_send_data(this);
>> >> >> +}
>> >> >> +
>> >> >> +static uint8_t gpmi_read_byte(struct mtd_info *mtd)
>> >> >> +{
>> >> >> +  struct nand_chip *nand = mtd->priv;
>> >> >> +  struct gpmi_nand_data *this = nand->priv;
>> >> >> +  struct mil *mil =&this->mil;
>> >> >> +  uint8_t *buf = mil->data_buffer_dma;
>> >> >> +
>> >> >> +  gpmi_read_buf(mtd, buf, 1);
>> >> >> +  return buf[0];
>> >> >> +}
>> >> >> +
>> >> >>
>> >> >> +static int gpmi_block_markbad(struct mtd_info *mtd, loff_t ofs)
>> >> >> +{
>> >> >> +  struct nand_chip *nand = mtd->priv;
>> >> >> +  struct gpmi_nand_data *this = nand->priv;
>> >> >> +  int block, ret = 0;
>> >> >> +
>> >> >> +  /* Get block number */
>> >> >> +  block = (int)(ofs>>  nand->bbt_erase_shift);
>> >> >> +  if (nand->bbt)
>> >> >> +          nand->bbt[block>>  2] |= 0x01<<  ((block&  0x03)<<  1);
>> >> >> +
>> >> >> +  /* Do we have a flash based bad block table ? */
>> >> >> +  if (nand->options&  NAND_USE_FLASH_BBT)
>> >> >> +          ret = nand_update_bbt(mtd, ofs);
>> >> >
>> >> > if (stuff)
>> >> >
>> >> >     return nand_update_bbt();
>> >>
>> >> I can not return it here, I need to update the ecc_stats too.
>> >
>> > You're right.
>> >
>> >> > stuff from else branch
>> >> > .
>> >> > .
>> >> > .
>> >> >
>> >> > Besides, please don't declare variables in the middle of code.
>> >>
>> >> why?
>> >> it's no harm to declare the variables in the {}.
>> >
>> > And to find out what kind of variable it is, you can't just jump at the
>> > begining of the function, you need to navigate through the code ...
>> > that's bad and additional work for other people.
>>
>> thanks, got it.
>>
>> >> >> +  else {
>> >> >> +          struct mil *mil =&this->mil;
>> >> >> +          uint8_t *block_mark;
>> >> >> +          int column, page, status, chipnr;
>> >> >> +
>> >> >> +          chipnr = (int)(ofs>>  nand->chip_shift);
>> >> >> +          nand->select_chip(mtd, chipnr);
>> >> >> +
>> >> >> +          column = this->swap_block_mark ? mtd->writesize : 0;
>> >> >> +
>> >> >> +          /* Write the block mark. */
>> >> >> +          block_mark = mil->data_buffer_dma;
>> >> >> +          block_mark[0] = 0; /* bad block marker */
>> >> >> +
>> >> >> +          /* Shift to get page */
>> >> >> +          page = (int)(ofs>>  nand->page_shift);
>> >> >> +
>> >> >> +          nand->cmdfunc(mtd, NAND_CMD_SEQIN, column, page);
>> >> >> +          nand->write_buf(mtd, block_mark, 1);
>> >> >> +          nand->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
>> >> >> +
>> >> >> +          status = nand->waitfunc(mtd, nand);
>> >> >> +          if (status&  NAND_STATUS_FAIL)
>> >> >> +                  ret = -EIO;
>> >> >> +
>> >> >> +          nand->select_chip(mtd, -1);
>> >> >> +  }
>> >> >> +  if (!ret)
>> >> >> +          mtd->ecc_stats.badblocks++;
>> >> >> +
>> >> >> +  return ret;
>> >> >> +}
>> >
>> > [...]
>> >
>> >> >> addr_t auxiliary);
>> >> >> +
>> >> >> +/* ONFI or TOGGLE nand */
>> >> >> +bool is_ddr_nand(struct gpmi_nand_data *);
>> >> >> +
>> >> >> +/* for log */
>> >> >> +extern int gpmi_debug;
>> >> >
>> >> > Why this extern ?
>> >>
>> >> this header can be included by gpmi-nand.c and gpmi-lib.c.
>> >
>> > This is a peculiar one ... can't you -- for example -- hide this into
>> > driver data?
>>
>> It's a parameter of the driver.
>> I use it to show different log.
>> I think it can not be hide into driver data :(
>
> You can set up a variable in the driver data (the internal state of the driver)
> according to this parameter, no problem.
>
it will be a little complicated. I prefer to remove it from the header file.


thanks
Huang Shijie
>>
>> thanks
>>
>> Huang Shijie
>
Huang Shijie - Aug. 23, 2011, 10:27 a.m.
Hi,
>
>>>> +}
>>>> +
>>>> +int common_nfc_set_geometry(struct gpmi_nand_data *this)
>>>> +{
>>>> +	struct bch_geometry *geo =&this->bch_geometry;
>>>> +	struct mtd_info *mtd =&this->mil.mtd;
>>>> +	unsigned int metadata_size;
>>>> +	unsigned int status_size;
>>>> +	unsigned int chunk_data_size_in_bits;
>>>> +	unsigned int chunk_ecc_size_in_bits;
>>>> +	unsigned int chunk_total_size_in_bits;
>>>> +	unsigned int block_mark_chunk_number;
>>>> +	unsigned int block_mark_chunk_bit_offset;
>>>> +	unsigned int block_mark_bit_offset;
>>>> +	int gf_len = 13;/* use GP13 by default */
>>>> +
>>>> +	/* We only support BCH now. */
>>>> +	geo->ecc_algorithm = "BCH";
>>>> +
>>>> +	/*
>>>> +	 * We always choose a metadata size of 10. Don't try to make sense of
>>>> +	 * it -- this is really only for historical compatibility.
>>>> +	 */
>>> Historical compat or you mean "the chip was designed this way, see
>>> datasheet section x.y.z"? ;-)
>> Just for historical compatibility.
>> it's better to keep it as now, there is no need to change it.
> I'm just trying to make sense of it ... from the docs, it seems like a chip
> design thing. So this is compat with STMP37xx and 36xx ? Or even something older
> and more obscure ?
>
The size of metadata can be changed, though it's set to 10 bytes now.

But it can't be too large, because we have to save enough space for BCH.


thanks
Huang Shijie
Marek Vasut - Aug. 23, 2011, 10:34 a.m.
On Tuesday, August 23, 2011 12:27:07 PM Huang Shijie wrote:
> Hi,
> 
> >>>> +}
> >>>> +
> >>>> +int common_nfc_set_geometry(struct gpmi_nand_data *this)
> >>>> +{
> >>>> +	struct bch_geometry *geo =&this->bch_geometry;
> >>>> +	struct mtd_info *mtd =&this->mil.mtd;
> >>>> +	unsigned int metadata_size;
> >>>> +	unsigned int status_size;
> >>>> +	unsigned int chunk_data_size_in_bits;
> >>>> +	unsigned int chunk_ecc_size_in_bits;
> >>>> +	unsigned int chunk_total_size_in_bits;
> >>>> +	unsigned int block_mark_chunk_number;
> >>>> +	unsigned int block_mark_chunk_bit_offset;
> >>>> +	unsigned int block_mark_bit_offset;
> >>>> +	int gf_len = 13;/* use GP13 by default */
> >>>> +
> >>>> +	/* We only support BCH now. */
> >>>> +	geo->ecc_algorithm = "BCH";
> >>>> +
> >>>> +	/*
> >>>> +	 * We always choose a metadata size of 10. Don't try to make sense
> >>>> of +	 * it -- this is really only for historical compatibility.
> >>>> +	 */
> >>> 
> >>> Historical compat or you mean "the chip was designed this way, see
> >>> datasheet section x.y.z"? ;-)
> >> 
> >> Just for historical compatibility.
> >> it's better to keep it as now, there is no need to change it.
> > 
> > I'm just trying to make sense of it ... from the docs, it seems like a
> > chip design thing. So this is compat with STMP37xx and 36xx ? Or even
> > something older and more obscure ?
> 
> The size of metadata can be changed, though it's set to 10 bytes now.
> 
> But it can't be too large, because we have to save enough space for BCH.

I saw the algo in the MX28 manual. Then just sum this up in the comment and it's 
good :)

Thanks!

Cheers
> 
> 
> thanks
> Huang Shijie
Huang Shijie - Aug. 23, 2011, 10:38 a.m.
Hi,
> On Tuesday, August 23, 2011 12:27:07 PM Huang Shijie wrote:
>> Hi,
>>
>>>>>> +}
>>>>>> +
>>>>>> +int common_nfc_set_geometry(struct gpmi_nand_data *this)
>>>>>> +{
>>>>>> +	struct bch_geometry *geo =&this->bch_geometry;
>>>>>> +	struct mtd_info *mtd =&this->mil.mtd;
>>>>>> +	unsigned int metadata_size;
>>>>>> +	unsigned int status_size;
>>>>>> +	unsigned int chunk_data_size_in_bits;
>>>>>> +	unsigned int chunk_ecc_size_in_bits;
>>>>>> +	unsigned int chunk_total_size_in_bits;
>>>>>> +	unsigned int block_mark_chunk_number;
>>>>>> +	unsigned int block_mark_chunk_bit_offset;
>>>>>> +	unsigned int block_mark_bit_offset;
>>>>>> +	int gf_len = 13;/* use GP13 by default */
>>>>>> +
>>>>>> +	/* We only support BCH now. */
>>>>>> +	geo->ecc_algorithm = "BCH";
>>>>>> +
>>>>>> +	/*
>>>>>> +	 * We always choose a metadata size of 10. Don't try to make sense
>>>>>> of +	 * it -- this is really only for historical compatibility.
>>>>>> +	 */
>>>>> Historical compat or you mean "the chip was designed this way, see
>>>>> datasheet section x.y.z"? ;-)
>>>> Just for historical compatibility.
>>>> it's better to keep it as now, there is no need to change it.
>>> I'm just trying to make sense of it ... from the docs, it seems like a
>>> chip design thing. So this is compat with STMP37xx and 36xx ? Or even
>>> something older and more obscure ?
>> The size of metadata can be changed, though it's set to 10 bytes now.
>>
>> But it can't be too large, because we have to save enough space for BCH.
> I saw the algo in the MX28 manual. Then just sum this up in the comment and it's
> good :)
>
ok, thanks :)

Huang Shijie
> Thanks!
>
> Cheers
>>
>> thanks
>> Huang Shijie

Patch

diff --git a/drivers/mtd/nand/gpmi-nand/gpmi-nand.c b/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
new file mode 100644
index 0000000..afeef48
--- /dev/null
+++ b/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
@@ -0,0 +1,1804 @@ 
+/*
+ * Freescale GPMI NAND Flash Driver
+ *
+ * Copyright (C) 2010-2011 Freescale Semiconductor, Inc.
+ * Copyright (C) 2008 Embedded Alley Solutions, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include "gpmi-nand.h"
+
+/* add our owner bbt descriptor */
+static uint8_t scan_ff_pattern[] = { 0xff };
+static struct nand_bbt_descr gpmi_bbt_descr = {
+	.options	= 0,
+	.offs		= 0,
+	.len		= 1,
+	.pattern	= scan_ff_pattern
+};
+
+/* debug control */
+int gpmi_debug;
+module_param(gpmi_debug, int, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(gpmi_debug, "print out the debug infomation.");
+
+static irqreturn_t bch_irq(int irq, void *cookie)
+{
+	struct gpmi_nand_data *this = cookie;
+
+	gpmi_clear_bch(this);
+	complete(&this->bch_done);
+	return IRQ_HANDLED;
+}
+
+/* calculate the ECC strength by hand */
+static inline int get_ecc_strength(struct gpmi_nand_data *this)
+{
+	struct mtd_info	*mtd = &this->mil.mtd;
+	int ecc_strength = 0;
+
+	switch (mtd->writesize) {
+	case 2048:
+		ecc_strength = 8;
+		break;
+	case 4096:
+		switch (mtd->oobsize) {
+		case 128:
+			ecc_strength = 8;
+			break;
+		case 224:
+		case 218:
+			ecc_strength = 16;
+			break;
+		}
+		break;
+	case 8192:
+		ecc_strength = 24;
+		break;
+	}
+
+	return ecc_strength;
+}
+
+static inline int get_ecc_chunk_size(struct gpmi_nand_data *this)
+{
+	/* for historical reason */
+	return 512;
+}
+
+int common_nfc_set_geometry(struct gpmi_nand_data *this)
+{
+	struct bch_geometry *geo = &this->bch_geometry;
+	struct mtd_info *mtd = &this->mil.mtd;
+	unsigned int metadata_size;
+	unsigned int status_size;
+	unsigned int chunk_data_size_in_bits;
+	unsigned int chunk_ecc_size_in_bits;
+	unsigned int chunk_total_size_in_bits;
+	unsigned int block_mark_chunk_number;
+	unsigned int block_mark_chunk_bit_offset;
+	unsigned int block_mark_bit_offset;
+	int gf_len = 13;/* use GP13 by default */
+
+	/* We only support BCH now. */
+	geo->ecc_algorithm = "BCH";
+
+	/*
+	 * We always choose a metadata size of 10. Don't try to make sense of
+	 * it -- this is really only for historical compatibility.
+	 */
+	geo->metadata_size_in_bytes = 10;
+
+	/* ECC chunks */
+	geo->ecc_chunk_size_in_bytes = get_ecc_chunk_size(this);
+
+	/*
+	 * Compute the total number of ECC chunks in a page. This includes the
+	 * slightly larger chunk at the beginning of the page, which contains
+	 * both data and metadata.
+	 */
+	geo->ecc_chunk_count = mtd->writesize / geo->ecc_chunk_size_in_bytes;
+
+	/*
+	 * We use the same ECC strength for all chunks, including the first one.
+	 */
+	geo->ecc_strength = get_ecc_strength(this);
+	if (!geo->ecc_strength) {
+		pr_info("Page size:%d, OOB:%d\n", mtd->writesize, mtd->oobsize);
+		return -EINVAL;
+	}
+
+	/* Compute the page size, include page and oob. */
+	geo->page_size_in_bytes = mtd->writesize + mtd->oobsize;
+	geo->payload_size_in_bytes = mtd->writesize;
+
+	/*
+	 * In principle, computing the auxiliary buffer geometry is NFC
+	 * version-specific. However, at this writing, all versions share the
+	 * same model, so this code can also be shared.
+	 *
+	 * The auxiliary buffer contains the metadata and the ECC status. The
+	 * metadata is padded to the nearest 32-bit boundary. The ECC status
+	 * contains one byte for every ECC chunk, and is also padded to the
+	 * nearest 32-bit boundary.
+	 */
+	metadata_size = ALIGN(geo->metadata_size_in_bytes, 4);
+	status_size   = ALIGN(geo->ecc_chunk_count, 4);
+
+	geo->auxiliary_size_in_bytes = metadata_size + status_size;
+	geo->auxiliary_status_offset = metadata_size;
+
+	/* Check if we're going to do block mark swapping. */
+	if (!this->swap_block_mark)
+		return 0;
+
+	/*
+	 * If control arrives here, we're doing block mark swapping, so we need
+	 * to compute the byte and bit offsets of the physical block mark within
+	 * the ECC-based view of the page data. In principle, this isn't a
+	 * difficult computation -- but it's very important and it's easy to get
+	 * it wrong, so we do it carefully.
+	 *
+	 * Note that this calculation is simpler because we use the same ECC
+	 * strength for all chunks, including the zero'th one, which contains
+	 * the metadata. The calculation would be slightly more complicated
+	 * otherwise.
+	 *
+	 * We start by computing the physical bit offset of the block mark. We
+	 * then subtract the number of metadata and ECC bits appearing before
+	 * the mark to arrive at its bit offset within the data alone.
+	 */
+
+	/* Compute some important facts about chunk geometry. */
+	chunk_data_size_in_bits = geo->ecc_chunk_size_in_bytes * 8;
+	chunk_ecc_size_in_bits  = geo->ecc_strength * gf_len;
+	chunk_total_size_in_bits = chunk_data_size_in_bits
+					+ chunk_ecc_size_in_bits;
+
+	/* Compute the bit offset of the block mark within the physical page. */
+	block_mark_bit_offset = mtd->writesize * 8;
+
+	/* Subtract the metadata bits. */
+	block_mark_bit_offset -= geo->metadata_size_in_bytes * 8;
+
+	/*
+	 * Compute the chunk number (starting at zero) in which the block mark
+	 * appears.
+	 */
+	block_mark_chunk_number =
+			block_mark_bit_offset / chunk_total_size_in_bits;
+
+	/*
+	 * Compute the bit offset of the block mark within its chunk, and
+	 * validate it.
+	 */
+	block_mark_chunk_bit_offset =
+		block_mark_bit_offset -
+			(block_mark_chunk_number * chunk_total_size_in_bits);
+
+	if (block_mark_chunk_bit_offset > chunk_data_size_in_bits) {
+		/*
+		 * If control arrives here, the block mark actually appears in
+		 * the ECC bits of this chunk. This wont' work.
+		 */
+		pr_info("Unsupported page geometry : %u:%u\n",
+				mtd->writesize, mtd->oobsize);
+		return -EINVAL;
+	}
+
+	/*
+	 * Now that we know the chunk number in which the block mark appears,
+	 * we can subtract all the ECC bits that appear before it.
+	 */
+	block_mark_bit_offset -=
+			block_mark_chunk_number * chunk_ecc_size_in_bits;
+
+	/*
+	 * We now know the absolute bit offset of the block mark within the
+	 * ECC-based data. We can now compute the byte offset and the bit
+	 * offset within the byte.
+	 */
+	geo->block_mark_byte_offset = block_mark_bit_offset / 8;
+	geo->block_mark_bit_offset  = block_mark_bit_offset % 8;
+
+	return 0;
+}
+
+struct dma_chan *get_dma_chan(struct gpmi_nand_data *this)
+{
+	int chip = this->mil.current_chip;
+
+	BUG_ON(chip < 0);
+	return this->dma_chans[chip];
+}
+
+/* Can we use the upper's buffer directly for DMA? */
+void prepare_data_dma(struct gpmi_nand_data *this, enum dma_data_direction dr)
+{
+	struct mil *mil = &this->mil;
+	struct scatterlist *sgl = &mil->data_sgl;
+	int ret;
+
+	mil->direct_dma_map_ok = true;
+
+	/* first try to map the upper buffer directly */
+	sg_init_one(sgl, mil->upper_buf, mil->upper_len);
+	ret = dma_map_sg(this->dev, sgl, 1, dr);
+	if (ret == 0) {
+		/* We have to use our own DMA buffer. */
+		sg_init_one(sgl, mil->data_buffer_dma, PAGE_SIZE);
+
+		if (dr == DMA_TO_DEVICE)
+			memcpy(mil->data_buffer_dma, mil->upper_buf,
+				mil->upper_len);
+
+		ret = dma_map_sg(this->dev, sgl, 1, dr);
+		BUG_ON(ret == 0);
+
+		mil->direct_dma_map_ok = false;
+	}
+}
+
+/* This will be called after the DMA operation is finished. */
+static void dma_irq_callback(void *param)
+{
+	struct gpmi_nand_data *this = param;
+	struct mil *mil = &this->mil;
+	struct completion *dma_c = &this->dma_done;
+
+	complete(dma_c);
+
+	switch (this->dma_type) {
+	case DMA_FOR_COMMAND:
+		dma_unmap_sg(this->dev, &mil->cmd_sgl, 1, DMA_TO_DEVICE);
+		break;
+
+	case DMA_FOR_READ_DATA:
+		dma_unmap_sg(this->dev, &mil->data_sgl, 1, DMA_FROM_DEVICE);
+		if (mil->direct_dma_map_ok == false)
+			memcpy(mil->upper_buf, mil->data_buffer_dma,
+				mil->upper_len);
+		break;
+
+	case DMA_FOR_WRITE_DATA:
+		dma_unmap_sg(this->dev, &mil->data_sgl, 1, DMA_TO_DEVICE);
+		break;
+
+	case DMA_FOR_READ_ECC_PAGE:
+	case DMA_FOR_WRITE_ECC_PAGE:
+		/* We have to wait the BCH interrupt to finish. */
+		break;
+
+	default:
+		BUG();
+	}
+}
+
+static void show_bch_geometry(struct bch_geometry *geo)
+{
+	pr_info("---------------------------------------\n");
+	pr_info("	BCH Geometry\n");
+	pr_info("---------------------------------------\n");
+	pr_info("ECC Algorithm          : %s\n", geo->ecc_algorithm);
+	pr_info("ECC Strength           : %u\n", geo->ecc_strength);
+	pr_info("Page Size in Bytes     : %u\n", geo->page_size_in_bytes);
+	pr_info("Metadata Size in Bytes : %u\n", geo->metadata_size_in_bytes);
+	pr_info("ECC Chunk Size in Bytes: %u\n", geo->ecc_chunk_size_in_bytes);
+	pr_info("ECC Chunk Count        : %u\n", geo->ecc_chunk_count);
+	pr_info("Payload Size in Bytes  : %u\n", geo->payload_size_in_bytes);
+	pr_info("Auxiliary Size in Bytes: %u\n", geo->auxiliary_size_in_bytes);
+	pr_info("Auxiliary Status Offset: %u\n", geo->auxiliary_status_offset);
+	pr_info("Block Mark Byte Offset : %u\n", geo->block_mark_byte_offset);
+	pr_info("Block Mark Bit Offset  : %u\n", geo->block_mark_bit_offset);
+}
+
+int start_dma_without_bch_irq(struct gpmi_nand_data *this,
+				struct dma_async_tx_descriptor *desc)
+{
+	struct completion *dma_c = &this->dma_done;
+	int err;
+
+	init_completion(dma_c);
+
+	desc->callback		= dma_irq_callback;
+	desc->callback_param	= this;
+	dmaengine_submit(desc);
+
+	/* Wait for the interrupt from the DMA block. */
+	err = wait_for_completion_timeout(dma_c, msecs_to_jiffies(1000));
+	err = (!err) ? -ETIMEDOUT : 0;
+	if (err) {
+		pr_info("DMA timeout, last DMA :%d\n", this->last_dma_type);
+		if (gpmi_debug & GPMI_DEBUG_CRAZY) {
+			struct bch_geometry *geo = &this->bch_geometry;
+
+			gpmi_show_regs(this);
+			show_bch_geometry(geo);
+			panic("-----------DMA FAILED------------------");
+		}
+	}
+	return err;
+}
+
+/*
+ * This function is used in BCH reading or BCH writing pages.
+ * It will wait for the BCH interrupt as long as ONE second.
+ * Actually, we must wait for two interrupts :
+ *	[1] firstly the DMA interrupt and
+ *	[2] secondly the BCH interrupt.
+ *
+ * @this:	Per-device data structure.
+ * @desc:	DMA channel
+ */
+int start_dma_with_bch_irq(struct gpmi_nand_data *this,
+			struct dma_async_tx_descriptor *desc)
+{
+	int err;
+
+	/* Prepare to receive an interrupt from the BCH block. */
+	init_completion(&this->bch_done);
+
+	/* start the DMA */
+	start_dma_without_bch_irq(this, desc);
+
+	/* Wait for the interrupt from the BCH block. */
+	err = wait_for_completion_timeout(&this->bch_done,
+					msecs_to_jiffies(1000));
+	err = (!err) ? -ETIMEDOUT : 0;
+	if (err) {
+		pr_info("BCH timeout!!!\n");
+		if (gpmi_debug & GPMI_DEBUG_CRAZY) {
+			struct bch_geometry *geo = &this->bch_geometry;
+
+			gpmi_show_regs(this);
+			show_bch_geometry(geo);
+			panic("-----------BCH FAILED------------------");
+		}
+	}
+	return err;
+}
+
+static int __devinit acquire_register_block(struct gpmi_nand_data *this,
+			const char *resource_name, void **reg_block_base)
+{
+	struct platform_device *pdev = this->pdev;
+	struct resource *r;
+	void *p;
+
+	r = platform_get_resource_byname(pdev, IORESOURCE_MEM, resource_name);
+	if (!r) {
+		pr_info("Can't get resource for %s\n", resource_name);
+		return -ENXIO;
+	}
+
+	/* remap the register block */
+	p = ioremap(r->start, resource_size(r));
+	if (!p) {
+		pr_info("Can't remap %s\n", resource_name);
+		return -ENOMEM;
+	}
+
+	*reg_block_base = p;
+	return 0;
+}
+
+static void release_register_block(struct gpmi_nand_data *this,
+				void *reg_block_base)
+{
+	iounmap(reg_block_base);
+}
+
+static int __devinit acquire_interrupt(struct gpmi_nand_data *this,
+			const char *resource_name,
+			irq_handler_t interrupt_handler, int *lno, int *hno)
+{
+	struct platform_device *pdev = this->pdev;
+	struct resource *r;
+	int err;
+
+	r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, resource_name);
+	if (!r) {
+		pr_info("Can't get resource for %s\n", resource_name);
+		return -ENXIO;
+	}
+
+	BUG_ON(r->start != r->end);
+	err = request_irq(r->start, interrupt_handler, 0, resource_name, this);
+	if (err) {
+		pr_info("Can't own %s\n", resource_name);
+		return err;
+	}
+
+	*lno = r->start;
+	*hno = r->end;
+	return 0;
+}
+
+static void release_interrupt(struct gpmi_nand_data *this,
+			int low_interrupt_number, int high_interrupt_number)
+{
+	int i;
+	for (i = low_interrupt_number; i <= high_interrupt_number; i++)
+		free_irq(i, this);
+}
+
+static bool gpmi_dma_filter(struct dma_chan *chan, void *param)
+{
+	struct gpmi_nand_data *this = param;
+	struct resource *r = this->private;
+
+	if (!mxs_dma_is_apbh(chan))
+		return false;
+	/*
+	 * only catch the GPMI dma channels :
+	 *	for mx23 :	MX23_DMA_GPMI0 ~ MX23_DMA_GPMI3
+	 *		(These four channels share the same IRQ!)
+	 *
+	 *	for mx28 :	MX28_DMA_GPMI0 ~ MX28_DMA_GPMI7
+	 *		(These eight channels share the same IRQ!)
+	 */
+	if (r->start <= chan->chan_id && chan->chan_id <= r->end) {
+		chan->private = &this->dma_data;
+		return true;
+	}
+	return false;
+}
+
+static void release_dma_channels(struct gpmi_nand_data *this)
+{
+	unsigned int i;
+	for (i = 0; i < DMA_CHANS; i++)
+		if (this->dma_chans[i]) {
+			dma_release_channel(this->dma_chans[i]);
+			this->dma_chans[i] = NULL;
+		}
+}
+
+static int __devinit acquire_dma_channels(struct gpmi_nand_data *this,
+				const char *resource_name,
+				unsigned *low_channel, unsigned *high_channel)
+{
+	struct platform_device *pdev = this->pdev;
+	struct gpmi_nand_platform_data *pdata = this->pdata;
+	struct resource *r, *r_dma;
+	unsigned int i;
+
+	r = platform_get_resource_byname(pdev, IORESOURCE_DMA, resource_name);
+	r_dma = platform_get_resource_byname(pdev, IORESOURCE_IRQ,
+					GPMI_NAND_DMA_INTERRUPT_RES_NAME);
+	if (!r || !r_dma) {
+		pr_info("Can't get resource for DMA\n");
+		return -ENXIO;
+	}
+
+	/* used in gpmi_dma_filter() */
+	this->private = r;
+
+	for (i = r->start; i <= r->end; i++) {
+		struct dma_chan *dma_chan;
+		dma_cap_mask_t mask;
+
+		if (i - r->start >= pdata->max_chip_count)
+			break;
+
+		dma_cap_zero(mask);
+		dma_cap_set(DMA_SLAVE, mask);
+
+		/* get the DMA interrupt */
+		if (r_dma->start == r_dma->end) {
+			/* only register the first. */
+			if (i == r->start)
+				this->dma_data.chan_irq = r_dma->start;
+			else
+				this->dma_data.chan_irq = NO_IRQ;
+		} else
+			this->dma_data.chan_irq = r_dma->start + (i - r->start);
+
+		dma_chan = dma_request_channel(mask, gpmi_dma_filter, this);
+		if (!dma_chan)
+			goto acquire_err;
+
+		/* fill the first empty item */
+		this->dma_chans[i - r->start] = dma_chan;
+	}
+
+	*low_channel  = r->start;
+	*high_channel = i;
+	return 0;
+
+acquire_err:
+	pr_info("Can't acquire DMA channel %u\n", i);
+	release_dma_channels(this);
+	return -EINVAL;
+}
+
+static int __devinit acquire_resources(struct gpmi_nand_data *this)
+{
+	struct resources *r = &this->resources;
+	int error;
+
+	/* Attempt to acquire the GPMI register block. */
+	error = acquire_register_block(this,
+				GPMI_NAND_GPMI_REGS_ADDR_RES_NAME,
+				&r->gpmi_regs);
+	if (error)
+		goto exit_gpmi_regs;
+
+	/* Attempt to acquire the BCH register block. */
+	error = acquire_register_block(this,
+				GPMI_NAND_BCH_REGS_ADDR_RES_NAME,
+				&r->bch_regs);
+	if (error)
+		goto exit_bch_regs;
+
+	/* Attempt to acquire the BCH interrupt. */
+	error = acquire_interrupt(this,
+				GPMI_NAND_BCH_INTERRUPT_RES_NAME,
+				bch_irq,
+				&r->bch_low_interrupt,
+				&r->bch_high_interrupt);
+	if (error)
+		goto exit_bch_interrupt;
+
+	/* Attempt to acquire the DMA channels. */
+	error = acquire_dma_channels(this,
+				GPMI_NAND_DMA_CHANNELS_RES_NAME,
+				&r->dma_low_channel,
+				&r->dma_high_channel);
+	if (error)
+		goto exit_dma_channels;
+
+	/* Attempt to acquire our clock. */
+	r->clock = clk_get(&this->pdev->dev, NULL);
+	if (IS_ERR(r->clock)) {
+		pr_info("can not get the clock\n");
+		error = -ENOENT;
+		goto exit_clock;
+	}
+	return 0;
+
+exit_clock:
+	release_dma_channels(this);
+exit_dma_channels:
+	release_interrupt(this, r->bch_low_interrupt, r->bch_high_interrupt);
+exit_bch_interrupt:
+	release_register_block(this, r->bch_regs);
+exit_bch_regs:
+	release_register_block(this, r->gpmi_regs);
+exit_gpmi_regs:
+	return error;
+}
+
+static void release_resources(struct gpmi_nand_data *this)
+{
+	struct resources *r = &this->resources;
+
+	clk_put(r->clock);
+	release_register_block(this, r->gpmi_regs);
+	release_register_block(this, r->bch_regs);
+	release_interrupt(this, r->bch_low_interrupt, r->bch_low_interrupt);
+	release_dma_channels(this);
+}
+
+static int __devinit init_hardware(struct gpmi_nand_data *this)
+{
+	int error;
+
+	/*
+	 * This structure contains the "safe" GPMI timing that should succeed
+	 * with any NAND Flash device
+	 * (although, with less-than-optimal performance).
+	 */
+	struct nand_timing  safe_timing = {
+		.data_setup_in_ns        = 80,
+		.data_hold_in_ns         = 60,
+		.address_setup_in_ns     = 25,
+		.gpmi_sample_delay_in_ns =  6,
+		.tREA_in_ns              = -1,
+		.tRLOH_in_ns             = -1,
+		.tRHOH_in_ns             = -1,
+	};
+
+	/* Initialize the hardwares. */
+	error = gpmi_init(this);
+	if (error)
+		return error;
+
+	this->timing = safe_timing;
+	return 0;
+}
+
+static int read_page_prepare(struct gpmi_nand_data *this,
+			void *destination, unsigned length,
+			void *alt_virt, dma_addr_t alt_phys, unsigned alt_size,
+			void **use_virt, dma_addr_t *use_phys)
+{
+	struct device *dev = this->dev;
+
+	if (virt_addr_valid(destination)) {
+		dma_addr_t dest_phys;
+
+		dest_phys = dma_map_single(dev, destination,
+						length, DMA_FROM_DEVICE);
+		if (dma_mapping_error(dev, dest_phys)) {
+			if (alt_size < length) {
+				pr_info("Alternate buffer is too small\n");
+				return -ENOMEM;
+			}
+			goto map_failed;
+		}
+		*use_virt = destination;
+		*use_phys = dest_phys;
+		this->mil.direct_dma_map_ok = true;
+		return 0;
+	}
+
+map_failed:
+	*use_virt = alt_virt;
+	*use_phys = alt_phys;
+	this->mil.direct_dma_map_ok = false;
+	return 0;
+}
+
+static inline void read_page_end(struct gpmi_nand_data *this,
+			void *destination, unsigned length,
+			void *alt_virt, dma_addr_t alt_phys, unsigned alt_size,
+			void *used_virt, dma_addr_t used_phys)
+{
+	if (this->mil.direct_dma_map_ok)
+		dma_unmap_single(this->dev, used_phys, length, DMA_FROM_DEVICE);
+}
+
+static inline void read_page_swap_end(struct gpmi_nand_data *this,
+			void *destination, unsigned length,
+			void *alt_virt, dma_addr_t alt_phys, unsigned alt_size,
+			void *used_virt, dma_addr_t used_phys)
+{
+	if (!this->mil.direct_dma_map_ok)
+		memcpy(destination, alt_virt, length);
+}
+
+static int send_page_prepare(struct gpmi_nand_data *this,
+			const void *source, unsigned length,
+			void *alt_virt, dma_addr_t alt_phys, unsigned alt_size,
+			const void **use_virt, dma_addr_t *use_phys)
+{
+	struct device *dev = this->dev;
+
+	if (virt_addr_valid(source)) {
+		dma_addr_t source_phys;
+
+		source_phys = dma_map_single(dev, (void *)source, length,
+						DMA_TO_DEVICE);
+		if (dma_mapping_error(dev, source_phys)) {
+			if (alt_size < length) {
+				pr_info("Alternate buffer is too small\n");
+				return -ENOMEM;
+			}
+			goto map_failed;
+		}
+		*use_virt = source;
+		*use_phys = source_phys;
+		return 0;
+	}
+map_failed:
+	/*
+	 * Copy the content of the source buffer into the alternate
+	 * buffer and set up the return values accordingly.
+	 */
+	memcpy(alt_virt, source, length);
+
+	*use_virt = alt_virt;
+	*use_phys = alt_phys;
+	return 0;
+}
+
+static void send_page_end(struct gpmi_nand_data *this,
+			const void *source, unsigned length,
+			void *alt_virt, dma_addr_t alt_phys, unsigned alt_size,
+			const void *used_virt, dma_addr_t used_phys)
+{
+	struct device *dev = this->dev;
+	if (used_virt == source)
+		dma_unmap_single(dev, used_phys, length, DMA_TO_DEVICE);
+}
+
+static void mil_free_dma_buffer(struct gpmi_nand_data *this)
+{
+	struct device *dev = this->dev;
+	struct mil *mil	= &this->mil;
+
+	if (mil->page_buffer_virt && virt_addr_valid(mil->page_buffer_virt))
+		dma_free_coherent(dev, mil->page_buffer_size,
+					mil->page_buffer_virt,
+					mil->page_buffer_phys);
+	kfree(mil->cmd_buffer);
+	kfree(mil->data_buffer_dma);
+
+	mil->cmd_buffer		= NULL;
+	mil->data_buffer_dma	= NULL;
+	mil->page_buffer_virt	= NULL;
+	mil->page_buffer_size	=  0;
+}
+
+/* Allocate the DMA buffers */
+static int mil_alloc_dma_buffer(struct gpmi_nand_data *this)
+{
+	struct bch_geometry *geo = &this->bch_geometry;
+	struct device *dev = this->dev;
+	struct mil *mil = &this->mil;
+
+	/* [1] Allocate a command buffer. PAGE_SIZE is enough. */
+	mil->cmd_buffer = kzalloc(PAGE_SIZE, GFP_DMA);
+	if (mil->cmd_buffer == NULL)
+		goto error_alloc;
+
+	/* [2] Allocate a read/write data buffer. PAGE_SIZE is enough. */
+	mil->data_buffer_dma = kzalloc(PAGE_SIZE, GFP_DMA);
+	if (mil->data_buffer_dma == NULL)
+		goto error_alloc;
+
+	/*
+	 * [3] Allocate the page buffer.
+	 *
+	 * Both the payload buffer and the auxiliary buffer must appear on
+	 * 32-bit boundaries. We presume the size of the payload buffer is a
+	 * power of two and is much larger than four, which guarantees the
+	 * auxiliary buffer will appear on a 32-bit boundary.
+	 */
+	mil->page_buffer_size = geo->payload_size_in_bytes +
+				geo->auxiliary_size_in_bytes;
+
+	mil->page_buffer_virt = dma_alloc_coherent(dev, mil->page_buffer_size,
+					&mil->page_buffer_phys, GFP_DMA);
+	if (!mil->page_buffer_virt)
+		goto error_alloc;
+
+
+	/* Slice up the page buffer. */
+	mil->payload_virt = mil->page_buffer_virt;
+	mil->payload_phys = mil->page_buffer_phys;
+	mil->auxiliary_virt = mil->payload_virt + geo->payload_size_in_bytes;
+	mil->auxiliary_phys = mil->payload_phys + geo->payload_size_in_bytes;
+	return 0;
+
+error_alloc:
+	mil_free_dma_buffer(this);
+	pr_info("allocate DMA buffer error!!\n");
+	return -ENOMEM;
+}
+
+static void gpmi_cmd_ctrl(struct mtd_info *mtd, int data, unsigned int ctrl)
+{
+	struct nand_chip *nand = mtd->priv;
+	struct gpmi_nand_data *this = nand->priv;
+	struct mil *mil = &this->mil;
+	int error;
+
+	/*
+	 * Every operation begins with a command byte and a series of zero or
+	 * more address bytes. These are distinguished by either the Address
+	 * Latch Enable (ALE) or Command Latch Enable (CLE) signals being
+	 * asserted. When MTD is ready to execute the command, it will deassert
+	 * both latch enables.
+	 *
+	 * Rather than run a separate DMA operation for every single byte, we
+	 * queue them up and run a single DMA operation for the entire series
+	 * of command and data bytes. NAND_CMD_NONE means the END of the queue.
+	 */
+	if ((ctrl & (NAND_ALE | NAND_CLE))) {
+		if (data != NAND_CMD_NONE)
+			mil->cmd_buffer[mil->command_length++] = data;
+		return;
+	}
+
+	if (!mil->command_length)
+		return;
+
+	error = gpmi_send_command(this);
+	if (error)
+		pr_info("Chip: %u, Error %d\n", mil->current_chip, error);
+
+	mil->command_length = 0;
+}
+
+static int gpmi_dev_ready(struct mtd_info *mtd)
+{
+	struct nand_chip *nand = mtd->priv;
+	struct gpmi_nand_data *this = nand->priv;
+	struct mil *mil = &this->mil;
+
+	return gpmi_is_ready(this, mil->current_chip);
+}
+
+static void gpmi_select_chip(struct mtd_info *mtd, int chip)
+{
+	struct nand_chip *nand = mtd->priv;
+	struct gpmi_nand_data *this = nand->priv;
+	struct mil *mil = &this->mil;
+
+	if ((mil->current_chip < 0) && (chip >= 0))
+		gpmi_begin(this);
+	else if ((mil->current_chip >= 0) && (chip < 0))
+		gpmi_end(this);
+	else
+		;
+
+	mil->current_chip = chip;
+}
+
+static void gpmi_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
+{
+	struct nand_chip *nand = mtd->priv;
+	struct gpmi_nand_data *this = nand->priv;
+	struct mil *mil = &this->mil;
+
+	logio(GPMI_DEBUG_READ);
+	/* save the info in mil{} for future */
+	mil->upper_buf	= buf;
+	mil->upper_len	= len;
+
+	gpmi_read_data(this);
+}
+
+static void gpmi_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
+{
+	struct nand_chip *nand = mtd->priv;
+	struct gpmi_nand_data *this = nand->priv;
+	struct mil *mil = &this->mil;
+
+	logio(GPMI_DEBUG_WRITE);
+	/* save the info in mil{} for future */
+	mil->upper_buf	= (uint8_t *)buf;
+	mil->upper_len	= len;
+
+	gpmi_send_data(this);
+}
+
+static uint8_t gpmi_read_byte(struct mtd_info *mtd)
+{
+	struct nand_chip *nand = mtd->priv;
+	struct gpmi_nand_data *this = nand->priv;
+	struct mil *mil = &this->mil;
+	uint8_t *buf = mil->data_buffer_dma;
+
+	gpmi_read_buf(mtd, buf, 1);
+	return buf[0];
+}
+
+/**
+ * mil_handle_block_mark_swapping() - Handles block mark swapping.
+ *
+ * Note that, when this function is called, it doesn't know whether it's
+ * swapping the block mark, or swapping it *back* -- but it doesn't matter
+ * because the the operation is the same.
+ *
+ * @this:       Per-device data.
+ * @payload:    A pointer to the payload buffer.
+ * @auxiliary:  A pointer to the auxiliary buffer.
+ */
+static void mil_handle_block_mark_swapping(struct gpmi_nand_data *this,
+						void *payload, void *auxiliary)
+{
+	struct bch_geometry *nfc_geo = &this->bch_geometry;
+	unsigned char *p;
+	unsigned char *a;
+	unsigned int  bit;
+	unsigned char mask;
+	unsigned char from_data;
+	unsigned char from_oob;
+
+	/* Check if we're doing block mark swapping. */
+	if (!this->swap_block_mark)
+		return;
+
+	/*
+	 * If control arrives here, we're swapping. Make some convenience
+	 * variables.
+	 */
+	bit = nfc_geo->block_mark_bit_offset;
+	p   = payload + nfc_geo->block_mark_byte_offset;
+	a   = auxiliary;
+
+	/*
+	 * Get the byte from the data area that overlays the block mark. Since
+	 * the ECC engine applies its own view to the bits in the page, the
+	 * physical block mark won't (in general) appear on a byte boundary in
+	 * the data.
+	 */
+	from_data = (p[0] >> bit) | (p[1] << (8 - bit));
+
+	/* Get the byte from the OOB. */
+	from_oob = a[0];
+
+	/* Swap them. */
+	a[0] = from_data;
+
+	mask = (0x1 << bit) - 1;
+	p[0] = (p[0] & mask) | (from_oob << bit);
+
+	mask = ~0 << bit;
+	p[1] = (p[1] & mask) | (from_oob >> (8 - bit));
+}
+
+static int gpmi_ecc_read_page(struct mtd_info *mtd, struct nand_chip *nand,
+				uint8_t *buf, int page)
+{
+	struct gpmi_nand_data *this = nand->priv;
+	struct bch_geometry *nfc_geo = &this->bch_geometry;
+	struct mil *mil = &this->mil;
+	void          *payload_virt;
+	dma_addr_t    payload_phys;
+	void          *auxiliary_virt;
+	dma_addr_t    auxiliary_phys;
+	unsigned int  i;
+	unsigned char *status;
+	unsigned int  failed;
+	unsigned int  corrected;
+	int           error;
+
+	logio(GPMI_DEBUG_ECC_READ);
+	error = read_page_prepare(this, buf, mtd->writesize,
+					mil->payload_virt, mil->payload_phys,
+					nfc_geo->payload_size_in_bytes,
+					&payload_virt, &payload_phys);
+	if (error) {
+		pr_info("Inadequate DMA buffer\n");
+		error = -ENOMEM;
+		return error;
+	}
+	auxiliary_virt = mil->auxiliary_virt;
+	auxiliary_phys = mil->auxiliary_phys;
+
+	/* go! */
+	error = gpmi_read_page(this, payload_phys, auxiliary_phys);
+	read_page_end(this, buf, mtd->writesize,
+			mil->payload_virt, mil->payload_phys,
+			nfc_geo->payload_size_in_bytes,
+			payload_virt, payload_phys);
+	if (error) {
+		pr_info("Error in ECC-based read: %d\n", error);
+		goto exit_nfc;
+	}
+
+	/* handle the block mark swapping */
+	mil_handle_block_mark_swapping(this, payload_virt, auxiliary_virt);
+
+	/* Loop over status bytes, accumulating ECC status. */
+	failed		= 0;
+	corrected	= 0;
+	status		= auxiliary_virt + nfc_geo->auxiliary_status_offset;
+
+	for (i = 0; i < nfc_geo->ecc_chunk_count; i++, status++) {
+		if ((*status == STATUS_GOOD) || (*status == STATUS_ERASED))
+			continue;
+
+		if (*status == STATUS_UNCORRECTABLE) {
+			failed++;
+			continue;
+		}
+		corrected += *status;
+	}
+
+	/*
+	 * Propagate ECC status to the owning MTD only when failed or
+	 * corrected times nearly reaches our ECC correction threshold.
+	 */
+	if (failed || corrected >= (nfc_geo->ecc_strength - 1)) {
+		mtd->ecc_stats.failed    += failed;
+		mtd->ecc_stats.corrected += corrected;
+	}
+
+	/*
+	 * It's time to deliver the OOB bytes. See gpmi_ecc_read_oob() for
+	 * details about our policy for delivering the OOB.
+	 *
+	 * We fill the caller's buffer with set bits, and then copy the block
+	 * mark to th caller's buffer. Note that, if block mark swapping was
+	 * necessary, it has already been done, so we can rely on the first
+	 * byte of the auxiliary buffer to contain the block mark.
+	 */
+	memset(nand->oob_poi, ~0, mtd->oobsize);
+	nand->oob_poi[0] = ((uint8_t *) auxiliary_virt)[0];
+
+	read_page_swap_end(this, buf, mtd->writesize,
+			mil->payload_virt, mil->payload_phys,
+			nfc_geo->payload_size_in_bytes,
+			payload_virt, payload_phys);
+exit_nfc:
+	return error;
+}
+
+static void gpmi_ecc_write_page(struct mtd_info *mtd,
+				struct nand_chip *nand, const uint8_t *buf)
+{
+	struct gpmi_nand_data *this = nand->priv;
+	struct bch_geometry *nfc_geo = &this->bch_geometry;
+	struct mil *mil = &this->mil;
+	const void *payload_virt;
+	dma_addr_t payload_phys;
+	const void *auxiliary_virt;
+	dma_addr_t auxiliary_phys;
+	int        error;
+
+	logio(GPMI_DEBUG_ECC_WRITE);
+	if (this->swap_block_mark) {
+		/*
+		 * If control arrives here, we're doing block mark swapping.
+		 * Since we can't modify the caller's buffers, we must copy them
+		 * into our own.
+		 */
+		memcpy(mil->payload_virt, buf, mtd->writesize);
+		payload_virt = mil->payload_virt;
+		payload_phys = mil->payload_phys;
+
+		memcpy(mil->auxiliary_virt, nand->oob_poi,
+				nfc_geo->auxiliary_size_in_bytes);
+		auxiliary_virt = mil->auxiliary_virt;
+		auxiliary_phys = mil->auxiliary_phys;
+
+		/* Handle block mark swapping. */
+		mil_handle_block_mark_swapping(this,
+				(void *) payload_virt, (void *) auxiliary_virt);
+	} else {
+		/*
+		 * If control arrives here, we're not doing block mark swapping,
+		 * so we can to try and use the caller's buffers.
+		 */
+		error = send_page_prepare(this,
+				buf, mtd->writesize,
+				mil->payload_virt, mil->payload_phys,
+				nfc_geo->payload_size_in_bytes,
+				&payload_virt, &payload_phys);
+		if (error) {
+			pr_info("Inadequate payload DMA buffer\n");
+			return;
+		}
+
+		error = send_page_prepare(this,
+				nand->oob_poi, mtd->oobsize,
+				mil->auxiliary_virt, mil->auxiliary_phys,
+				nfc_geo->auxiliary_size_in_bytes,
+				&auxiliary_virt, &auxiliary_phys);
+		if (error) {
+			pr_info("Inadequate auxiliary DMA buffer\n");
+			goto exit_auxiliary;
+		}
+	}
+
+	/* Ask the NFC. */
+	error = gpmi_send_page(this, payload_phys, auxiliary_phys);
+	if (error)
+		pr_info("Error in ECC-based write: %d\n", error);
+
+	if (!this->swap_block_mark) {
+		send_page_end(this, nand->oob_poi, mtd->oobsize,
+				mil->auxiliary_virt, mil->auxiliary_phys,
+				nfc_geo->auxiliary_size_in_bytes,
+				auxiliary_virt, auxiliary_phys);
+exit_auxiliary:
+		send_page_end(this, buf, mtd->writesize,
+				mil->payload_virt, mil->payload_phys,
+				nfc_geo->payload_size_in_bytes,
+				payload_virt, payload_phys);
+	}
+}
+
+/**
+ * gpmi_ecc_read_oob() - MTD Interface ecc.read_oob().
+ *
+ * There are several places in this driver where we have to handle the OOB and
+ * block marks. This is the function where things are the most complicated, so
+ * this is where we try to explain it all. All the other places refer back to
+ * here.
+ *
+ * These are the rules, in order of decreasing importance:
+ *
+ * 1) Nothing the caller does can be allowed to imperil the block mark, so all
+ *    write operations take measures to protect it.
+ *
+ * 2) In read operations, the first byte of the OOB we return must reflect the
+ *    true state of the block mark, no matter where that block mark appears in
+ *    the physical page.
+ *
+ * 3) ECC-based read operations return an OOB full of set bits (since we never
+ *    allow ECC-based writes to the OOB, it doesn't matter what ECC-based reads
+ *    return).
+ *
+ * 4) "Raw" read operations return a direct view of the physical bytes in the
+ *    page, using the conventional definition of which bytes are data and which
+ *    are OOB. This gives the caller a way to see the actual, physical bytes
+ *    in the page, without the distortions applied by our ECC engine.
+ *
+ *
+ * What we do for this specific read operation depends on two questions:
+ *
+ * 1) Are we doing a "raw" read, or an ECC-based read?
+ *
+ * 2) Are we using block mark swapping or transcription?
+ *
+ * There are four cases, illustrated by the following Karnaugh map:
+ *
+ *                    |           Raw           |         ECC-based       |
+ *       -------------+-------------------------+-------------------------+
+ *                    | Read the conventional   |                         |
+ *                    | OOB at the end of the   |                         |
+ *       Swapping     | page and return it. It  |                         |
+ *                    | contains exactly what   |                         |
+ *                    | we want.                | Read the block mark and |
+ *       -------------+-------------------------+ return it in a buffer   |
+ *                    | Read the conventional   | full of set bits.       |
+ *                    | OOB at the end of the   |                         |
+ *                    | page and also the block |                         |
+ *       Transcribing | mark in the metadata.   |                         |
+ *                    | Copy the block mark     |                         |
+ *                    | into the first byte of  |                         |
+ *                    | the OOB.                |                         |
+ *       -------------+-------------------------+-------------------------+
+ *
+ * Note that we break rule #4 in the Transcribing/Raw case because we're not
+ * giving an accurate view of the actual, physical bytes in the page (we're
+ * overwriting the block mark). That's OK because it's more important to follow
+ * rule #2.
+ *
+ * It turns out that knowing whether we want an "ECC-based" or "raw" read is not
+ * easy. When reading a page, for example, the NAND Flash MTD code calls our
+ * ecc.read_page or ecc.read_page_raw function. Thus, the fact that MTD wants an
+ * ECC-based or raw view of the page is implicit in which function it calls
+ * (there is a similar pair of ECC-based/raw functions for writing).
+ *
+ * Since MTD assumes the OOB is not covered by ECC, there is no pair of
+ * ECC-based/raw functions for reading or or writing the OOB. The fact that the
+ * caller wants an ECC-based or raw view of the page is not propagated down to
+ * this driver.
+ *
+ * @mtd:     A pointer to the owning MTD.
+ * @nand:    A pointer to the owning NAND Flash MTD.
+ * @page:    The page number to read.
+ * @sndcmd:  Indicates this function should send a command to the chip before
+ *           reading the out-of-band bytes. This is only false for small page
+ *           chips that support auto-increment.
+ */
+static int gpmi_ecc_read_oob(struct mtd_info *mtd, struct nand_chip *nand,
+							int page, int sndcmd)
+{
+	struct gpmi_nand_data *this = nand->priv;
+
+	/* clear the OOB buffer */
+	memset(nand->oob_poi, ~0, mtd->oobsize);
+
+	/* Read out the conventional OOB. */
+	nand->cmdfunc(mtd, NAND_CMD_READ0, mtd->writesize, page);
+	nand->read_buf(mtd, nand->oob_poi, mtd->oobsize);
+
+	/*
+	 * Now, we want to make sure the block mark is correct. In the
+	 * Swapping/Raw case, we already have it. Otherwise, we need to
+	 * explicitly read it.
+	 */
+	if (!this->swap_block_mark) {
+		/* Read the block mark into the first byte of the OOB buffer. */
+		nand->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
+		nand->oob_poi[0] = nand->read_byte(mtd);
+	}
+
+	/*
+	 * Return true, indicating that the next call to this function must send
+	 * a command.
+	 */
+	return true;
+}
+
+static int gpmi_block_markbad(struct mtd_info *mtd, loff_t ofs)
+{
+	struct nand_chip *nand = mtd->priv;
+	struct gpmi_nand_data *this = nand->priv;
+	int block, ret = 0;
+
+	/* Get block number */
+	block = (int)(ofs >> nand->bbt_erase_shift);
+	if (nand->bbt)
+		nand->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
+
+	/* Do we have a flash based bad block table ? */
+	if (nand->options & NAND_USE_FLASH_BBT)
+		ret = nand_update_bbt(mtd, ofs);
+	else {
+		struct mil *mil	= &this->mil;
+		uint8_t *block_mark;
+		int column, page, status, chipnr;
+
+		chipnr = (int)(ofs >> nand->chip_shift);
+		nand->select_chip(mtd, chipnr);
+
+		column = this->swap_block_mark ? mtd->writesize : 0;
+
+		/* Write the block mark. */
+		block_mark = mil->data_buffer_dma;
+		block_mark[0] = 0; /* bad block marker */
+
+		/* Shift to get page */
+		page = (int)(ofs >> nand->page_shift);
+
+		nand->cmdfunc(mtd, NAND_CMD_SEQIN, column, page);
+		nand->write_buf(mtd, block_mark, 1);
+		nand->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
+
+		status = nand->waitfunc(mtd, nand);
+		if (status & NAND_STATUS_FAIL)
+			ret = -EIO;
+
+		nand->select_chip(mtd, -1);
+	}
+	if (!ret)
+		mtd->ecc_stats.badblocks++;
+
+	return ret;
+}
+
+static int __devinit nand_boot_set_geometry(struct gpmi_nand_data *this)
+{
+	struct boot_rom_geometry *geometry = &this->rom_geometry;
+
+	/*
+	 * Set the boot block stride size.
+	 *
+	 * In principle, we should be reading this from the OTP bits, since
+	 * that's where the ROM is going to get it. In fact, we don't have any
+	 * way to read the OTP bits, so we go with the default and hope for the
+	 * best.
+	 */
+	geometry->stride_size_in_pages = 64;
+
+	/*
+	 * Set the search area stride exponent.
+	 *
+	 * In principle, we should be reading this from the OTP bits, since
+	 * that's where the ROM is going to get it. In fact, we don't have any
+	 * way to read the OTP bits, so we go with the default and hope for the
+	 * best.
+	 */
+	geometry->search_area_stride_exponent = 2;
+
+	if (gpmi_debug & GPMI_DEBUG_INIT)
+		pr_info("stride size in page : %d, search areas : %d\n",
+			geometry->stride_size_in_pages,
+			geometry->search_area_stride_exponent);
+	return 0;
+}
+
+static const char  *fingerprint = "STMP";
+static int __devinit mx23_check_transcription_stamp(struct gpmi_nand_data *this)
+{
+	struct boot_rom_geometry *rom_geo = &this->rom_geometry;
+	struct mil *mil = &this->mil;
+	struct mtd_info *mtd = &mil->mtd;
+	struct nand_chip *nand = &mil->nand;
+	unsigned int search_area_size_in_strides;
+	unsigned int stride;
+	unsigned int page;
+	loff_t byte;
+	uint8_t *buffer = nand->buffers->databuf;
+	int saved_chip_number;
+	int found_an_ncb_fingerprint = false;
+
+	/* Compute the number of strides in a search area. */
+	search_area_size_in_strides = 1 << rom_geo->search_area_stride_exponent;
+
+	/* Select chip 0. */
+	saved_chip_number = mil->current_chip;
+	nand->select_chip(mtd, 0);
+
+	/*
+	 * Loop through the first search area, looking for the NCB fingerprint.
+	 */
+	pr_info("Scanning for an NCB fingerprint...\n");
+
+	for (stride = 0; stride < search_area_size_in_strides; stride++) {
+		/* Compute the page and byte addresses. */
+		page = stride * rom_geo->stride_size_in_pages;
+		byte = page   * mtd->writesize;
+
+		pr_info("  Looking for a fingerprint in page 0x%x\n", page);
+
+		/*
+		 * Read the NCB fingerprint. The fingerprint is four bytes long
+		 * and starts in the 12th byte of the page.
+		 */
+		nand->cmdfunc(mtd, NAND_CMD_READ0, 12, page);
+		nand->read_buf(mtd, buffer, strlen(fingerprint));
+
+		/* Look for the fingerprint. */
+		if (!memcmp(buffer, fingerprint, strlen(fingerprint))) {
+			found_an_ncb_fingerprint = true;
+			break;
+		}
+
+	}
+
+	/* Deselect chip 0. */
+	nand->select_chip(mtd, saved_chip_number);
+
+	if (found_an_ncb_fingerprint)
+		pr_info("  Found a fingerprint\n");
+	else
+		pr_info("  No fingerprint found\n");
+	return found_an_ncb_fingerprint;
+}
+
+/* Writes a transcription stamp. */
+static int __devinit mx23_write_transcription_stamp(struct gpmi_nand_data *this)
+{
+	struct device *dev = this->dev;
+	struct boot_rom_geometry *rom_geo = &this->rom_geometry;
+	struct mil *mil = &this->mil;
+	struct mtd_info *mtd = &mil->mtd;
+	struct nand_chip *nand = &mil->nand;
+	unsigned int block_size_in_pages;
+	unsigned int search_area_size_in_strides;
+	unsigned int search_area_size_in_pages;
+	unsigned int search_area_size_in_blocks;
+	unsigned int block;
+	unsigned int stride;
+	unsigned int page;
+	loff_t       byte;
+	uint8_t      *buffer = nand->buffers->databuf;
+	int saved_chip_number;
+	int status;
+
+	/* Compute the search area geometry. */
+	block_size_in_pages = mtd->erasesize / mtd->writesize;
+	search_area_size_in_strides = 1 << rom_geo->search_area_stride_exponent;
+	search_area_size_in_pages = search_area_size_in_strides *
+					rom_geo->stride_size_in_pages;
+	search_area_size_in_blocks =
+		  (search_area_size_in_pages + (block_size_in_pages - 1)) /
+				    block_size_in_pages;
+
+	pr_info("-------------------------------------------\n");
+	pr_info("Search Area Geometry\n");
+	pr_info("-------------------------------------------\n");
+	pr_info("Search Area in Blocks : %u\n", search_area_size_in_blocks);
+	pr_info("Search Area in Strides: %u\n", search_area_size_in_strides);
+	pr_info("Search Area in Pages  : %u\n", search_area_size_in_pages);
+
+	/* Select chip 0. */
+	saved_chip_number = mil->current_chip;
+	nand->select_chip(mtd, 0);
+
+	/* Loop over blocks in the first search area, erasing them. */
+	pr_info("Erasing the search area...\n");
+
+	for (block = 0; block < search_area_size_in_blocks; block++) {
+		/* Compute the page address. */
+		page = block * block_size_in_pages;
+
+		/* Erase this block. */
+		pr_info("  Erasing block 0x%x\n", block);
+		nand->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
+		nand->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
+
+		/* Wait for the erase to finish. */
+		status = nand->waitfunc(mtd, nand);
+		if (status & NAND_STATUS_FAIL)
+			dev_err(dev, "[%s] Erase failed.\n", __func__);
+	}
+
+	/* Write the NCB fingerprint into the page buffer. */
+	memset(buffer, ~0, mtd->writesize);
+	memset(nand->oob_poi, ~0, mtd->oobsize);
+	memcpy(buffer + 12, fingerprint, strlen(fingerprint));
+
+	/* Loop through the first search area, writing NCB fingerprints. */
+	pr_info("Writing NCB fingerprints...\n");
+	for (stride = 0; stride < search_area_size_in_strides; stride++) {
+		/* Compute the page and byte addresses. */
+		page = stride * rom_geo->stride_size_in_pages;
+		byte = page   * mtd->writesize;
+
+		/* Write the first page of the current stride. */
+		pr_info("  Writing an NCB fingerprint in page 0x%x\n", page);
+		nand->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
+		nand->ecc.write_page_raw(mtd, nand, buffer);
+		nand->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
+
+		/* Wait for the write to finish. */
+		status = nand->waitfunc(mtd, nand);
+		if (status & NAND_STATUS_FAIL)
+			dev_err(dev, "[%s] Write failed.\n", __func__);
+	}
+
+	/* Deselect chip 0. */
+	nand->select_chip(mtd, saved_chip_number);
+	return 0;
+}
+
+static int __devinit mx23_boot_init(struct gpmi_nand_data  *this)
+{
+	struct device *dev = this->dev;
+	struct mil *mil = &this->mil;
+	struct nand_chip *nand = &mil->nand;
+	struct mtd_info *mtd = &mil->mtd;
+	unsigned int block_count;
+	unsigned int block;
+	int     chip;
+	int     page;
+	loff_t  byte;
+	uint8_t block_mark;
+	int     error = 0;
+
+	/*
+	 * If control arrives here, we can't use block mark swapping, which
+	 * means we're forced to use transcription. First, scan for the
+	 * transcription stamp. If we find it, then we don't have to do
+	 * anything -- the block marks are already transcribed.
+	 */
+	if (mx23_check_transcription_stamp(this))
+		return 0;
+
+	/*
+	 * If control arrives here, we couldn't find a transcription stamp, so
+	 * so we presume the block marks are in the conventional location.
+	 */
+	pr_info("Transcribing bad block marks...\n");
+
+	/* Compute the number of blocks in the entire medium. */
+	block_count = nand->chipsize >> nand->phys_erase_shift;
+
+	/*
+	 * Loop over all the blocks in the medium, transcribing block marks as
+	 * we go.
+	 */
+	for (block = 0; block < block_count; block++) {
+		/*
+		 * Compute the chip, page and byte addresses for this block's
+		 * conventional mark.
+		 */
+		chip = block >> (nand->chip_shift - nand->phys_erase_shift);
+		page = block << (nand->phys_erase_shift - nand->page_shift);
+		byte = block <<  nand->phys_erase_shift;
+
+		/* Send the command to read the conventional block mark. */
+		nand->select_chip(mtd, chip);
+		nand->cmdfunc(mtd, NAND_CMD_READ0, mtd->writesize, page);
+		block_mark = nand->read_byte(mtd);
+		nand->select_chip(mtd, -1);
+
+		/*
+		 * Check if the block is marked bad. If so, we need to mark it
+		 * again, but this time the result will be a mark in the
+		 * location where we transcribe block marks.
+		 */
+		if (block_mark != 0xff) {
+			pr_info("Transcribing mark in block %u\n", block);
+			error = nand->block_markbad(mtd, byte);
+			if (error)
+				dev_err(dev, "Failed to mark block bad with "
+							"error %d\n", error);
+		}
+	}
+
+	/* Write the stamp that indicates we've transcribed the block marks. */
+	mx23_write_transcription_stamp(this);
+	return 0;
+}
+
+static int __devinit nand_boot_init(struct gpmi_nand_data  *this)
+{
+	nand_boot_set_geometry(this);
+
+	/* This is ROM arch-specific initilization before the BBT scanning. */
+	if (GPMI_IS_MX23(this))
+		return mx23_boot_init(this);
+	return 0;
+}
+
+static int __devinit mil_set_geometry(struct gpmi_nand_data *this)
+{
+	int error;
+
+	/* Free the temporary DMA memory for reading ID. */
+	mil_free_dma_buffer(this);
+
+	/* Set up the NFC geometry which is used by BCH. */
+	error = bch_set_geometry(this);
+	if (error) {
+		pr_info("set geometry error : %d\n", error);
+		return error;
+	}
+
+	/* Alloc the new DMA buffers according to the pagesize and oobsize */
+	return mil_alloc_dma_buffer(this);
+}
+
+static int mil_pre_bbt_scan(struct gpmi_nand_data  *this)
+{
+	struct nand_chip *nand = &this->mil.nand;
+	struct mtd_info *mtd = &this->mil.mtd;
+	struct nand_ecclayout *layout = nand->ecc.layout;
+	int error;
+
+	/*
+	 *  fix the ECC layout before the scanning.
+	 *  We will use all the (page + OOB).
+	 */
+	layout->eccbytes = 0;
+	layout->oobavail = 0;
+
+	mtd->oobavail = mtd->oobsize;
+
+	/* Set up swap block-mark, must be set before the mil_set_geometry() */
+	if (GPMI_IS_MX23(this))
+		this->swap_block_mark = false;
+	else
+		this->swap_block_mark = true;
+
+	/* Set up the medium geometry */
+	error = mil_set_geometry(this);
+	if (error)
+		return error;
+
+	/* NAND boot init, depends on the mil_set_geometry(). */
+	return nand_boot_init(this);
+}
+
+static int gpmi_scan_bbt(struct mtd_info *mtd)
+{
+	struct nand_chip *nand = mtd->priv;
+	struct gpmi_nand_data *this = nand->priv;
+	int error;
+
+	/* Prepare for the BBT scan. */
+	error = mil_pre_bbt_scan(this);
+	if (error)
+		return error;
+
+	/* use the default BBT implementation */
+	return nand_default_bbt(mtd);
+}
+
+static const char *cmd_parse[] = {"cmdlinepart", NULL};
+static int __devinit mil_partitions_init(struct gpmi_nand_data *this)
+{
+	struct gpmi_nand_platform_data *pdata = this->pdata;
+	struct mil *mil = &this->mil;
+	struct mtd_info *mtd = &mil->mtd;
+
+	/* use the command line for simple partitions layout */
+	mil->partition_count = parse_mtd_partitions(mtd, cmd_parse,
+						&mil->partitions, 0);
+	if (mil->partition_count)
+		return mtd_device_register(mtd, mil->partitions,
+					mil->partition_count);
+
+	/* The complicated partitions layout uses this. */
+	if (pdata->partitions && pdata->partition_count > 0)
+		return mtd_device_register(mtd, pdata->partitions,
+					pdata->partition_count);
+	return mtd_device_register(mtd, NULL, 0);
+}
+
+static void mil_partitions_exit(struct gpmi_nand_data *this)
+{
+	struct mil *mil = &this->mil;
+	struct mtd_info *mtd = &mil->mtd;
+
+	mtd_device_unregister(mtd);
+	kfree(mil->partitions);
+	mil->partition_count = 0;
+}
+
+/* Initializes the MTD Interface Layer */
+static int __devinit gpmi_nfc_mil_init(struct gpmi_nand_data *this)
+{
+	struct gpmi_nand_platform_data *pdata = this->pdata;
+	struct mil *mil = &this->mil;
+	struct mtd_info  *mtd = &mil->mtd;
+	struct nand_chip *nand = &mil->nand;
+	int error;
+
+	/* Initialize data */
+	mil->current_chip	= -1;
+
+	/* Initialize the MTD data structures */
+	mtd->priv		= nand;
+	mtd->name		= "gpmi-nand";
+	mtd->owner		= THIS_MODULE;
+	nand->priv		= this;
+
+	/* Controls */
+	nand->select_chip	= gpmi_select_chip;
+	nand->cmd_ctrl		= gpmi_cmd_ctrl;
+	nand->dev_ready		= gpmi_dev_ready;
+
+	/*
+	 * Low-level I/O :
+	 *	We don't support a 16-bit NAND Flash bus,
+	 *	so we don't implement read_word.
+	 */
+	nand->read_byte		= gpmi_read_byte;
+	nand->read_buf		= gpmi_read_buf;
+	nand->write_buf		= gpmi_write_buf;
+
+	/* ECC-aware I/O */
+	nand->ecc.read_page	= gpmi_ecc_read_page;
+	nand->ecc.write_page	= gpmi_ecc_write_page;
+
+	/* High-level I/O */
+	nand->ecc.read_oob	= gpmi_ecc_read_oob;
+
+	/* Bad Block Management */
+	nand->scan_bbt		= gpmi_scan_bbt;
+	nand->badblock_pattern	= &gpmi_bbt_descr;
+	nand->block_markbad	= gpmi_block_markbad;
+
+	/* Disallow partial page writes */
+	nand->options		|= NAND_NO_SUBPAGE_WRITE;
+
+	/*
+	 * Tell the NAND Flash MTD system that we'll be handling ECC with our
+	 * own hardware. It turns out that we still have to fill in the ECC size
+	 * because the MTD code will divide by it -- even though it doesn't
+	 * actually care.
+	 */
+	nand->ecc.mode		= NAND_ECC_HW;
+	nand->ecc.size		= 1;
+
+	/* use our layout */
+	nand->ecc.layout = &mil->oob_layout;
+
+	/* Allocate a temporary DMA buffer for reading ID in the nand_scan() */
+	this->bch_geometry.payload_size_in_bytes	= 1024;
+	this->bch_geometry.auxiliary_size_in_bytes	= 128;
+	error = mil_alloc_dma_buffer(this);
+	if (error)
+		goto exit_dma_allocation;
+
+	printk(KERN_INFO "GPMI-NAND : Scanning for NAND Flash chips...\n");
+	error = nand_scan(mtd, pdata->max_chip_count);
+	if (error) {
+		pr_info("Chip scan failed\n");
+		goto exit_nand_scan;
+	}
+
+	/* Construct partitions as necessary. */
+	error = mil_partitions_init(this);
+	if (error)
+		goto exit_partitions;
+	return 0;
+
+exit_partitions:
+	nand_release(&mil->mtd);
+exit_nand_scan:
+	mil_free_dma_buffer(this);
+exit_dma_allocation:
+	return error;
+}
+
+void gpmi_nand_mil_exit(struct gpmi_nand_data *this)
+{
+	struct mil *mil = &this->mil;
+
+	mil_partitions_exit(this);
+	nand_release(&mil->mtd);
+	mil_free_dma_buffer(this);
+}
+
+static int __devinit gpmi_nand_probe(struct platform_device *pdev)
+{
+	struct gpmi_nand_platform_data *pdata = pdev->dev.platform_data;
+	struct gpmi_nand_data *this;
+	int error;
+
+	this = kzalloc(sizeof(*this), GFP_KERNEL);
+	if (!this) {
+		pr_info("Failed to allocate per-device memory\n");
+		return -ENOMEM;
+	}
+
+	/* Set up our data structures. */
+	platform_set_drvdata(pdev, this);
+	this->pdev  = pdev;
+	this->dev   = &pdev->dev;
+	this->pdata = pdata;
+
+	/* setup the platform */
+	if (pdata->platform_init) {
+		error = pdata->platform_init();
+		if (error)
+			goto platform_init_error;
+	}
+
+	/* Acquire the resources we need. */
+	error = acquire_resources(this);
+	if (error)
+		goto exit_acquire_resources;
+
+	/* Set up the GPMI/BCH hardware. */
+	error = init_hardware(this);
+	if (error)
+		goto exit_nfc_init;
+
+	/* Initialize the MTD Interface Layer. */
+	error = gpmi_nfc_mil_init(this);
+	if (error)
+		goto exit_mil_init;
+
+	return 0;
+
+exit_mil_init:
+exit_nfc_init:
+	release_resources(this);
+platform_init_error:
+exit_acquire_resources:
+	platform_set_drvdata(pdev, NULL);
+	kfree(this);
+	return error;
+}
+
+static int __exit gpmi_nand_remove(struct platform_device *pdev)
+{
+	struct gpmi_nand_data *this = platform_get_drvdata(pdev);
+
+	gpmi_nand_mil_exit(this);
+	release_resources(this);
+	platform_set_drvdata(pdev, NULL);
+	kfree(this);
+	return 0;
+}
+
+static const struct platform_device_id gpmi_ids[] = {
+	{
+		.name = "imx23-gpmi-nand",
+		.driver_data = IS_MX23,
+	}, {
+		.name = "imx28-gpmi-nand",
+		.driver_data = IS_MX28,
+	}, {},
+};
+
+/* This structure represents this driver to the platform management system. */
+static struct platform_driver gpmi_nand_driver = {
+	.driver = {
+		.name = "gpmi-nand",
+	},
+	.probe   = gpmi_nand_probe,
+	.remove  = __exit_p(gpmi_nand_remove),
+	.id_table = gpmi_ids,
+};
+
+static int __init gpmi_nand_init(void)
+{
+	int err;
+
+	err = platform_driver_register(&gpmi_nand_driver);
+	if (err == 0)
+		printk(KERN_INFO "GPMI NAND driver registered. (IMX)\n");
+	else
+		pr_err("i.MX GPMI NAND driver registration failed\n");
+	return err;
+}
+
+static void __exit gpmi_nand_exit(void)
+{
+	platform_driver_unregister(&gpmi_nand_driver);
+}
+
+module_init(gpmi_nand_init);
+module_exit(gpmi_nand_exit);
+
+MODULE_AUTHOR("Freescale Semiconductor, Inc.");
+MODULE_DESCRIPTION("i.MX GPMI NAND Flash Controller Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mtd/nand/gpmi-nand/gpmi-nand.h b/drivers/mtd/nand/gpmi-nand/gpmi-nand.h
new file mode 100644
index 0000000..daab719
--- /dev/null
+++ b/drivers/mtd/nand/gpmi-nand/gpmi-nand.h
@@ -0,0 +1,377 @@ 
+/*
+ * Freescale GPMI NAND Flash Driver
+ *
+ * Copyright (C) 2010-2011 Freescale Semiconductor, Inc.
+ * Copyright (C) 2008 Embedded Alley Solutions, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#ifndef __DRIVERS_MTD_NAND_GPMI_NAND_H
+#define __DRIVERS_MTD_NAND_GPMI_NAND_H
+
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/io.h>
+#include <linux/interrupt.h>
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/nand.h>
+#include <linux/mtd/partitions.h>
+#include <linux/mtd/concat.h>
+#include <linux/dmaengine.h>
+#include <asm/sizes.h>
+
+#include <mach/common.h>
+#include <mach/dma.h>
+#include <linux/mtd/gpmi-nand.h>
+#include <mach/system.h>
+#include <mach/clock.h>
+
+/* The collection of resources the driver needs. */
+struct resources {
+	void          *gpmi_regs;
+	void          *bch_regs;
+	unsigned int  bch_low_interrupt;
+	unsigned int  bch_high_interrupt;
+	unsigned int  dma_low_channel;
+	unsigned int  dma_high_channel;
+	struct clk    *clock;
+};
+
+/**
+ * struct mil - State for the MTD Interface Layer.
+ *
+ * @nand:                    The NAND Flash MTD data structure that represents
+ *                           the NAND Flash medium.
+ * @mtd:                     The MTD data structure that represents the NAND
+ *                           Flash medium.
+ * @oob_layout:              A structure that describes how bytes are laid out
+ *                           in the OOB.
+ * @partitions:              A pointer to a set of partitions.
+ * @partition_count:         The number of partitions.
+ * @current_chip:            The chip currently selected by the NAND Fash MTD
+ *                           code. A negative value indicates that no chip is
+ *                           selected.
+ * @command_length:          The length of the command that appears in the
+ *                           command buffer (see cmd_virt, below).
+ * @ignore_bad_block_marks:  Indicates we are ignoring bad block marks.
+ * @upper_buf:               The buffer passed from upper layer.
+ * @upper_len:               The buffer len passed from upper layer.
+ * @direct_dma_map_ok:       Is the direct DMA map is good for the upper_buf?
+ * @cmd_sgl/cmd_buffer:      For NAND command.
+ * @data_sgl/data_buffer_dma:For NAND DATA ops.
+ * @page_buffer_virt:        A pointer to a DMA-coherent buffer we use for
+ *                           reading and writing pages. This buffer includes
+ *                           space for both the payload data and the auxiliary
+ *                           data (including status bytes, but not syndrome
+ *                           bytes).
+ * @page_buffer_phys:        The physical address for the page_buffer_virt
+ *                           buffer.
+ * @page_buffer_size:        The size of the page buffer.
+ * @payload_virt:            A pointer to a location in the page buffer used
+ *                           for payload bytes. The size of this buffer is
+ *                           determined by struct bch_geometry.
+ * @payload_phys:            The physical address for payload_virt.
+ * @auxiliary_virt:          A pointer to a location in the page buffer used
+ *                           for auxiliary bytes. The size of this buffer is
+ *                           determined by struct bch_geometry.
+ * @auxiliary_phys:          The physical address for auxiliary_virt.
+ */
+struct mil {
+	/* MTD Data Structures */
+	struct nand_chip       nand;
+	struct mtd_info        mtd;
+	struct nand_ecclayout  oob_layout;
+
+	/* Partitions*/
+	struct mtd_partition   *partitions;
+	unsigned int           partition_count;
+
+	/* General-use Variables */
+	int                    current_chip;
+	unsigned int           command_length;
+	int                    ignore_bad_block_marks;
+
+	/* from upper layer */
+	uint8_t			*upper_buf;
+	int			upper_len;
+
+	/* DMA */
+	bool			direct_dma_map_ok;
+
+	struct scatterlist	cmd_sgl;
+	char			*cmd_buffer;
+
+	struct scatterlist	data_sgl;
+	char			*data_buffer_dma;
+
+	void                   *page_buffer_virt;
+	dma_addr_t             page_buffer_phys;
+	unsigned int           page_buffer_size;
+
+	void                   *payload_virt;
+	dma_addr_t             payload_phys;
+
+	void                   *auxiliary_virt;
+	dma_addr_t             auxiliary_phys;
+};
+
+/**
+ * struct bch_geometry - NFC geometry description.
+ *
+ * This structure describes the NFC's view of the medium geometry.
+ *
+ * @ecc_algorithm:            The human-readable name of the ECC algorithm
+ *                            (e.g., "Reed-Solomon" or "BCH").
+ * @ecc_strength:             A number that describes the strength of the ECC
+ *                            algorithm.
+ * @page_size_in_bytes:       The size, in bytes, of a physical page, including
+ *                            both data and OOB.
+ * @metadata_size_in_bytes:   The size, in bytes, of the metadata.
+ * @ecc_chunk_size_in_bytes:  The size, in bytes, of a single ECC chunk. Note
+ *                            the first chunk in the page includes both data and
+ *                            metadata, so it's a bit larger than this value.
+ * @ecc_chunk_count:          The number of ECC chunks in the page,
+ * @payload_size_in_bytes:    The size, in bytes, of the payload buffer.
+ * @auxiliary_size_in_bytes:  The size, in bytes, of the auxiliary buffer.
+ * @auxiliary_status_offset:  The offset into the auxiliary buffer at which
+ *                            the ECC status appears.
+ * @block_mark_byte_offset:   The byte offset in the ECC-based page view at
+ *                            which the underlying physical block mark appears.
+ * @block_mark_bit_offset:    The bit offset into the ECC-based page view at
+ *                            which the underlying physical block mark appears.
+ */
+struct bch_geometry {
+	char          *ecc_algorithm;
+	unsigned int  ecc_strength;
+	unsigned int  page_size_in_bytes;
+	unsigned int  metadata_size_in_bytes;
+	unsigned int  ecc_chunk_size_in_bytes;
+	unsigned int  ecc_chunk_count;
+	unsigned int  payload_size_in_bytes;
+	unsigned int  auxiliary_size_in_bytes;
+	unsigned int  auxiliary_status_offset;
+	unsigned int  block_mark_byte_offset;
+	unsigned int  block_mark_bit_offset;
+};
+
+/**
+ * struct boot_rom_geometry - Boot ROM geometry description.
+ *
+ * @stride_size_in_pages:        The size of a boot block stride, in pages.
+ * @search_area_stride_exponent: The logarithm to base 2 of the size of a
+ *                               search area in boot block strides.
+ */
+struct boot_rom_geometry {
+	unsigned int  stride_size_in_pages;
+	unsigned int  search_area_stride_exponent;
+};
+
+/* DMA operations types */
+enum dma_ops_type {
+	DMA_FOR_COMMAND = 1,
+	DMA_FOR_READ_DATA,
+	DMA_FOR_WRITE_DATA,
+	DMA_FOR_READ_ECC_PAGE,
+	DMA_FOR_WRITE_ECC_PAGE
+};
+
+/**
+ * This structure contains the fundamental timing attributes for NAND.
+ *
+ * @data_setup_in_ns:         The data setup time, in nanoseconds. Usually the
+ *                            maximum of tDS and tWP. A negative value
+ *                            indicates this characteristic isn't known.
+ * @data_hold_in_ns:          The data hold time, in nanoseconds. Usually the
+ *                            maximum of tDH, tWH and tREH. A negative value
+ *                            indicates this characteristic isn't known.
+ * @address_setup_in_ns:      The address setup time, in nanoseconds. Usually
+ *                            the maximum of tCLS, tCS and tALS. A negative
+ *                            value indicates this characteristic isn't known.
+ * @gpmi_sample_delay_in_ns:  A GPMI-specific timing parameter. A negative value
+ *                            indicates this characteristic isn't known.
+ * @tREA_in_ns:               tREA, in nanoseconds, from the data sheet. A
+ *                            negative value indicates this characteristic isn't
+ *                            known.
+ * @tRLOH_in_ns:              tRLOH, in nanoseconds, from the data sheet. A
+ *                            negative value indicates this characteristic isn't
+ *                            known.
+ * @tRHOH_in_ns:              tRHOH, in nanoseconds, from the data sheet. A
+ *                            negative value indicates this characteristic isn't
+ *                            known.
+ */
+struct nand_timing {
+	int8_t  data_setup_in_ns;
+	int8_t  data_hold_in_ns;
+	int8_t  address_setup_in_ns;
+	int8_t  gpmi_sample_delay_in_ns;
+	int8_t  tREA_in_ns;
+	int8_t  tRLOH_in_ns;
+	int8_t  tRHOH_in_ns;
+};
+
+struct gpmi_nand_data {
+	/* System Interface */
+	struct device			*dev;
+	struct platform_device		*pdev;
+	struct gpmi_nand_platform_data	*pdata;
+
+	/* Resources */
+	struct resources		resources;
+
+	/* Flash Hardware */
+	struct nand_timing		timing;
+
+	/* BCH */
+	struct bch_geometry		bch_geometry;
+	struct completion		bch_done;
+
+	/* NAND Boot issue */
+	bool				swap_block_mark;
+	struct boot_rom_geometry	rom_geometry;
+
+	/* MTD Interface Layer */
+	struct mil			mil;
+
+	/* DMA channels */
+#define DMA_CHANS			8
+	struct dma_chan			*dma_chans[DMA_CHANS];
+	struct mxs_dma_data		dma_data;
+	enum dma_ops_type		last_dma_type;
+	enum dma_ops_type		dma_type;
+	struct completion		dma_done;
+
+	/* private */
+	void				*private;
+};
+
+/**
+ * struct gpmi_nfc_hardware_timing - GPMI hardware timing parameters.
+ *
+ * This structure contains timing information expressed in a form directly
+ * usable by the GPMI hardware.
+ *
+ * @data_setup_in_cycles:      The data setup time, in cycles.
+ * @data_hold_in_cycles:       The data hold time, in cycles.
+ * @address_setup_in_cycles:   The address setup time, in cycles.
+ * @use_half_periods:          Indicates the clock is running slowly, so the
+ *                             NFC DLL should use half-periods.
+ * @sample_delay_factor:       The sample delay factor.
+ */
+struct gpmi_nfc_hardware_timing {
+	uint8_t  data_setup_in_cycles;
+	uint8_t  data_hold_in_cycles;
+	uint8_t  address_setup_in_cycles;
+	bool     use_half_periods;
+	uint8_t  sample_delay_factor;
+};
+
+/**
+ * struct timing_threshod - timing threshold
+ *
+ * @max_data_setup_cycles:       The maximum number of data setup cycles that
+ *                               can be expressed in the hardware.
+ * @internal_data_setup_in_ns:   The time, in ns, that the NFC hardware requires
+ *                               for data read internal setup. In the Reference
+ *                               Manual, see the chapter "High-Speed NAND
+ *                               Timing" for more details.
+ * @max_sample_delay_factor:     The maximum sample delay factor that can be
+ *                               expressed in the hardware.
+ * @max_dll_clock_period_in_ns:  The maximum period of the GPMI clock that the
+ *                               sample delay DLL hardware can possibly work
+ *                               with (the DLL is unusable with longer periods).
+ *                               If the full-cycle period is greater than HALF
+ *                               this value, the DLL must be configured to use
+ *                               half-periods.
+ * @max_dll_delay_in_ns:         The maximum amount of delay, in ns, that the
+ *                               DLL can implement.
+ * @clock_frequency_in_hz:       The clock frequency, in Hz, during the current
+ *                               I/O transaction. If no I/O transaction is in
+ *                               progress, this is the clock frequency during
+ *                               the most recent I/O transaction.
+ */
+struct timing_threshod {
+	const unsigned int      max_chip_count;
+	const unsigned int      max_data_setup_cycles;
+	const unsigned int      internal_data_setup_in_ns;
+	const unsigned int      max_sample_delay_factor;
+	const unsigned int      max_dll_clock_period_in_ns;
+	const unsigned int      max_dll_delay_in_ns;
+	unsigned long           clock_frequency_in_hz;
+
+};
+
+/* Common Services */
+extern int common_nfc_set_geometry(struct gpmi_nand_data *);
+extern struct dma_chan *get_dma_chan(struct gpmi_nand_data *);
+extern void prepare_data_dma(struct gpmi_nand_data *,
+				enum dma_data_direction dr);
+extern int start_dma_without_bch_irq(struct gpmi_nand_data *,
+				struct dma_async_tx_descriptor *);
+extern int start_dma_with_bch_irq(struct gpmi_nand_data *,
+				struct dma_async_tx_descriptor *);
+
+/* GPMI-NAND helper function library */
+extern int gpmi_init(struct gpmi_nand_data *);
+extern void gpmi_clear_bch(struct gpmi_nand_data *);
+extern void gpmi_show_regs(struct gpmi_nand_data *);
+extern int bch_set_geometry(struct gpmi_nand_data *);
+extern int gpmi_is_ready(struct gpmi_nand_data *, unsigned chip);
+extern int gpmi_send_command(struct gpmi_nand_data *);
+extern void gpmi_begin(struct gpmi_nand_data *);
+extern void gpmi_end(struct gpmi_nand_data *);
+extern int gpmi_read_data(struct gpmi_nand_data *);
+extern int gpmi_send_data(struct gpmi_nand_data *);
+extern int gpmi_send_page(struct gpmi_nand_data *,
+			dma_addr_t payload, dma_addr_t auxiliary);
+extern int gpmi_read_page(struct gpmi_nand_data *,
+			dma_addr_t payload, dma_addr_t auxiliary);
+
+/* ONFI or TOGGLE nand */
+bool is_ddr_nand(struct gpmi_nand_data *);
+
+/* for log */
+extern int gpmi_debug;
+#define GPMI_DEBUG_INIT		0x0001
+#define GPMI_DEBUG_READ		0x0002
+#define GPMI_DEBUG_WRITE	0x0004
+#define GPMI_DEBUG_ECC_READ	0x0008
+#define GPMI_DEBUG_ECC_WRITE	0x0010
+#define GPMI_DEBUG_CRAZY	0x0020
+
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+
+#define pr_fmt(fmt) "[ %s : %.3d ] " fmt, __func__, __LINE__
+
+#define logio(level)				\
+		do {				\
+			if (gpmi_debug & level)	\
+				pr_info("\n");	\
+		} while (0)
+
+/* BCH : Status Block Completion Codes */
+#define STATUS_GOOD		0x00
+#define STATUS_ERASED		0xff
+#define STATUS_UNCORRECTABLE	0xfe
+
+/* Use the platform_id to distinguish different Archs. */
+#define IS_MX23			0x1
+#define IS_MX28			0x2
+#define GPMI_IS_MX23(x)		((x)->pdev->id_entry->driver_data == IS_MX23)
+#define GPMI_IS_MX28(x)		((x)->pdev->id_entry->driver_data == IS_MX28)
+#endif