Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 1 | /* |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 2 | * Copyright (C) 2003 Rick Bronson |
| 3 | * |
| 4 | * Derived from drivers/mtd/nand/autcpu12.c |
| 5 | * Copyright (c) 2001 Thomas Gleixner (gleixner@autronix.de) |
| 6 | * |
| 7 | * Derived from drivers/mtd/spia.c |
| 8 | * Copyright (C) 2000 Steven J. Hill (sjhill@cotw.com) |
| 9 | * |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 10 | * |
| 11 | * Add Hardware ECC support for AT91SAM9260 / AT91SAM9263 |
| 12 | * Richard Genoud (richard.genoud@gmail.com), Adeneo Copyright (C) 2007 |
| 13 | * |
| 14 | * Derived from Das U-Boot source code |
| 15 | * (u-boot-1.1.5/board/atmel/at91sam9263ek/nand.c) |
| 16 | * (C) Copyright 2006 ATMEL Rousset, Lacressonniere Nicolas |
| 17 | * |
| 18 | * |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 19 | * This program is free software; you can redistribute it and/or modify |
| 20 | * it under the terms of the GNU General Public License version 2 as |
| 21 | * published by the Free Software Foundation. |
| 22 | * |
| 23 | */ |
| 24 | |
| 25 | #include <linux/slab.h> |
| 26 | #include <linux/module.h> |
Simon Polette | f4fa697 | 2009-05-27 18:19:39 +0300 | [diff] [blame] | 27 | #include <linux/moduleparam.h> |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 28 | #include <linux/platform_device.h> |
| 29 | #include <linux/mtd/mtd.h> |
| 30 | #include <linux/mtd/nand.h> |
| 31 | #include <linux/mtd/partitions.h> |
| 32 | |
David Woodhouse | 90574d0 | 2008-06-07 08:49:00 +0100 | [diff] [blame] | 33 | #include <linux/gpio.h> |
| 34 | #include <linux/io.h> |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 35 | |
Russell King | a09e64f | 2008-08-05 16:14:15 +0100 | [diff] [blame] | 36 | #include <mach/board.h> |
| 37 | #include <mach/cpu.h> |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 38 | |
Håvard Skinnemoen | d4f4c0a | 2008-06-06 18:04:52 +0200 | [diff] [blame] | 39 | #ifdef CONFIG_MTD_NAND_ATMEL_ECC_HW |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 40 | #define hard_ecc 1 |
| 41 | #else |
| 42 | #define hard_ecc 0 |
| 43 | #endif |
| 44 | |
Håvard Skinnemoen | d4f4c0a | 2008-06-06 18:04:52 +0200 | [diff] [blame] | 45 | #ifdef CONFIG_MTD_NAND_ATMEL_ECC_NONE |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 46 | #define no_ecc 1 |
| 47 | #else |
| 48 | #define no_ecc 0 |
| 49 | #endif |
| 50 | |
Hong Xu | cbc6c5e | 2011-01-18 14:36:05 +0800 | [diff] [blame] | 51 | static int use_dma = 1; |
| 52 | module_param(use_dma, int, 0); |
| 53 | |
Simon Polette | f4fa697 | 2009-05-27 18:19:39 +0300 | [diff] [blame] | 54 | static int on_flash_bbt = 0; |
| 55 | module_param(on_flash_bbt, int, 0); |
| 56 | |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 57 | /* Register access macros */ |
| 58 | #define ecc_readl(add, reg) \ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 59 | __raw_readl(add + ATMEL_ECC_##reg) |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 60 | #define ecc_writel(add, reg, value) \ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 61 | __raw_writel((value), add + ATMEL_ECC_##reg) |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 62 | |
Håvard Skinnemoen | d4f4c0a | 2008-06-06 18:04:52 +0200 | [diff] [blame] | 63 | #include "atmel_nand_ecc.h" /* Hardware ECC registers */ |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 64 | |
| 65 | /* oob layout for large page size |
| 66 | * bad block info is on bytes 0 and 1 |
| 67 | * the bytes have to be consecutives to avoid |
| 68 | * several NAND_CMD_RNDOUT during read |
| 69 | */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 70 | static struct nand_ecclayout atmel_oobinfo_large = { |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 71 | .eccbytes = 4, |
| 72 | .eccpos = {60, 61, 62, 63}, |
| 73 | .oobfree = { |
| 74 | {2, 58} |
| 75 | }, |
| 76 | }; |
| 77 | |
| 78 | /* oob layout for small page size |
| 79 | * bad block info is on bytes 4 and 5 |
| 80 | * the bytes have to be consecutives to avoid |
| 81 | * several NAND_CMD_RNDOUT during read |
| 82 | */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 83 | static struct nand_ecclayout atmel_oobinfo_small = { |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 84 | .eccbytes = 4, |
| 85 | .eccpos = {0, 1, 2, 3}, |
| 86 | .oobfree = { |
| 87 | {6, 10} |
| 88 | }, |
| 89 | }; |
| 90 | |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 91 | struct atmel_nand_host { |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 92 | struct nand_chip nand_chip; |
| 93 | struct mtd_info mtd; |
| 94 | void __iomem *io_base; |
Hong Xu | cbc6c5e | 2011-01-18 14:36:05 +0800 | [diff] [blame] | 95 | dma_addr_t io_phys; |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 96 | struct atmel_nand_data *board; |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 97 | struct device *dev; |
| 98 | void __iomem *ecc; |
Hong Xu | cbc6c5e | 2011-01-18 14:36:05 +0800 | [diff] [blame] | 99 | |
| 100 | struct completion comp; |
| 101 | struct dma_chan *dma_chan; |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 102 | }; |
| 103 | |
Hong Xu | cbc6c5e | 2011-01-18 14:36:05 +0800 | [diff] [blame] | 104 | static int cpu_has_dma(void) |
| 105 | { |
| 106 | return cpu_is_at91sam9rl() || cpu_is_at91sam9g45(); |
| 107 | } |
| 108 | |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 109 | /* |
Atsushi Nemoto | 8136508 | 2008-04-27 01:51:12 +0900 | [diff] [blame] | 110 | * Enable NAND. |
| 111 | */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 112 | static void atmel_nand_enable(struct atmel_nand_host *host) |
Atsushi Nemoto | 8136508 | 2008-04-27 01:51:12 +0900 | [diff] [blame] | 113 | { |
| 114 | if (host->board->enable_pin) |
Håvard Skinnemoen | 62fd71f | 2008-06-06 18:04:51 +0200 | [diff] [blame] | 115 | gpio_set_value(host->board->enable_pin, 0); |
Atsushi Nemoto | 8136508 | 2008-04-27 01:51:12 +0900 | [diff] [blame] | 116 | } |
| 117 | |
| 118 | /* |
| 119 | * Disable NAND. |
| 120 | */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 121 | static void atmel_nand_disable(struct atmel_nand_host *host) |
Atsushi Nemoto | 8136508 | 2008-04-27 01:51:12 +0900 | [diff] [blame] | 122 | { |
| 123 | if (host->board->enable_pin) |
Håvard Skinnemoen | 62fd71f | 2008-06-06 18:04:51 +0200 | [diff] [blame] | 124 | gpio_set_value(host->board->enable_pin, 1); |
Atsushi Nemoto | 8136508 | 2008-04-27 01:51:12 +0900 | [diff] [blame] | 125 | } |
| 126 | |
| 127 | /* |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 128 | * Hardware specific access to control-lines |
| 129 | */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 130 | static void atmel_nand_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl) |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 131 | { |
| 132 | struct nand_chip *nand_chip = mtd->priv; |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 133 | struct atmel_nand_host *host = nand_chip->priv; |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 134 | |
Atsushi Nemoto | 8136508 | 2008-04-27 01:51:12 +0900 | [diff] [blame] | 135 | if (ctrl & NAND_CTRL_CHANGE) { |
Atsushi Nemoto | 2314488 | 2008-04-24 23:51:29 +0900 | [diff] [blame] | 136 | if (ctrl & NAND_NCE) |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 137 | atmel_nand_enable(host); |
Atsushi Nemoto | 2314488 | 2008-04-24 23:51:29 +0900 | [diff] [blame] | 138 | else |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 139 | atmel_nand_disable(host); |
Atsushi Nemoto | 2314488 | 2008-04-24 23:51:29 +0900 | [diff] [blame] | 140 | } |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 141 | if (cmd == NAND_CMD_NONE) |
| 142 | return; |
| 143 | |
| 144 | if (ctrl & NAND_CLE) |
| 145 | writeb(cmd, host->io_base + (1 << host->board->cle)); |
| 146 | else |
| 147 | writeb(cmd, host->io_base + (1 << host->board->ale)); |
| 148 | } |
| 149 | |
| 150 | /* |
| 151 | * Read the Device Ready pin. |
| 152 | */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 153 | static int atmel_nand_device_ready(struct mtd_info *mtd) |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 154 | { |
| 155 | struct nand_chip *nand_chip = mtd->priv; |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 156 | struct atmel_nand_host *host = nand_chip->priv; |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 157 | |
Gregory CLEMENT | 744f659 | 2009-02-16 21:21:47 +0100 | [diff] [blame] | 158 | return gpio_get_value(host->board->rdy_pin) ^ |
| 159 | !!host->board->rdy_pin_active_low; |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 160 | } |
| 161 | |
| 162 | /* |
David Brownell | 23a346c | 2008-07-03 23:40:16 -0700 | [diff] [blame] | 163 | * Minimal-overhead PIO for data access. |
| 164 | */ |
Hong Xu | cbc6c5e | 2011-01-18 14:36:05 +0800 | [diff] [blame] | 165 | static void atmel_read_buf8(struct mtd_info *mtd, u8 *buf, int len) |
David Brownell | 23a346c | 2008-07-03 23:40:16 -0700 | [diff] [blame] | 166 | { |
| 167 | struct nand_chip *nand_chip = mtd->priv; |
| 168 | |
| 169 | __raw_readsb(nand_chip->IO_ADDR_R, buf, len); |
| 170 | } |
| 171 | |
| 172 | static void atmel_read_buf16(struct mtd_info *mtd, u8 *buf, int len) |
| 173 | { |
| 174 | struct nand_chip *nand_chip = mtd->priv; |
| 175 | |
| 176 | __raw_readsw(nand_chip->IO_ADDR_R, buf, len / 2); |
| 177 | } |
| 178 | |
Hong Xu | cbc6c5e | 2011-01-18 14:36:05 +0800 | [diff] [blame] | 179 | static void atmel_write_buf8(struct mtd_info *mtd, const u8 *buf, int len) |
David Brownell | 23a346c | 2008-07-03 23:40:16 -0700 | [diff] [blame] | 180 | { |
| 181 | struct nand_chip *nand_chip = mtd->priv; |
| 182 | |
| 183 | __raw_writesb(nand_chip->IO_ADDR_W, buf, len); |
| 184 | } |
| 185 | |
| 186 | static void atmel_write_buf16(struct mtd_info *mtd, const u8 *buf, int len) |
| 187 | { |
| 188 | struct nand_chip *nand_chip = mtd->priv; |
| 189 | |
| 190 | __raw_writesw(nand_chip->IO_ADDR_W, buf, len / 2); |
| 191 | } |
| 192 | |
Hong Xu | cbc6c5e | 2011-01-18 14:36:05 +0800 | [diff] [blame] | 193 | static void dma_complete_func(void *completion) |
| 194 | { |
| 195 | complete(completion); |
| 196 | } |
| 197 | |
| 198 | static int atmel_nand_dma_op(struct mtd_info *mtd, void *buf, int len, |
| 199 | int is_read) |
| 200 | { |
| 201 | struct dma_device *dma_dev; |
| 202 | enum dma_ctrl_flags flags; |
| 203 | dma_addr_t dma_src_addr, dma_dst_addr, phys_addr; |
| 204 | struct dma_async_tx_descriptor *tx = NULL; |
| 205 | dma_cookie_t cookie; |
| 206 | struct nand_chip *chip = mtd->priv; |
| 207 | struct atmel_nand_host *host = chip->priv; |
| 208 | void *p = buf; |
| 209 | int err = -EIO; |
| 210 | enum dma_data_direction dir = is_read ? DMA_FROM_DEVICE : DMA_TO_DEVICE; |
| 211 | |
| 212 | if (buf >= high_memory) { |
| 213 | struct page *pg; |
| 214 | |
| 215 | if (((size_t)buf & PAGE_MASK) != |
| 216 | ((size_t)(buf + len - 1) & PAGE_MASK)) { |
| 217 | dev_warn(host->dev, "Buffer not fit in one page\n"); |
| 218 | goto err_buf; |
| 219 | } |
| 220 | |
| 221 | pg = vmalloc_to_page(buf); |
| 222 | if (pg == 0) { |
| 223 | dev_err(host->dev, "Failed to vmalloc_to_page\n"); |
| 224 | goto err_buf; |
| 225 | } |
| 226 | p = page_address(pg) + ((size_t)buf & ~PAGE_MASK); |
| 227 | } |
| 228 | |
| 229 | dma_dev = host->dma_chan->device; |
| 230 | |
| 231 | flags = DMA_CTRL_ACK | DMA_PREP_INTERRUPT | DMA_COMPL_SKIP_SRC_UNMAP | |
| 232 | DMA_COMPL_SKIP_DEST_UNMAP; |
| 233 | |
| 234 | phys_addr = dma_map_single(dma_dev->dev, p, len, dir); |
| 235 | if (dma_mapping_error(dma_dev->dev, phys_addr)) { |
| 236 | dev_err(host->dev, "Failed to dma_map_single\n"); |
| 237 | goto err_buf; |
| 238 | } |
| 239 | |
| 240 | if (is_read) { |
| 241 | dma_src_addr = host->io_phys; |
| 242 | dma_dst_addr = phys_addr; |
| 243 | } else { |
| 244 | dma_src_addr = phys_addr; |
| 245 | dma_dst_addr = host->io_phys; |
| 246 | } |
| 247 | |
| 248 | tx = dma_dev->device_prep_dma_memcpy(host->dma_chan, dma_dst_addr, |
| 249 | dma_src_addr, len, flags); |
| 250 | if (!tx) { |
| 251 | dev_err(host->dev, "Failed to prepare DMA memcpy\n"); |
| 252 | goto err_dma; |
| 253 | } |
| 254 | |
| 255 | init_completion(&host->comp); |
| 256 | tx->callback = dma_complete_func; |
| 257 | tx->callback_param = &host->comp; |
| 258 | |
| 259 | cookie = tx->tx_submit(tx); |
| 260 | if (dma_submit_error(cookie)) { |
| 261 | dev_err(host->dev, "Failed to do DMA tx_submit\n"); |
| 262 | goto err_dma; |
| 263 | } |
| 264 | |
| 265 | dma_async_issue_pending(host->dma_chan); |
| 266 | wait_for_completion(&host->comp); |
| 267 | |
| 268 | err = 0; |
| 269 | |
| 270 | err_dma: |
| 271 | dma_unmap_single(dma_dev->dev, phys_addr, len, dir); |
| 272 | err_buf: |
| 273 | if (err != 0) |
| 274 | dev_warn(host->dev, "Fall back to CPU I/O\n"); |
| 275 | return err; |
| 276 | } |
| 277 | |
| 278 | static void atmel_read_buf(struct mtd_info *mtd, u8 *buf, int len) |
| 279 | { |
| 280 | struct nand_chip *chip = mtd->priv; |
| 281 | struct atmel_nand_host *host = chip->priv; |
| 282 | |
| 283 | if (use_dma && len >= mtd->oobsize) |
| 284 | if (atmel_nand_dma_op(mtd, buf, len, 1) == 0) |
| 285 | return; |
| 286 | |
| 287 | if (host->board->bus_width_16) |
| 288 | atmel_read_buf16(mtd, buf, len); |
| 289 | else |
| 290 | atmel_read_buf8(mtd, buf, len); |
| 291 | } |
| 292 | |
| 293 | static void atmel_write_buf(struct mtd_info *mtd, const u8 *buf, int len) |
| 294 | { |
| 295 | struct nand_chip *chip = mtd->priv; |
| 296 | struct atmel_nand_host *host = chip->priv; |
| 297 | |
| 298 | if (use_dma && len >= mtd->oobsize) |
| 299 | if (atmel_nand_dma_op(mtd, (void *)buf, len, 0) == 0) |
| 300 | return; |
| 301 | |
| 302 | if (host->board->bus_width_16) |
| 303 | atmel_write_buf16(mtd, buf, len); |
| 304 | else |
| 305 | atmel_write_buf8(mtd, buf, len); |
| 306 | } |
| 307 | |
David Brownell | 23a346c | 2008-07-03 23:40:16 -0700 | [diff] [blame] | 308 | /* |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 309 | * Calculate HW ECC |
| 310 | * |
| 311 | * function called after a write |
| 312 | * |
| 313 | * mtd: MTD block structure |
| 314 | * dat: raw data (unused) |
| 315 | * ecc_code: buffer for ECC |
| 316 | */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 317 | static int atmel_nand_calculate(struct mtd_info *mtd, |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 318 | const u_char *dat, unsigned char *ecc_code) |
| 319 | { |
| 320 | struct nand_chip *nand_chip = mtd->priv; |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 321 | struct atmel_nand_host *host = nand_chip->priv; |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 322 | unsigned int ecc_value; |
| 323 | |
| 324 | /* get the first 2 ECC bytes */ |
Richard Genoud | d43fa14 | 2008-04-25 09:32:26 +0200 | [diff] [blame] | 325 | ecc_value = ecc_readl(host->ecc, PR); |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 326 | |
Richard Genoud | 3fc2389 | 2008-10-12 08:42:28 +0200 | [diff] [blame] | 327 | ecc_code[0] = ecc_value & 0xFF; |
| 328 | ecc_code[1] = (ecc_value >> 8) & 0xFF; |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 329 | |
| 330 | /* get the last 2 ECC bytes */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 331 | ecc_value = ecc_readl(host->ecc, NPR) & ATMEL_ECC_NPARITY; |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 332 | |
Richard Genoud | 3fc2389 | 2008-10-12 08:42:28 +0200 | [diff] [blame] | 333 | ecc_code[2] = ecc_value & 0xFF; |
| 334 | ecc_code[3] = (ecc_value >> 8) & 0xFF; |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 335 | |
| 336 | return 0; |
| 337 | } |
| 338 | |
| 339 | /* |
| 340 | * HW ECC read page function |
| 341 | * |
| 342 | * mtd: mtd info structure |
| 343 | * chip: nand chip info structure |
| 344 | * buf: buffer to store read data |
| 345 | */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 346 | static int atmel_nand_read_page(struct mtd_info *mtd, |
Sneha Narnakaje | 46a8cf2 | 2009-09-18 12:51:46 -0700 | [diff] [blame] | 347 | struct nand_chip *chip, uint8_t *buf, int page) |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 348 | { |
| 349 | int eccsize = chip->ecc.size; |
| 350 | int eccbytes = chip->ecc.bytes; |
| 351 | uint32_t *eccpos = chip->ecc.layout->eccpos; |
| 352 | uint8_t *p = buf; |
| 353 | uint8_t *oob = chip->oob_poi; |
| 354 | uint8_t *ecc_pos; |
| 355 | int stat; |
| 356 | |
Haavard Skinnemoen | d6248fd | 2008-07-03 23:40:18 -0700 | [diff] [blame] | 357 | /* |
| 358 | * Errata: ALE is incorrectly wired up to the ECC controller |
| 359 | * on the AP7000, so it will include the address cycles in the |
| 360 | * ECC calculation. |
| 361 | * |
| 362 | * Workaround: Reset the parity registers before reading the |
| 363 | * actual data. |
| 364 | */ |
| 365 | if (cpu_is_at32ap7000()) { |
| 366 | struct atmel_nand_host *host = chip->priv; |
| 367 | ecc_writel(host->ecc, CR, ATMEL_ECC_RST); |
| 368 | } |
| 369 | |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 370 | /* read the page */ |
| 371 | chip->read_buf(mtd, p, eccsize); |
| 372 | |
| 373 | /* move to ECC position if needed */ |
| 374 | if (eccpos[0] != 0) { |
| 375 | /* This only works on large pages |
| 376 | * because the ECC controller waits for |
| 377 | * NAND_CMD_RNDOUTSTART after the |
| 378 | * NAND_CMD_RNDOUT. |
| 379 | * anyway, for small pages, the eccpos[0] == 0 |
| 380 | */ |
| 381 | chip->cmdfunc(mtd, NAND_CMD_RNDOUT, |
| 382 | mtd->writesize + eccpos[0], -1); |
| 383 | } |
| 384 | |
| 385 | /* the ECC controller needs to read the ECC just after the data */ |
| 386 | ecc_pos = oob + eccpos[0]; |
| 387 | chip->read_buf(mtd, ecc_pos, eccbytes); |
| 388 | |
| 389 | /* check if there's an error */ |
| 390 | stat = chip->ecc.correct(mtd, p, oob, NULL); |
| 391 | |
| 392 | if (stat < 0) |
| 393 | mtd->ecc_stats.failed++; |
| 394 | else |
| 395 | mtd->ecc_stats.corrected += stat; |
| 396 | |
| 397 | /* get back to oob start (end of page) */ |
| 398 | chip->cmdfunc(mtd, NAND_CMD_RNDOUT, mtd->writesize, -1); |
| 399 | |
| 400 | /* read the oob */ |
| 401 | chip->read_buf(mtd, oob, mtd->oobsize); |
| 402 | |
| 403 | return 0; |
| 404 | } |
| 405 | |
| 406 | /* |
| 407 | * HW ECC Correction |
| 408 | * |
| 409 | * function called after a read |
| 410 | * |
| 411 | * mtd: MTD block structure |
| 412 | * dat: raw data read from the chip |
| 413 | * read_ecc: ECC from the chip (unused) |
| 414 | * isnull: unused |
| 415 | * |
| 416 | * Detect and correct a 1 bit error for a page |
| 417 | */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 418 | static int atmel_nand_correct(struct mtd_info *mtd, u_char *dat, |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 419 | u_char *read_ecc, u_char *isnull) |
| 420 | { |
| 421 | struct nand_chip *nand_chip = mtd->priv; |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 422 | struct atmel_nand_host *host = nand_chip->priv; |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 423 | unsigned int ecc_status; |
| 424 | unsigned int ecc_word, ecc_bit; |
| 425 | |
| 426 | /* get the status from the Status Register */ |
| 427 | ecc_status = ecc_readl(host->ecc, SR); |
| 428 | |
| 429 | /* if there's no error */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 430 | if (likely(!(ecc_status & ATMEL_ECC_RECERR))) |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 431 | return 0; |
| 432 | |
| 433 | /* get error bit offset (4 bits) */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 434 | ecc_bit = ecc_readl(host->ecc, PR) & ATMEL_ECC_BITADDR; |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 435 | /* get word address (12 bits) */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 436 | ecc_word = ecc_readl(host->ecc, PR) & ATMEL_ECC_WORDADDR; |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 437 | ecc_word >>= 4; |
| 438 | |
| 439 | /* if there are multiple errors */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 440 | if (ecc_status & ATMEL_ECC_MULERR) { |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 441 | /* check if it is a freshly erased block |
| 442 | * (filled with 0xff) */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 443 | if ((ecc_bit == ATMEL_ECC_BITADDR) |
| 444 | && (ecc_word == (ATMEL_ECC_WORDADDR >> 4))) { |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 445 | /* the block has just been erased, return OK */ |
| 446 | return 0; |
| 447 | } |
| 448 | /* it doesn't seems to be a freshly |
| 449 | * erased block. |
| 450 | * We can't correct so many errors */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 451 | dev_dbg(host->dev, "atmel_nand : multiple errors detected." |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 452 | " Unable to correct.\n"); |
| 453 | return -EIO; |
| 454 | } |
| 455 | |
| 456 | /* if there's a single bit error : we can correct it */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 457 | if (ecc_status & ATMEL_ECC_ECCERR) { |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 458 | /* there's nothing much to do here. |
| 459 | * the bit error is on the ECC itself. |
| 460 | */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 461 | dev_dbg(host->dev, "atmel_nand : one bit error on ECC code." |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 462 | " Nothing to correct\n"); |
| 463 | return 0; |
| 464 | } |
| 465 | |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 466 | dev_dbg(host->dev, "atmel_nand : one bit error on data." |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 467 | " (word offset in the page :" |
| 468 | " 0x%x bit offset : 0x%x)\n", |
| 469 | ecc_word, ecc_bit); |
| 470 | /* correct the error */ |
| 471 | if (nand_chip->options & NAND_BUSWIDTH_16) { |
| 472 | /* 16 bits words */ |
| 473 | ((unsigned short *) dat)[ecc_word] ^= (1 << ecc_bit); |
| 474 | } else { |
| 475 | /* 8 bits words */ |
| 476 | dat[ecc_word] ^= (1 << ecc_bit); |
| 477 | } |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 478 | dev_dbg(host->dev, "atmel_nand : error corrected\n"); |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 479 | return 1; |
| 480 | } |
| 481 | |
| 482 | /* |
Haavard Skinnemoen | d6248fd | 2008-07-03 23:40:18 -0700 | [diff] [blame] | 483 | * Enable HW ECC : unused on most chips |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 484 | */ |
Haavard Skinnemoen | d6248fd | 2008-07-03 23:40:18 -0700 | [diff] [blame] | 485 | static void atmel_nand_hwctl(struct mtd_info *mtd, int mode) |
| 486 | { |
| 487 | if (cpu_is_at32ap7000()) { |
| 488 | struct nand_chip *nand_chip = mtd->priv; |
| 489 | struct atmel_nand_host *host = nand_chip->priv; |
| 490 | ecc_writel(host->ecc, CR, ATMEL_ECC_RST); |
| 491 | } |
| 492 | } |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 493 | |
Andreas Bießmann | 9a9745c3 | 2010-08-05 12:38:41 +0200 | [diff] [blame] | 494 | #ifdef CONFIG_MTD_CMDLINE_PARTS |
Atsushi Nemoto | 52f8301 | 2008-03-30 21:59:37 +0900 | [diff] [blame] | 495 | static const char *part_probes[] = { "cmdlinepart", NULL }; |
Andrew Victor | 693ef66 | 2007-05-03 08:16:44 +0200 | [diff] [blame] | 496 | #endif |
| 497 | |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 498 | /* |
| 499 | * Probe for the NAND device. |
| 500 | */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 501 | static int __init atmel_nand_probe(struct platform_device *pdev) |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 502 | { |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 503 | struct atmel_nand_host *host; |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 504 | struct mtd_info *mtd; |
| 505 | struct nand_chip *nand_chip; |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 506 | struct resource *regs; |
| 507 | struct resource *mem; |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 508 | int res; |
| 509 | |
| 510 | #ifdef CONFIG_MTD_PARTITIONS |
| 511 | struct mtd_partition *partitions = NULL; |
| 512 | int num_partitions = 0; |
| 513 | #endif |
| 514 | |
Håvard Skinnemoen | cc0c72e | 2008-06-06 18:04:54 +0200 | [diff] [blame] | 515 | mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
| 516 | if (!mem) { |
| 517 | printk(KERN_ERR "atmel_nand: can't get I/O resource mem\n"); |
| 518 | return -ENXIO; |
| 519 | } |
| 520 | |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 521 | /* Allocate memory for the device structure (and zero it) */ |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 522 | host = kzalloc(sizeof(struct atmel_nand_host), GFP_KERNEL); |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 523 | if (!host) { |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 524 | printk(KERN_ERR "atmel_nand: failed to allocate device structure.\n"); |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 525 | return -ENOMEM; |
| 526 | } |
| 527 | |
Hong Xu | cbc6c5e | 2011-01-18 14:36:05 +0800 | [diff] [blame] | 528 | host->io_phys = (dma_addr_t)mem->start; |
| 529 | |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 530 | host->io_base = ioremap(mem->start, mem->end - mem->start + 1); |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 531 | if (host->io_base == NULL) { |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 532 | printk(KERN_ERR "atmel_nand: ioremap failed\n"); |
Håvard Skinnemoen | cc0c72e | 2008-06-06 18:04:54 +0200 | [diff] [blame] | 533 | res = -EIO; |
| 534 | goto err_nand_ioremap; |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 535 | } |
| 536 | |
| 537 | mtd = &host->mtd; |
| 538 | nand_chip = &host->nand_chip; |
| 539 | host->board = pdev->dev.platform_data; |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 540 | host->dev = &pdev->dev; |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 541 | |
| 542 | nand_chip->priv = host; /* link the private data structures */ |
| 543 | mtd->priv = nand_chip; |
| 544 | mtd->owner = THIS_MODULE; |
| 545 | |
| 546 | /* Set address of NAND IO lines */ |
| 547 | nand_chip->IO_ADDR_R = host->io_base; |
| 548 | nand_chip->IO_ADDR_W = host->io_base; |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 549 | nand_chip->cmd_ctrl = atmel_nand_cmd_ctrl; |
Ivan Kuten | a4265f8 | 2007-05-24 14:35:58 +0300 | [diff] [blame] | 550 | |
| 551 | if (host->board->rdy_pin) |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 552 | nand_chip->dev_ready = atmel_nand_device_ready; |
Ivan Kuten | a4265f8 | 2007-05-24 14:35:58 +0300 | [diff] [blame] | 553 | |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 554 | regs = platform_get_resource(pdev, IORESOURCE_MEM, 1); |
| 555 | if (!regs && hard_ecc) { |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 556 | printk(KERN_ERR "atmel_nand: can't get I/O resource " |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 557 | "regs\nFalling back on software ECC\n"); |
| 558 | } |
| 559 | |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 560 | nand_chip->ecc.mode = NAND_ECC_SOFT; /* enable ECC */ |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 561 | if (no_ecc) |
| 562 | nand_chip->ecc.mode = NAND_ECC_NONE; |
| 563 | if (hard_ecc && regs) { |
| 564 | host->ecc = ioremap(regs->start, regs->end - regs->start + 1); |
| 565 | if (host->ecc == NULL) { |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 566 | printk(KERN_ERR "atmel_nand: ioremap failed\n"); |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 567 | res = -EIO; |
| 568 | goto err_ecc_ioremap; |
| 569 | } |
Richard Genoud | 3fc2389 | 2008-10-12 08:42:28 +0200 | [diff] [blame] | 570 | nand_chip->ecc.mode = NAND_ECC_HW; |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 571 | nand_chip->ecc.calculate = atmel_nand_calculate; |
| 572 | nand_chip->ecc.correct = atmel_nand_correct; |
| 573 | nand_chip->ecc.hwctl = atmel_nand_hwctl; |
| 574 | nand_chip->ecc.read_page = atmel_nand_read_page; |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 575 | nand_chip->ecc.bytes = 4; |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 576 | } |
| 577 | |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 578 | nand_chip->chip_delay = 20; /* 20us command delay time */ |
| 579 | |
Hong Xu | cbc6c5e | 2011-01-18 14:36:05 +0800 | [diff] [blame] | 580 | if (host->board->bus_width_16) /* 16-bit bus width */ |
Andrew Victor | dd11b8c | 2006-12-08 13:49:42 +0200 | [diff] [blame] | 581 | nand_chip->options |= NAND_BUSWIDTH_16; |
Hong Xu | cbc6c5e | 2011-01-18 14:36:05 +0800 | [diff] [blame] | 582 | |
| 583 | nand_chip->read_buf = atmel_read_buf; |
| 584 | nand_chip->write_buf = atmel_write_buf; |
Andrew Victor | dd11b8c | 2006-12-08 13:49:42 +0200 | [diff] [blame] | 585 | |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 586 | platform_set_drvdata(pdev, host); |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 587 | atmel_nand_enable(host); |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 588 | |
| 589 | if (host->board->det_pin) { |
Håvard Skinnemoen | 62fd71f | 2008-06-06 18:04:51 +0200 | [diff] [blame] | 590 | if (gpio_get_value(host->board->det_pin)) { |
Simon Polette | f4fa697 | 2009-05-27 18:19:39 +0300 | [diff] [blame] | 591 | printk(KERN_INFO "No SmartMedia card inserted.\n"); |
Roel Kluin | 895fb49 | 2009-11-11 21:47:06 +0100 | [diff] [blame] | 592 | res = -ENXIO; |
Håvard Skinnemoen | cc0c72e | 2008-06-06 18:04:54 +0200 | [diff] [blame] | 593 | goto err_no_card; |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 594 | } |
| 595 | } |
| 596 | |
Simon Polette | f4fa697 | 2009-05-27 18:19:39 +0300 | [diff] [blame] | 597 | if (on_flash_bbt) { |
| 598 | printk(KERN_INFO "atmel_nand: Use On Flash BBT\n"); |
| 599 | nand_chip->options |= NAND_USE_FLASH_BBT; |
| 600 | } |
| 601 | |
Hong Xu | cbc6c5e | 2011-01-18 14:36:05 +0800 | [diff] [blame] | 602 | if (cpu_has_dma() && use_dma) { |
| 603 | dma_cap_mask_t mask; |
| 604 | |
| 605 | dma_cap_zero(mask); |
| 606 | dma_cap_set(DMA_MEMCPY, mask); |
| 607 | host->dma_chan = dma_request_channel(mask, 0, NULL); |
| 608 | if (!host->dma_chan) { |
| 609 | dev_err(host->dev, "Failed to request DMA channel\n"); |
| 610 | use_dma = 0; |
| 611 | } |
| 612 | } |
| 613 | if (use_dma) |
Nicolas Ferre | 042bc9c | 2011-03-30 16:26:40 +0800 | [diff] [blame^] | 614 | dev_info(host->dev, "Using %s for DMA transfers.\n", |
| 615 | dma_chan_name(host->dma_chan)); |
Hong Xu | cbc6c5e | 2011-01-18 14:36:05 +0800 | [diff] [blame] | 616 | else |
| 617 | dev_info(host->dev, "No DMA support for NAND access.\n"); |
| 618 | |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 619 | /* first scan to find the device and get the page size */ |
David Woodhouse | 5e81e88 | 2010-02-26 18:32:56 +0000 | [diff] [blame] | 620 | if (nand_scan_ident(mtd, 1, NULL)) { |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 621 | res = -ENXIO; |
Håvard Skinnemoen | cc0c72e | 2008-06-06 18:04:54 +0200 | [diff] [blame] | 622 | goto err_scan_ident; |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 623 | } |
| 624 | |
Richard Genoud | 3fc2389 | 2008-10-12 08:42:28 +0200 | [diff] [blame] | 625 | if (nand_chip->ecc.mode == NAND_ECC_HW) { |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 626 | /* ECC is calculated for the whole page (1 step) */ |
| 627 | nand_chip->ecc.size = mtd->writesize; |
| 628 | |
| 629 | /* set ECC page size and oob layout */ |
| 630 | switch (mtd->writesize) { |
| 631 | case 512: |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 632 | nand_chip->ecc.layout = &atmel_oobinfo_small; |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 633 | ecc_writel(host->ecc, MR, ATMEL_ECC_PAGESIZE_528); |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 634 | break; |
| 635 | case 1024: |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 636 | nand_chip->ecc.layout = &atmel_oobinfo_large; |
| 637 | ecc_writel(host->ecc, MR, ATMEL_ECC_PAGESIZE_1056); |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 638 | break; |
| 639 | case 2048: |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 640 | nand_chip->ecc.layout = &atmel_oobinfo_large; |
| 641 | ecc_writel(host->ecc, MR, ATMEL_ECC_PAGESIZE_2112); |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 642 | break; |
| 643 | case 4096: |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 644 | nand_chip->ecc.layout = &atmel_oobinfo_large; |
| 645 | ecc_writel(host->ecc, MR, ATMEL_ECC_PAGESIZE_4224); |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 646 | break; |
| 647 | default: |
| 648 | /* page size not handled by HW ECC */ |
| 649 | /* switching back to soft ECC */ |
| 650 | nand_chip->ecc.mode = NAND_ECC_SOFT; |
| 651 | nand_chip->ecc.calculate = NULL; |
| 652 | nand_chip->ecc.correct = NULL; |
| 653 | nand_chip->ecc.hwctl = NULL; |
| 654 | nand_chip->ecc.read_page = NULL; |
| 655 | nand_chip->ecc.postpad = 0; |
| 656 | nand_chip->ecc.prepad = 0; |
| 657 | nand_chip->ecc.bytes = 0; |
| 658 | break; |
| 659 | } |
| 660 | } |
| 661 | |
| 662 | /* second phase scan */ |
| 663 | if (nand_scan_tail(mtd)) { |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 664 | res = -ENXIO; |
Håvard Skinnemoen | cc0c72e | 2008-06-06 18:04:54 +0200 | [diff] [blame] | 665 | goto err_scan_tail; |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 666 | } |
| 667 | |
| 668 | #ifdef CONFIG_MTD_PARTITIONS |
Andrew Victor | 693ef66 | 2007-05-03 08:16:44 +0200 | [diff] [blame] | 669 | #ifdef CONFIG_MTD_CMDLINE_PARTS |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 670 | mtd->name = "atmel_nand"; |
Atsushi Nemoto | 842b1a10 | 2008-01-29 22:28:22 +0900 | [diff] [blame] | 671 | num_partitions = parse_mtd_partitions(mtd, part_probes, |
| 672 | &partitions, 0); |
Andrew Victor | 693ef66 | 2007-05-03 08:16:44 +0200 | [diff] [blame] | 673 | #endif |
Atsushi Nemoto | 842b1a10 | 2008-01-29 22:28:22 +0900 | [diff] [blame] | 674 | if (num_partitions <= 0 && host->board->partition_info) |
| 675 | partitions = host->board->partition_info(mtd->size, |
| 676 | &num_partitions); |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 677 | |
| 678 | if ((!partitions) || (num_partitions == 0)) { |
Thadeu Lima de Souza Cascardo | ae27a7a | 2009-06-24 18:40:46 -0300 | [diff] [blame] | 679 | printk(KERN_ERR "atmel_nand: No partitions defined, or unsupported device.\n"); |
Roel Kluin | 895fb49 | 2009-11-11 21:47:06 +0100 | [diff] [blame] | 680 | res = -ENXIO; |
Håvard Skinnemoen | cc0c72e | 2008-06-06 18:04:54 +0200 | [diff] [blame] | 681 | goto err_no_partitions; |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 682 | } |
| 683 | |
| 684 | res = add_mtd_partitions(mtd, partitions, num_partitions); |
| 685 | #else |
| 686 | res = add_mtd_device(mtd); |
| 687 | #endif |
| 688 | |
| 689 | if (!res) |
| 690 | return res; |
| 691 | |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 692 | #ifdef CONFIG_MTD_PARTITIONS |
Håvard Skinnemoen | cc0c72e | 2008-06-06 18:04:54 +0200 | [diff] [blame] | 693 | err_no_partitions: |
Richard Genoud | 77f5492 | 2008-04-23 19:51:14 +0200 | [diff] [blame] | 694 | #endif |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 695 | nand_release(mtd); |
Håvard Skinnemoen | cc0c72e | 2008-06-06 18:04:54 +0200 | [diff] [blame] | 696 | err_scan_tail: |
| 697 | err_scan_ident: |
| 698 | err_no_card: |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 699 | atmel_nand_disable(host); |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 700 | platform_set_drvdata(pdev, NULL); |
Hong Xu | cbc6c5e | 2011-01-18 14:36:05 +0800 | [diff] [blame] | 701 | if (host->dma_chan) |
| 702 | dma_release_channel(host->dma_chan); |
Håvard Skinnemoen | cc0c72e | 2008-06-06 18:04:54 +0200 | [diff] [blame] | 703 | if (host->ecc) |
| 704 | iounmap(host->ecc); |
| 705 | err_ecc_ioremap: |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 706 | iounmap(host->io_base); |
Håvard Skinnemoen | cc0c72e | 2008-06-06 18:04:54 +0200 | [diff] [blame] | 707 | err_nand_ioremap: |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 708 | kfree(host); |
| 709 | return res; |
| 710 | } |
| 711 | |
| 712 | /* |
| 713 | * Remove a NAND device. |
| 714 | */ |
David Brownell | 23a346c | 2008-07-03 23:40:16 -0700 | [diff] [blame] | 715 | static int __exit atmel_nand_remove(struct platform_device *pdev) |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 716 | { |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 717 | struct atmel_nand_host *host = platform_get_drvdata(pdev); |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 718 | struct mtd_info *mtd = &host->mtd; |
| 719 | |
| 720 | nand_release(mtd); |
| 721 | |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 722 | atmel_nand_disable(host); |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 723 | |
Håvard Skinnemoen | cc0c72e | 2008-06-06 18:04:54 +0200 | [diff] [blame] | 724 | if (host->ecc) |
| 725 | iounmap(host->ecc); |
Hong Xu | cbc6c5e | 2011-01-18 14:36:05 +0800 | [diff] [blame] | 726 | |
| 727 | if (host->dma_chan) |
| 728 | dma_release_channel(host->dma_chan); |
| 729 | |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 730 | iounmap(host->io_base); |
| 731 | kfree(host); |
| 732 | |
| 733 | return 0; |
| 734 | } |
| 735 | |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 736 | static struct platform_driver atmel_nand_driver = { |
David Brownell | 23a346c | 2008-07-03 23:40:16 -0700 | [diff] [blame] | 737 | .remove = __exit_p(atmel_nand_remove), |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 738 | .driver = { |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 739 | .name = "atmel_nand", |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 740 | .owner = THIS_MODULE, |
| 741 | }, |
| 742 | }; |
| 743 | |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 744 | static int __init atmel_nand_init(void) |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 745 | { |
David Brownell | 23a346c | 2008-07-03 23:40:16 -0700 | [diff] [blame] | 746 | return platform_driver_probe(&atmel_nand_driver, atmel_nand_probe); |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 747 | } |
| 748 | |
| 749 | |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 750 | static void __exit atmel_nand_exit(void) |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 751 | { |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 752 | platform_driver_unregister(&atmel_nand_driver); |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 753 | } |
| 754 | |
| 755 | |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 756 | module_init(atmel_nand_init); |
| 757 | module_exit(atmel_nand_exit); |
Andrew Victor | 42cb140 | 2006-10-19 18:24:35 +0200 | [diff] [blame] | 758 | |
| 759 | MODULE_LICENSE("GPL"); |
| 760 | MODULE_AUTHOR("Rick Bronson"); |
Håvard Skinnemoen | d4f4c0a | 2008-06-06 18:04:52 +0200 | [diff] [blame] | 761 | MODULE_DESCRIPTION("NAND/SmartMedia driver for AT91 / AVR32"); |
Håvard Skinnemoen | 3c3796c | 2008-06-06 18:04:53 +0200 | [diff] [blame] | 762 | MODULE_ALIAS("platform:atmel_nand"); |