[mirror_ubuntu-bionic-kernel.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 <mach/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, res->end - res->start + 1);

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

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

	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 existance of the device
	 */
	if (nand_scan(&host->mtd, 1)) {
		ret = -ENXIO;
		goto err_unmap;
	}

#ifdef CONFIG_MTD_PARTITIONS
	add_mtd_partitions(&host->mtd, pdata->parts, pdata->nparts);
#else
	pr_info("Registering %s as whole device\n", mtd->name);
	add_mtd_device(mtd);
#endif

	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) {
		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 = host->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)
		host->mtd.resume(&host->mtd);
	return 0;
}

static 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,
	},
};

static int __init nand_nomadik_init(void)
{
	pr_info("Nomadik NAND driver\n");
	return platform_driver_register(&nomadik_nand_driver);
}

static void __exit nand_nomadik_exit(void)
{
	platform_driver_unregister(&nomadik_nand_driver);
}

module_init(nand_nomadik_init);
module_exit(nand_nomadik_exit);

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>
	33	#include <mach/nand.h>
	34	#include <mach/fsmc.h>
	35
	36	#include <mtd/mtd-abi.h>
	37
	38	struct nomadik_nand_host {
	39	struct mtd_info mtd;
	40	struct nand_chip nand;
	41	void __iomem *data_va;
	42	void __iomem *cmd_va;
	43	void __iomem *addr_va;
	44	struct nand_bbt_descr *bbt_desc;
	45	};
	46
	47	static struct nand_ecclayout nomadik_ecc_layout = {
	48	.eccbytes = 3 * 4,
	49	.eccpos = { /* each subpage has 16 bytes: pos 2,3,4 hosts ECC */
	50	0x02, 0x03, 0x04,
	51	0x12, 0x13, 0x14,
	52	0x22, 0x23, 0x24,
	53	0x32, 0x33, 0x34},
	54	/* let's keep bytes 5,6,7 for us, just in case we change ECC algo */
	55	.oobfree = { {0x08, 0x08}, {0x18, 0x08}, {0x28, 0x08}, {0x38, 0x08} },
	56	};
	57
	58	static void nomadik_ecc_control(struct mtd_info *mtd, int mode)
	59	{
	60	/* No need to enable hw ecc, it's on by default */
	61	}
	62
	63	static void nomadik_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
	64	{
65	struct nand_chip *nand = mtd->priv;
66	struct nomadik_nand_host *host = nand->priv;
67
68	if (cmd == NAND_CMD_NONE)
69	return;
70
71	if (ctrl & NAND_CLE)
72	writeb(cmd, host->cmd_va);
73	else
74	writeb(cmd, host->addr_va);
75	}
76
77	static int nomadik_nand_probe(struct platform_device *pdev)
78	{
79	struct nomadik_nand_platform_data *pdata = pdev->dev.platform_data;
80	struct nomadik_nand_host *host;
81	struct mtd_info *mtd;
82	struct nand_chip *nand;
83	struct resource *res;
84	int ret = 0;
85
86	/* Allocate memory for the device structure (and zero it) */
87	host = kzalloc(sizeof(struct nomadik_nand_host), GFP_KERNEL);
88	if (!host) {
89	dev_err(&pdev->dev, "Failed to allocate device structure.\n");
90	return -ENOMEM;
91	}
92
93	/* Call the client's init function, if any */
94	if (pdata->init)
95	ret = pdata->init();
96	if (ret < 0) {
97	dev_err(&pdev->dev, "Init function failed\n");
98	goto err;
99	}
100
101	/* ioremap three regions */
102	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "nand_addr");
103	if (!res) {
104	ret = -EIO;
105	goto err_unmap;
106	}
107	host->addr_va = ioremap(res->start, res->end - res->start + 1);
108
109	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "nand_data");
110	if (!res) {
111	ret = -EIO;
112	goto err_unmap;
113	}
114	host->data_va = ioremap(res->start, res->end - res->start + 1);
115
116	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "nand_cmd");
117	if (!res) {
118	ret = -EIO;
119	goto err_unmap;
120	}
121	host->cmd_va = ioremap(res->start, res->end - res->start + 1);
122
123	if (!host->addr_va \|\| !host->data_va \|\| !host->cmd_va) {
124	ret = -ENOMEM;
125	goto err_unmap;
126	}
127
128	/* Link all private pointers */
129	mtd = &host->mtd;
130	nand = &host->nand;
131	mtd->priv = nand;
132	nand->priv = host;
133
134	host->mtd.owner = THIS_MODULE;
135	nand->IO_ADDR_R = host->data_va;
136	nand->IO_ADDR_W = host->data_va;
137	nand->cmd_ctrl = nomadik_cmd_ctrl;
138
139	/*
140	* This stanza declares ECC_HW but uses soft routines. It's because
141	* HW claims to make the calculation but not the correction. However,
142	* I haven't managed to get the desired data out of it until now.
143	*/
144	nand->ecc.mode = NAND_ECC_SOFT;
145	nand->ecc.layout = &nomadik_ecc_layout;
146	nand->ecc.hwctl = nomadik_ecc_control;
147	nand->ecc.size = 512;
148	nand->ecc.bytes = 3;
149
150	nand->options = pdata->options;
151
152	/*
153	* Scan to find existance of the device
154	*/
155	if (nand_scan(&host->mtd, 1)) {
156	ret = -ENXIO;
157	goto err_unmap;
158	}
159
160	#ifdef CONFIG_MTD_PARTITIONS
161	add_mtd_partitions(&host->mtd, pdata->parts, pdata->nparts);
162	#else
163	pr_info("Registering %s as whole device\n", mtd->name);
164	add_mtd_device(mtd);
165	#endif
166
167	platform_set_drvdata(pdev, host);
168	return 0;
169
170	err_unmap:
171	if (host->cmd_va)
172	iounmap(host->cmd_va);
173	if (host->data_va)
174	iounmap(host->data_va);
175	if (host->addr_va)
176	iounmap(host->addr_va);
177	err:
178	kfree(host);
179	return ret;
180	}
181
182	/*
183	* Clean up routine
184	*/
185	static int nomadik_nand_remove(struct platform_device *pdev)
186	{
187	struct nomadik_nand_host *host = platform_get_drvdata(pdev);
188	struct nomadik_nand_platform_data *pdata = pdev->dev.platform_data;
189
190	if (pdata->exit)
191	pdata->exit();
192
193	if (host) {
194	iounmap(host->cmd_va);
195	iounmap(host->data_va);
196	iounmap(host->addr_va);
197	kfree(host);
198	}
199	return 0;
200	}
201
202	static int nomadik_nand_suspend(struct device *dev)
203	{
204	struct nomadik_nand_host *host = dev_get_drvdata(dev);
205	int ret = 0;
206	if (host)
207	ret = host->mtd.suspend(&host->mtd);
208	return ret;
209	}
210
211	static int nomadik_nand_resume(struct device *dev)
212	{
213	struct nomadik_nand_host *host = dev_get_drvdata(dev);
214	if (host)
215	host->mtd.resume(&host->mtd);
216	return 0;
217	}
218
219	static struct dev_pm_ops nomadik_nand_pm_ops = {
220	.suspend = nomadik_nand_suspend,
221	.resume = nomadik_nand_resume,
222	};
223
224	static struct platform_driver nomadik_nand_driver = {
225	.probe = nomadik_nand_probe,
226	.remove = nomadik_nand_remove,
227	.driver = {
228	.owner = THIS_MODULE,
229	.name = "nomadik_nand",
230	.pm = &nomadik_nand_pm_ops,
231	},
232	};
233
234	static int __init nand_nomadik_init(void)
235	{
236	pr_info("Nomadik NAND driver\n");
237	return platform_driver_register(&nomadik_nand_driver);
238	}
239
240	static void __exit nand_nomadik_exit(void)
241	{
242	platform_driver_unregister(&nomadik_nand_driver);
243	}
244
245	module_init(nand_nomadik_init);
246	module_exit(nand_nomadik_exit);
247
248	MODULE_LICENSE("GPL");
249	MODULE_AUTHOR("ST Microelectronics (sachin.verma@st.com)");
250	MODULE_DESCRIPTION("NAND driver for Nomadik Platform");