1 /*
2 * drivers/mtd/nand/orion_nand.c
3 *
4 * NAND support for Marvell Orion SoC platforms
5 *
6 * Tzachi Perelstein <tzachi@marvell.com>
7 *
8 * This file is licensed under the terms of the GNU General Public
9 * License version 2. This program is licensed "as is" without any
10 * warranty of any kind, whether express or implied.
11 */
12
13 #include <linux/slab.h>
14 #include <linux/module.h>
15 #include <linux/platform_device.h>
16 #include <linux/mtd/mtd.h>
17 #include <linux/mtd/nand.h>
18 #include <linux/mtd/partitions.h>
19 #include <asm/io.h>
20 #include <asm/sizes.h>
21 #include <mach/hardware.h>
22 #include <plat/orion_nand.h>
23
orion_nand_cmd_ctrl(struct mtd_info * mtd,int cmd,unsigned int ctrl)24 static void orion_nand_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
25 {
26 struct nand_chip *nc = mtd->priv;
27 struct orion_nand_data *board = nc->priv;
28 u32 offs;
29
30 if (cmd == NAND_CMD_NONE)
31 return;
32
33 if (ctrl & NAND_CLE)
34 offs = (1 << board->cle);
35 else if (ctrl & NAND_ALE)
36 offs = (1 << board->ale);
37 else
38 return;
39
40 if (nc->options & NAND_BUSWIDTH_16)
41 offs <<= 1;
42
43 writeb(cmd, nc->IO_ADDR_W + offs);
44 }
45
orion_nand_read_buf(struct mtd_info * mtd,uint8_t * buf,int len)46 static void orion_nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
47 {
48 struct nand_chip *chip = mtd->priv;
49 void __iomem *io_base = chip->IO_ADDR_R;
50 uint64_t *buf64;
51 int i = 0;
52
53 while (len && (unsigned long)buf & 7) {
54 *buf++ = readb(io_base);
55 len--;
56 }
57 buf64 = (uint64_t *)buf;
58 while (i < len/8) {
59 /*
60 * Since GCC has no proper constraint (PR 43518)
61 * force x variable to r2/r3 registers as ldrd instruction
62 * requires first register to be even.
63 */
64 register uint64_t x asm ("r2");
65
66 asm volatile ("ldrd\t%0, [%1]" : "=&r" (x) : "r" (io_base));
67 buf64[i++] = x;
68 }
69 i *= 8;
70 while (i < len)
71 buf[i++] = readb(io_base);
72 }
73
orion_nand_probe(struct platform_device * pdev)74 static int __init orion_nand_probe(struct platform_device *pdev)
75 {
76 struct mtd_info *mtd;
77 struct nand_chip *nc;
78 struct orion_nand_data *board;
79 struct resource *res;
80 void __iomem *io_base;
81 int ret = 0;
82
83 nc = kzalloc(sizeof(struct nand_chip) + sizeof(struct mtd_info), GFP_KERNEL);
84 if (!nc) {
85 printk(KERN_ERR "orion_nand: failed to allocate device structure.\n");
86 ret = -ENOMEM;
87 goto no_res;
88 }
89 mtd = (struct mtd_info *)(nc + 1);
90
91 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
92 if (!res) {
93 ret = -ENODEV;
94 goto no_res;
95 }
96
97 io_base = ioremap(res->start, resource_size(res));
98 if (!io_base) {
99 printk(KERN_ERR "orion_nand: ioremap failed\n");
100 ret = -EIO;
101 goto no_res;
102 }
103
104 board = pdev->dev.platform_data;
105
106 mtd->priv = nc;
107 mtd->owner = THIS_MODULE;
108
109 nc->priv = board;
110 nc->IO_ADDR_R = nc->IO_ADDR_W = io_base;
111 nc->cmd_ctrl = orion_nand_cmd_ctrl;
112 nc->read_buf = orion_nand_read_buf;
113 nc->ecc.mode = NAND_ECC_SOFT;
114
115 if (board->chip_delay)
116 nc->chip_delay = board->chip_delay;
117
118 if (board->width == 16)
119 nc->options |= NAND_BUSWIDTH_16;
120
121 if (board->dev_ready)
122 nc->dev_ready = board->dev_ready;
123
124 platform_set_drvdata(pdev, mtd);
125
126 if (nand_scan(mtd, 1)) {
127 ret = -ENXIO;
128 goto no_dev;
129 }
130
131 mtd->name = "orion_nand";
132 ret = mtd_device_parse_register(mtd, NULL, 0,
133 board->parts, board->nr_parts);
134 if (ret) {
135 nand_release(mtd);
136 goto no_dev;
137 }
138
139 return 0;
140
141 no_dev:
142 platform_set_drvdata(pdev, NULL);
143 iounmap(io_base);
144 no_res:
145 kfree(nc);
146
147 return ret;
148 }
149
orion_nand_remove(struct platform_device * pdev)150 static int __devexit orion_nand_remove(struct platform_device *pdev)
151 {
152 struct mtd_info *mtd = platform_get_drvdata(pdev);
153 struct nand_chip *nc = mtd->priv;
154
155 nand_release(mtd);
156
157 iounmap(nc->IO_ADDR_W);
158
159 kfree(nc);
160
161 return 0;
162 }
163
164 static struct platform_driver orion_nand_driver = {
165 .remove = __devexit_p(orion_nand_remove),
166 .driver = {
167 .name = "orion_nand",
168 .owner = THIS_MODULE,
169 },
170 };
171
orion_nand_init(void)172 static int __init orion_nand_init(void)
173 {
174 return platform_driver_probe(&orion_nand_driver, orion_nand_probe);
175 }
176
orion_nand_exit(void)177 static void __exit orion_nand_exit(void)
178 {
179 platform_driver_unregister(&orion_nand_driver);
180 }
181
182 module_init(orion_nand_init);
183 module_exit(orion_nand_exit);
184
185 MODULE_LICENSE("GPL");
186 MODULE_AUTHOR("Tzachi Perelstein");
187 MODULE_DESCRIPTION("NAND glue for Orion platforms");
188 MODULE_ALIAS("platform:orion_nand");
189