2 * linux/drivers/mtd/onenand/omap2.c
4 * OneNAND driver for OMAP2 / OMAP3
6 * Copyright © 2005-2006 Nokia Corporation
8 * Author: Jarkko Lavinen <jarkko.lavinen@nokia.com> and Juha Yrjölä
9 * IRQ and DMA support written by Timo Teras
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License version 2 as published by
13 * the Free Software Foundation.
15 * This program is distributed in the hope that it will be useful, but WITHOUT
16 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
20 * You should have received a copy of the GNU General Public License along with
21 * this program; see the file COPYING. If not, write to the Free Software
22 * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
26 #include <linux/device.h>
27 #include <linux/module.h>
28 #include <linux/mtd/mtd.h>
29 #include <linux/mtd/onenand.h>
30 #include <linux/mtd/partitions.h>
31 #include <linux/platform_device.h>
32 #include <linux/interrupt.h>
33 #include <linux/delay.h>
34 #include <linux/dma-mapping.h>
35 #include <linux/dmaengine.h>
37 #include <linux/slab.h>
38 #include <linux/gpio.h>
40 #include <asm/mach/flash.h>
41 #include <linux/platform_data/mtd-onenand-omap2.h>
43 #define DRIVER_NAME "omap2-onenand"
45 #define ONENAND_BUFRAM_SIZE (1024 * 5)
47 struct omap2_onenand {
48 struct platform_device *pdev;
50 unsigned long phys_base;
51 unsigned int mem_size;
54 struct onenand_chip onenand;
55 struct completion irq_done;
56 struct completion dma_done;
57 struct dma_chan *dma_chan;
59 int (*setup)(void __iomem *base, int *freq_ptr);
62 static void omap2_onenand_dma_complete_func(void *completion)
67 static irqreturn_t omap2_onenand_interrupt(int irq, void *dev_id)
69 struct omap2_onenand *c = dev_id;
71 complete(&c->irq_done);
76 static inline unsigned short read_reg(struct omap2_onenand *c, int reg)
78 return readw(c->onenand.base + reg);
81 static inline void write_reg(struct omap2_onenand *c, unsigned short value,
84 writew(value, c->onenand.base + reg);
87 static void wait_err(char *msg, int state, unsigned int ctrl, unsigned int intr)
89 printk(KERN_ERR "onenand_wait: %s! state %d ctrl 0x%04x intr 0x%04x\n",
90 msg, state, ctrl, intr);
93 static void wait_warn(char *msg, int state, unsigned int ctrl,
96 printk(KERN_WARNING "onenand_wait: %s! state %d ctrl 0x%04x "
97 "intr 0x%04x\n", msg, state, ctrl, intr);
100 static int omap2_onenand_wait(struct mtd_info *mtd, int state)
102 struct omap2_onenand *c = container_of(mtd, struct omap2_onenand, mtd);
103 struct onenand_chip *this = mtd->priv;
104 unsigned int intr = 0;
105 unsigned int ctrl, ctrl_mask;
106 unsigned long timeout;
109 if (state == FL_RESETING || state == FL_PREPARING_ERASE ||
110 state == FL_VERIFYING_ERASE) {
112 unsigned int intr_flags = ONENAND_INT_MASTER;
116 intr_flags |= ONENAND_INT_RESET;
118 case FL_PREPARING_ERASE:
119 intr_flags |= ONENAND_INT_ERASE;
121 case FL_VERIFYING_ERASE:
128 intr = read_reg(c, ONENAND_REG_INTERRUPT);
129 if (intr & ONENAND_INT_MASTER)
132 ctrl = read_reg(c, ONENAND_REG_CTRL_STATUS);
133 if (ctrl & ONENAND_CTRL_ERROR) {
134 wait_err("controller error", state, ctrl, intr);
137 if ((intr & intr_flags) == intr_flags)
139 /* Continue in wait for interrupt branch */
142 if (state != FL_READING) {
145 /* Turn interrupts on */
146 syscfg = read_reg(c, ONENAND_REG_SYS_CFG1);
147 if (!(syscfg & ONENAND_SYS_CFG1_IOBE)) {
148 syscfg |= ONENAND_SYS_CFG1_IOBE;
149 write_reg(c, syscfg, ONENAND_REG_SYS_CFG1);
150 /* Add a delay to let GPIO settle */
151 syscfg = read_reg(c, ONENAND_REG_SYS_CFG1);
154 reinit_completion(&c->irq_done);
156 result = gpio_get_value(c->gpio_irq);
158 ctrl = read_reg(c, ONENAND_REG_CTRL_STATUS);
159 intr = read_reg(c, ONENAND_REG_INTERRUPT);
160 wait_err("gpio error", state, ctrl, intr);
168 if (!wait_for_completion_io_timeout(&c->irq_done,
169 msecs_to_jiffies(20))) {
170 /* Timeout after 20ms */
171 ctrl = read_reg(c, ONENAND_REG_CTRL_STATUS);
172 if (ctrl & ONENAND_CTRL_ONGO &&
175 * The operation seems to be still going
176 * so give it some more time.
182 ONENAND_REG_INTERRUPT);
183 wait_err("timeout", state, ctrl, intr);
186 intr = read_reg(c, ONENAND_REG_INTERRUPT);
187 if ((intr & ONENAND_INT_MASTER) == 0)
188 wait_warn("timeout", state, ctrl, intr);
194 /* Turn interrupts off */
195 syscfg = read_reg(c, ONENAND_REG_SYS_CFG1);
196 syscfg &= ~ONENAND_SYS_CFG1_IOBE;
197 write_reg(c, syscfg, ONENAND_REG_SYS_CFG1);
199 timeout = jiffies + msecs_to_jiffies(20);
201 if (time_before(jiffies, timeout)) {
202 intr = read_reg(c, ONENAND_REG_INTERRUPT);
203 if (intr & ONENAND_INT_MASTER)
206 /* Timeout after 20ms */
207 ctrl = read_reg(c, ONENAND_REG_CTRL_STATUS);
208 if (ctrl & ONENAND_CTRL_ONGO) {
210 * The operation seems to be still going
211 * so give it some more time.
216 msecs_to_jiffies(20);
225 intr = read_reg(c, ONENAND_REG_INTERRUPT);
226 ctrl = read_reg(c, ONENAND_REG_CTRL_STATUS);
228 if (intr & ONENAND_INT_READ) {
229 int ecc = read_reg(c, ONENAND_REG_ECC_STATUS);
232 unsigned int addr1, addr8;
234 addr1 = read_reg(c, ONENAND_REG_START_ADDRESS1);
235 addr8 = read_reg(c, ONENAND_REG_START_ADDRESS8);
236 if (ecc & ONENAND_ECC_2BIT_ALL) {
237 printk(KERN_ERR "onenand_wait: ECC error = "
238 "0x%04x, addr1 %#x, addr8 %#x\n",
240 mtd->ecc_stats.failed++;
242 } else if (ecc & ONENAND_ECC_1BIT_ALL) {
243 printk(KERN_NOTICE "onenand_wait: correctable "
244 "ECC error = 0x%04x, addr1 %#x, "
245 "addr8 %#x\n", ecc, addr1, addr8);
246 mtd->ecc_stats.corrected++;
249 } else if (state == FL_READING) {
250 wait_err("timeout", state, ctrl, intr);
254 if (ctrl & ONENAND_CTRL_ERROR) {
255 wait_err("controller error", state, ctrl, intr);
256 if (ctrl & ONENAND_CTRL_LOCK)
257 printk(KERN_ERR "onenand_wait: "
258 "Device is write protected!!!\n");
264 ctrl_mask &= ~0x8000;
266 if (ctrl & ctrl_mask)
267 wait_warn("unexpected controller status", state, ctrl, intr);
272 static inline int omap2_onenand_bufferram_offset(struct mtd_info *mtd, int area)
274 struct onenand_chip *this = mtd->priv;
276 if (ONENAND_CURRENT_BUFFERRAM(this)) {
277 if (area == ONENAND_DATARAM)
278 return this->writesize;
279 if (area == ONENAND_SPARERAM)
286 static inline int omap2_onenand_dma_transfer(struct omap2_onenand *c,
287 dma_addr_t src, dma_addr_t dst,
290 struct dma_async_tx_descriptor *tx;
293 tx = dmaengine_prep_dma_memcpy(c->dma_chan, dst, src, count, 0);
295 dev_err(&c->pdev->dev, "Failed to prepare DMA memcpy\n");
299 reinit_completion(&c->dma_done);
301 tx->callback = omap2_onenand_dma_complete_func;
302 tx->callback_param = &c->dma_done;
304 cookie = tx->tx_submit(tx);
305 if (dma_submit_error(cookie)) {
306 dev_err(&c->pdev->dev, "Failed to do DMA tx_submit\n");
310 dma_async_issue_pending(c->dma_chan);
312 if (!wait_for_completion_io_timeout(&c->dma_done,
313 msecs_to_jiffies(20))) {
314 dmaengine_terminate_sync(c->dma_chan);
321 static int omap2_onenand_read_bufferram(struct mtd_info *mtd, int area,
322 unsigned char *buffer, int offset,
325 struct omap2_onenand *c = container_of(mtd, struct omap2_onenand, mtd);
326 struct onenand_chip *this = mtd->priv;
327 dma_addr_t dma_src, dma_dst;
329 void *buf = (void *)buffer;
333 bram_offset = omap2_onenand_bufferram_offset(mtd, area) + area + offset;
334 if (bram_offset & 3 || (size_t)buf & 3 || count < 384)
337 /* panic_write() may be in an interrupt context */
338 if (in_interrupt() || oops_in_progress)
341 if (buf >= high_memory) {
344 if (((size_t)buf & PAGE_MASK) !=
345 ((size_t)(buf + count - 1) & PAGE_MASK))
347 p1 = vmalloc_to_page(buf);
350 buf = page_address(p1) + ((size_t)buf & ~PAGE_MASK);
356 memcpy(buf + count, this->base + bram_offset + count, xtra);
359 dma_src = c->phys_base + bram_offset;
360 dma_dst = dma_map_single(&c->pdev->dev, buf, count, DMA_FROM_DEVICE);
361 if (dma_mapping_error(&c->pdev->dev, dma_dst)) {
362 dev_err(&c->pdev->dev,
363 "Couldn't DMA map a %d byte buffer\n",
368 ret = omap2_onenand_dma_transfer(c, dma_src, dma_dst, count);
369 dma_unmap_single(&c->pdev->dev, dma_dst, count, DMA_FROM_DEVICE);
372 dev_err(&c->pdev->dev, "timeout waiting for DMA\n");
379 memcpy(buf, this->base + bram_offset, count);
383 static int omap2_onenand_write_bufferram(struct mtd_info *mtd, int area,
384 const unsigned char *buffer,
385 int offset, size_t count)
387 struct omap2_onenand *c = container_of(mtd, struct omap2_onenand, mtd);
388 struct onenand_chip *this = mtd->priv;
389 dma_addr_t dma_src, dma_dst;
391 void *buf = (void *)buffer;
394 bram_offset = omap2_onenand_bufferram_offset(mtd, area) + area + offset;
395 if (bram_offset & 3 || (size_t)buf & 3 || count < 384)
398 /* panic_write() may be in an interrupt context */
399 if (in_interrupt() || oops_in_progress)
402 if (buf >= high_memory) {
405 if (((size_t)buf & PAGE_MASK) !=
406 ((size_t)(buf + count - 1) & PAGE_MASK))
408 p1 = vmalloc_to_page(buf);
411 buf = page_address(p1) + ((size_t)buf & ~PAGE_MASK);
414 dma_src = dma_map_single(&c->pdev->dev, buf, count, DMA_TO_DEVICE);
415 dma_dst = c->phys_base + bram_offset;
416 if (dma_mapping_error(&c->pdev->dev, dma_src)) {
417 dev_err(&c->pdev->dev,
418 "Couldn't DMA map a %d byte buffer\n",
423 ret = omap2_onenand_dma_transfer(c, dma_src, dma_dst, count);
424 dma_unmap_single(&c->pdev->dev, dma_src, count, DMA_TO_DEVICE);
427 dev_err(&c->pdev->dev, "timeout waiting for DMA\n");
434 memcpy(this->base + bram_offset, buf, count);
438 static struct platform_driver omap2_onenand_driver;
440 static void omap2_onenand_shutdown(struct platform_device *pdev)
442 struct omap2_onenand *c = dev_get_drvdata(&pdev->dev);
444 /* With certain content in the buffer RAM, the OMAP boot ROM code
445 * can recognize the flash chip incorrectly. Zero it out before
448 memset((__force void *)c->onenand.base, 0, ONENAND_BUFRAM_SIZE);
451 static int omap2_onenand_probe(struct platform_device *pdev)
453 struct omap_onenand_platform_data *pdata;
454 struct omap2_onenand *c;
455 struct onenand_chip *this;
457 struct resource *res;
459 pdata = dev_get_platdata(&pdev->dev);
461 dev_err(&pdev->dev, "platform data missing\n");
465 c = kzalloc(sizeof(struct omap2_onenand), GFP_KERNEL);
469 init_completion(&c->irq_done);
470 init_completion(&c->dma_done);
471 c->gpmc_cs = pdata->cs;
472 c->gpio_irq = pdata->gpio_irq;
473 if (pdata->dma_channel < 0) {
474 /* if -1, don't use DMA */
478 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
481 dev_err(&pdev->dev, "error getting memory resource\n");
485 c->phys_base = res->start;
486 c->mem_size = resource_size(res);
488 if (request_mem_region(c->phys_base, c->mem_size,
489 pdev->dev.driver->name) == NULL) {
490 dev_err(&pdev->dev, "Cannot reserve memory region at 0x%08lx, size: 0x%x\n",
491 c->phys_base, c->mem_size);
495 c->onenand.base = ioremap(c->phys_base, c->mem_size);
496 if (c->onenand.base == NULL) {
498 goto err_release_mem_region;
501 if (pdata->onenand_setup != NULL) {
502 r = pdata->onenand_setup(c->onenand.base, &c->freq);
504 dev_err(&pdev->dev, "Onenand platform setup failed: "
508 c->setup = pdata->onenand_setup;
512 if ((r = gpio_request(c->gpio_irq, "OneNAND irq")) < 0) {
513 dev_err(&pdev->dev, "Failed to request GPIO%d for "
514 "OneNAND\n", c->gpio_irq);
517 gpio_direction_input(c->gpio_irq);
519 if ((r = request_irq(gpio_to_irq(c->gpio_irq),
520 omap2_onenand_interrupt, IRQF_TRIGGER_RISING,
521 pdev->dev.driver->name, c)) < 0)
522 goto err_release_gpio;
525 if (pdata->dma_channel >= 0) {
529 dma_cap_set(DMA_MEMCPY, mask);
531 c->dma_chan = dma_request_channel(mask, NULL, NULL);
534 "failed to allocate DMA for OneNAND, "
535 "using PIO instead\n");
538 dev_info(&pdev->dev, "initializing on CS%d, phys base 0x%08lx, virtual "
539 "base %p, freq %d MHz\n", c->gpmc_cs, c->phys_base,
540 c->onenand.base, c->freq);
543 c->mtd.priv = &c->onenand;
545 c->mtd.dev.parent = &pdev->dev;
546 mtd_set_of_node(&c->mtd, pdata->of_node);
550 this->wait = omap2_onenand_wait;
551 this->read_bufferram = omap2_onenand_read_bufferram;
552 this->write_bufferram = omap2_onenand_write_bufferram;
555 if ((r = onenand_scan(&c->mtd, 1)) < 0)
556 goto err_release_dma;
558 r = mtd_device_register(&c->mtd, NULL, 0);
560 goto err_release_onenand;
562 platform_set_drvdata(pdev, c);
567 onenand_release(&c->mtd);
570 dma_release_channel(c->dma_chan);
572 free_irq(gpio_to_irq(c->gpio_irq), c);
575 gpio_free(c->gpio_irq);
577 iounmap(c->onenand.base);
578 err_release_mem_region:
579 release_mem_region(c->phys_base, c->mem_size);
586 static int omap2_onenand_remove(struct platform_device *pdev)
588 struct omap2_onenand *c = dev_get_drvdata(&pdev->dev);
590 onenand_release(&c->mtd);
592 dma_release_channel(c->dma_chan);
593 omap2_onenand_shutdown(pdev);
595 free_irq(gpio_to_irq(c->gpio_irq), c);
596 gpio_free(c->gpio_irq);
598 iounmap(c->onenand.base);
599 release_mem_region(c->phys_base, c->mem_size);
605 static struct platform_driver omap2_onenand_driver = {
606 .probe = omap2_onenand_probe,
607 .remove = omap2_onenand_remove,
608 .shutdown = omap2_onenand_shutdown,
614 module_platform_driver(omap2_onenand_driver);
616 MODULE_ALIAS("platform:" DRIVER_NAME);
617 MODULE_LICENSE("GPL");
618 MODULE_AUTHOR("Jarkko Lavinen <jarkko.lavinen@nokia.com>");
619 MODULE_DESCRIPTION("Glue layer for OneNAND flash on OMAP2 / OMAP3");