[deliverable/linux.git] / drivers / mtd / nand / nomadik_nand.c

/*
 *  drivers/mtd/nand/nomadik_nand.c
 *
 *  Overview:
 *  	Driver for on-board NAND flash on Nomadik Platforms
 *
 * Copyright © 2007 STMicroelectronics Pvt. Ltd.
 * Author: Sachin Verma <sachin.verma@st.com>
 *
 * Copyright © 2009 Alessandro Rubini
 *
 * 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.
 *
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/nand.h>
#include <linux/mtd/nand_ecc.h>
#include <linux/platform_device.h>
#include <linux/mtd/partitions.h>
#include <linux/io.h>
#include <linux/slab.h>
#include <linux/platform_data/mtd-nomadik-nand.h>
#include <mach/fsmc.h>

#include <mtd/mtd-abi.h>

struct nomadik_nand_host {
	struct mtd_info		mtd;
	struct nand_chip	nand;
	void __iomem *data_va;
	void __iomem *cmd_va;
	void __iomem *addr_va;
	struct nand_bbt_descr *bbt_desc;
};

static struct nand_ecclayout nomadik_ecc_layout = {
	.eccbytes = 3 * 4,
	.eccpos = { /* each subpage has 16 bytes: pos 2,3,4 hosts ECC */
		0x02, 0x03, 0x04,
		0x12, 0x13, 0x14,
		0x22, 0x23, 0x24,
		0x32, 0x33, 0x34},
	/* let's keep bytes 5,6,7 for us, just in case we change ECC algo */
	.oobfree = { {0x08, 0x08}, {0x18, 0x08}, {0x28, 0x08}, {0x38, 0x08} },
};

static void nomadik_ecc_control(struct mtd_info *mtd, int mode)
{
	/* No need to enable hw ecc, it's on by default */
}

static void nomadik_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
{
	struct nand_chip *nand = mtd->priv;
	struct nomadik_nand_host *host = nand->priv;

	if (cmd == NAND_CMD_NONE)
		return;

	if (ctrl & NAND_CLE)
		writeb(cmd, host->cmd_va);
	else
		writeb(cmd, host->addr_va);
}

static int nomadik_nand_probe(struct platform_device *pdev)
{
	struct nomadik_nand_platform_data *pdata = pdev->dev.platform_data;
	struct nomadik_nand_host *host;
	struct mtd_info *mtd;
	struct nand_chip *nand;
	struct resource *res;
	int ret = 0;

	/* Allocate memory for the device structure (and zero it) */
	host = kzalloc(sizeof(struct nomadik_nand_host), GFP_KERNEL);
	if (!host) {
		dev_err(&pdev->dev, "Failed to allocate device structure.\n");
		return -ENOMEM;
	}

	/* Call the client's init function, if any */
	if (pdata->init)
		ret = pdata->init();
	if (ret < 0) {
		dev_err(&pdev->dev, "Init function failed\n");
		goto err;
	}

	/* ioremap three regions */
	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "nand_addr");
	if (!res) {
		ret = -EIO;
		goto err_unmap;
	}
	host->addr_va = ioremap(res->start, resource_size(res));

	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "nand_data");
	if (!res) {
		ret = -EIO;
		goto err_unmap;
	}
	host->data_va = ioremap(res->start, resource_size(res));

	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "nand_cmd");
	if (!res) {
		ret = -EIO;
		goto err_unmap;
	}
	host->cmd_va = ioremap(res->start, resource_size(res));

	if (!host->addr_va || !host->data_va || !host->cmd_va) {
		ret = -ENOMEM;
		goto err_unmap;
	}

	/* Link all private pointers */
	mtd = &host->mtd;
	nand = &host->nand;
	mtd->priv = nand;
	nand->priv = host;

	host->mtd.owner = THIS_MODULE;
	nand->IO_ADDR_R = host->data_va;
	nand->IO_ADDR_W = host->data_va;
	nand->cmd_ctrl = nomadik_cmd_ctrl;

	/*
	 * This stanza declares ECC_HW but uses soft routines. It's because
	 * HW claims to make the calculation but not the correction. However,
	 * I haven't managed to get the desired data out of it until now.
	 */
	nand->ecc.mode = NAND_ECC_SOFT;
	nand->ecc.layout = &nomadik_ecc_layout;
	nand->ecc.hwctl = nomadik_ecc_control;
	nand->ecc.size = 512;
	nand->ecc.bytes = 3;

	nand->options = pdata->options;

	/*
	 * Scan to find existence of the device
	 */
	if (nand_scan(&host->mtd, 1)) {
		ret = -ENXIO;
		goto err_unmap;
	}

	mtd_device_register(&host->mtd, pdata->parts, pdata->nparts);

	platform_set_drvdata(pdev, host);
	return 0;

 err_unmap:
	if (host->cmd_va)
		iounmap(host->cmd_va);
	if (host->data_va)
		iounmap(host->data_va);
	if (host->addr_va)
		iounmap(host->addr_va);
 err:
	kfree(host);
	return ret;
}

/*
 * Clean up routine
 */
static int nomadik_nand_remove(struct platform_device *pdev)
{
	struct nomadik_nand_host *host = platform_get_drvdata(pdev);
	struct nomadik_nand_platform_data *pdata = pdev->dev.platform_data;

	if (pdata->exit)
		pdata->exit();

	if (host) {
		nand_release(&host->mtd);
		iounmap(host->cmd_va);
		iounmap(host->data_va);
		iounmap(host->addr_va);
		kfree(host);
	}
	return 0;
}

static int nomadik_nand_suspend(struct device *dev)
{
	struct nomadik_nand_host *host = dev_get_drvdata(dev);
	int ret = 0;
	if (host)
		ret = mtd_suspend(&host->mtd);
	return ret;
}

static int nomadik_nand_resume(struct device *dev)
{
	struct nomadik_nand_host *host = dev_get_drvdata(dev);
	if (host)
		mtd_resume(&host->mtd);
	return 0;
}

static const struct dev_pm_ops nomadik_nand_pm_ops = {
	.suspend = nomadik_nand_suspend,
	.resume = nomadik_nand_resume,
};

static struct platform_driver nomadik_nand_driver = {
	.probe = nomadik_nand_probe,
	.remove = nomadik_nand_remove,
	.driver = {
		.owner = THIS_MODULE,
		.name = "nomadik_nand",
		.pm = &nomadik_nand_pm_ops,
	},
};

module_platform_driver(nomadik_nand_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("ST Microelectronics (sachin.verma@st.com)");
MODULE_DESCRIPTION("NAND driver for Nomadik Platform");
Commit	Line	Data
63234717 AR	1	/*
	2	* drivers/mtd/nand/nomadik_nand.c
	3	*
	4	* Overview:
	5	* Driver for on-board NAND flash on Nomadik Platforms
	6	*
	7	* Copyright © 2007 STMicroelectronics Pvt. Ltd.
	8	* Author: Sachin Verma <sachin.verma@st.com>
	9	*
	10	* Copyright © 2009 Alessandro Rubini
	11	*
	12	* This program is free software; you can redistribute it and/or modify
	13	* it under the terms of the GNU General Public License as published by
	14	* the Free Software Foundation; either version 2 of the License, or
	15	* (at your option) any later version.
	16	*
	17	* This program is distributed in the hope that it will be useful,
	18	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	20	* GNU General Public License for more details.
	21	*
	22	*/
	23
	24	#include <linux/init.h>
	25	#include <linux/module.h>
	26	#include <linux/types.h>
	27	#include <linux/mtd/mtd.h>
	28	#include <linux/mtd/nand.h>
	29	#include <linux/mtd/nand_ecc.h>
	30	#include <linux/platform_device.h>
	31	#include <linux/mtd/partitions.h>
	32	#include <linux/io.h>
5a0e3ad6	33	#include <linux/slab.h>
db298da2	34	#include <linux/platform_data/mtd-nomadik-nand.h>
63234717 AR	35	#include <mach/fsmc.h>
	36
	37	#include <mtd/mtd-abi.h>
	38
	39	struct nomadik_nand_host {
	40	struct mtd_info mtd;
	41	struct nand_chip nand;
	42	void __iomem *data_va;
	43	void __iomem *cmd_va;
	44	void __iomem *addr_va;
	45	struct nand_bbt_descr *bbt_desc;
	46	};
	47
	48	static struct nand_ecclayout nomadik_ecc_layout = {
	49	.eccbytes = 3 * 4,
	50	.eccpos = { /* each subpage has 16 bytes: pos 2,3,4 hosts ECC */
	51	0x02, 0x03, 0x04,
	52	0x12, 0x13, 0x14,
	53	0x22, 0x23, 0x24,
	54	0x32, 0x33, 0x34},
	55	/* let's keep bytes 5,6,7 for us, just in case we change ECC algo */
	56	.oobfree = { {0x08, 0x08}, {0x18, 0x08}, {0x28, 0x08}, {0x38, 0x08} },
	57	};
	58
	59	static void nomadik_ecc_control(struct mtd_info *mtd, int mode)
	60	{
	61	/* No need to enable hw ecc, it's on by default */
	62	}
	63
	64	static void nomadik_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
	65	{
	66	struct nand_chip *nand = mtd->priv;
	67	struct nomadik_nand_host *host = nand->priv;
	68
	69	if (cmd == NAND_CMD_NONE)
	70	return;
	71
	72	if (ctrl & NAND_CLE)
	73	writeb(cmd, host->cmd_va);
	74	else
	75	writeb(cmd, host->addr_va);
	76	}
	77
	78	static int nomadik_nand_probe(struct platform_device *pdev)
	79	{
	80	struct nomadik_nand_platform_data *pdata = pdev->dev.platform_data;
	81	struct nomadik_nand_host *host;
	82	struct mtd_info *mtd;
	83	struct nand_chip *nand;
	84	struct resource *res;
	85	int ret = 0;
	86
	87	/* Allocate memory for the device structure (and zero it) */
	88	host = kzalloc(sizeof(struct nomadik_nand_host), GFP_KERNEL);
	89	if (!host) {
	90	dev_err(&pdev->dev, "Failed to allocate device structure.\n");
	91	return -ENOMEM;
	92	}
	93
	94	/* Call the client's init function, if any */
	95	if (pdata->init)
	96	ret = pdata->init();
	97	if (ret < 0) {
	98	dev_err(&pdev->dev, "Init function failed\n");
99	goto err;
100	}
101
102	/* ioremap three regions */
103	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "nand_addr");
104	if (!res) {
105	ret = -EIO;
106	goto err_unmap;
107	}
4442241e	108	host->addr_va = ioremap(res->start, resource_size(res));
63234717 AR	109
	110	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "nand_data");
	111	if (!res) {
	112	ret = -EIO;
	113	goto err_unmap;
	114	}
4442241e	115	host->data_va = ioremap(res->start, resource_size(res));
63234717 AR	116
	117	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "nand_cmd");
	118	if (!res) {
	119	ret = -EIO;
	120	goto err_unmap;
	121	}
4442241e	122	host->cmd_va = ioremap(res->start, resource_size(res));
63234717 AR	123
	124	if (!host->addr_va \|\| !host->data_va \|\| !host->cmd_va) {
	125	ret = -ENOMEM;
	126	goto err_unmap;
	127	}
	128
	129	/* Link all private pointers */
	130	mtd = &host->mtd;
	131	nand = &host->nand;
	132	mtd->priv = nand;
	133	nand->priv = host;
	134
	135	host->mtd.owner = THIS_MODULE;
	136	nand->IO_ADDR_R = host->data_va;
	137	nand->IO_ADDR_W = host->data_va;
	138	nand->cmd_ctrl = nomadik_cmd_ctrl;
	139
	140	/*
	141	* This stanza declares ECC_HW but uses soft routines. It's because
	142	* HW claims to make the calculation but not the correction. However,
	143	* I haven't managed to get the desired data out of it until now.
	144	*/
	145	nand->ecc.mode = NAND_ECC_SOFT;
	146	nand->ecc.layout = &nomadik_ecc_layout;
	147	nand->ecc.hwctl = nomadik_ecc_control;
	148	nand->ecc.size = 512;
	149	nand->ecc.bytes = 3;
	150
	151	nand->options = pdata->options;
	152
	153	/*
25985edc	154	* Scan to find existence of the device
63234717 AR	155	*/
	156	if (nand_scan(&host->mtd, 1)) {
	157	ret = -ENXIO;
	158	goto err_unmap;
	159	}
	160
a04d23df	161	mtd_device_register(&host->mtd, pdata->parts, pdata->nparts);
63234717 AR	162
	163	platform_set_drvdata(pdev, host);
	164	return 0;
	165
	166	err_unmap:
	167	if (host->cmd_va)
	168	iounmap(host->cmd_va);
	169	if (host->data_va)
	170	iounmap(host->data_va);
	171	if (host->addr_va)
	172	iounmap(host->addr_va);
	173	err:
	174	kfree(host);
	175	return ret;
	176	}
	177
	178	/*
	179	* Clean up routine
	180	*/
	181	static int nomadik_nand_remove(struct platform_device *pdev)
	182	{
	183	struct nomadik_nand_host *host = platform_get_drvdata(pdev);
	184	struct nomadik_nand_platform_data *pdata = pdev->dev.platform_data;
	185
	186	if (pdata->exit)
	187	pdata->exit();
	188
	189	if (host) {
d80932b2	190	nand_release(&host->mtd);
63234717 AR	191	iounmap(host->cmd_va);
	192	iounmap(host->data_va);
	193	iounmap(host->addr_va);
	194	kfree(host);
	195	}
	196	return 0;
	197	}
	198
	199	static int nomadik_nand_suspend(struct device *dev)
	200	{
	201	struct nomadik_nand_host *host = dev_get_drvdata(dev);
	202	int ret = 0;
	203	if (host)
3fe4bae8	204	ret = mtd_suspend(&host->mtd);
63234717 AR	205	return ret;
	206	}
	207
	208	static int nomadik_nand_resume(struct device *dev)
	209	{
	210	struct nomadik_nand_host *host = dev_get_drvdata(dev);
	211	if (host)
ead995f8	212	mtd_resume(&host->mtd);
63234717 AR	213	return 0;
	214	}
	215
47145210	216	static const struct dev_pm_ops nomadik_nand_pm_ops = {
63234717 AR	217	.suspend = nomadik_nand_suspend,
	218	.resume = nomadik_nand_resume,
	219	};
	220
	221	static struct platform_driver nomadik_nand_driver = {
	222	.probe = nomadik_nand_probe,
	223	.remove = nomadik_nand_remove,
	224	.driver = {
	225	.owner = THIS_MODULE,
	226	.name = "nomadik_nand",
	227	.pm = &nomadik_nand_pm_ops,
	228	},
	229	};
	230
f99640de	231	module_platform_driver(nomadik_nand_driver);
63234717 AR	232
	233	MODULE_LICENSE("GPL");
	234	MODULE_AUTHOR("ST Microelectronics (sachin.verma@st.com)");
	235	MODULE_DESCRIPTION("NAND driver for Nomadik Platform");