atmel_nand.c 17.3 KB
Newer Older
A
Andrew Victor 已提交
1 2 3 4 5 6 7 8 9
/*
 *  Copyright (C) 2003 Rick Bronson
 *
 *  Derived from drivers/mtd/nand/autcpu12.c
 *	 Copyright (c) 2001 Thomas Gleixner (gleixner@autronix.de)
 *
 *  Derived from drivers/mtd/spia.c
 *	 Copyright (C) 2000 Steven J. Hill (sjhill@cotw.com)
 *
10 11 12 13 14 15 16 17 18
 *
 *  Add Hardware ECC support for AT91SAM9260 / AT91SAM9263
 *     Richard Genoud (richard.genoud@gmail.com), Adeneo Copyright (C) 2007
 *
 *     Derived from Das U-Boot source code
 *     		(u-boot-1.1.5/board/atmel/at91sam9263ek/nand.c)
 *     (C) Copyright 2006 ATMEL Rousset, Lacressonniere Nicolas
 *
 *
A
Andrew Victor 已提交
19 20 21 22 23 24
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

25
#include <linux/dma-mapping.h>
A
Andrew Victor 已提交
26 27
#include <linux/slab.h>
#include <linux/module.h>
28
#include <linux/moduleparam.h>
A
Andrew Victor 已提交
29 30 31 32 33
#include <linux/platform_device.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/nand.h>
#include <linux/mtd/partitions.h>

34
#include <linux/dmaengine.h>
35 36
#include <linux/gpio.h>
#include <linux/io.h>
A
Andrew Victor 已提交
37

38 39
#include <mach/board.h>
#include <mach/cpu.h>
A
Andrew Victor 已提交
40

41
#ifdef CONFIG_MTD_NAND_ATMEL_ECC_HW
42 43 44 45 46
#define hard_ecc	1
#else
#define hard_ecc	0
#endif

47
#ifdef CONFIG_MTD_NAND_ATMEL_ECC_NONE
48 49 50 51 52
#define no_ecc		1
#else
#define no_ecc		0
#endif

53 54 55
static int use_dma = 1;
module_param(use_dma, int, 0);

56 57 58
static int on_flash_bbt = 0;
module_param(on_flash_bbt, int, 0);

59 60
/* Register access macros */
#define ecc_readl(add, reg)				\
61
	__raw_readl(add + ATMEL_ECC_##reg)
62
#define ecc_writel(add, reg, value)			\
63
	__raw_writel((value), add + ATMEL_ECC_##reg)
64

65
#include "atmel_nand_ecc.h"	/* Hardware ECC registers */
66 67 68 69 70 71

/* oob layout for large page size
 * bad block info is on bytes 0 and 1
 * the bytes have to be consecutives to avoid
 * several NAND_CMD_RNDOUT during read
 */
72
static struct nand_ecclayout atmel_oobinfo_large = {
73 74 75 76 77 78 79 80 81 82 83 84
	.eccbytes = 4,
	.eccpos = {60, 61, 62, 63},
	.oobfree = {
		{2, 58}
	},
};

/* oob layout for small page size
 * bad block info is on bytes 4 and 5
 * the bytes have to be consecutives to avoid
 * several NAND_CMD_RNDOUT during read
 */
85
static struct nand_ecclayout atmel_oobinfo_small = {
86 87 88 89 90 91 92
	.eccbytes = 4,
	.eccpos = {0, 1, 2, 3},
	.oobfree = {
		{6, 10}
	},
};

93
struct atmel_nand_host {
A
Andrew Victor 已提交
94 95 96
	struct nand_chip	nand_chip;
	struct mtd_info		mtd;
	void __iomem		*io_base;
97
	dma_addr_t		io_phys;
98
	struct atmel_nand_data	*board;
99 100
	struct device		*dev;
	void __iomem		*ecc;
101 102 103

	struct completion	comp;
	struct dma_chan		*dma_chan;
A
Andrew Victor 已提交
104 105
};

106 107 108 109 110
static int cpu_has_dma(void)
{
	return cpu_is_at91sam9rl() || cpu_is_at91sam9g45();
}

111 112 113
/*
 * Enable NAND.
 */
114
static void atmel_nand_enable(struct atmel_nand_host *host)
115 116
{
	if (host->board->enable_pin)
117
		gpio_set_value(host->board->enable_pin, 0);
118 119 120 121 122
}

/*
 * Disable NAND.
 */
123
static void atmel_nand_disable(struct atmel_nand_host *host)
124 125
{
	if (host->board->enable_pin)
126
		gpio_set_value(host->board->enable_pin, 1);
127 128
}

A
Andrew Victor 已提交
129 130 131
/*
 * Hardware specific access to control-lines
 */
132
static void atmel_nand_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
A
Andrew Victor 已提交
133 134
{
	struct nand_chip *nand_chip = mtd->priv;
135
	struct atmel_nand_host *host = nand_chip->priv;
A
Andrew Victor 已提交
136

137
	if (ctrl & NAND_CTRL_CHANGE) {
138
		if (ctrl & NAND_NCE)
139
			atmel_nand_enable(host);
140
		else
141
			atmel_nand_disable(host);
142
	}
A
Andrew Victor 已提交
143 144 145 146 147 148 149 150 151 152 153 154
	if (cmd == NAND_CMD_NONE)
		return;

	if (ctrl & NAND_CLE)
		writeb(cmd, host->io_base + (1 << host->board->cle));
	else
		writeb(cmd, host->io_base + (1 << host->board->ale));
}

/*
 * Read the Device Ready pin.
 */
155
static int atmel_nand_device_ready(struct mtd_info *mtd)
A
Andrew Victor 已提交
156 157
{
	struct nand_chip *nand_chip = mtd->priv;
158
	struct atmel_nand_host *host = nand_chip->priv;
A
Andrew Victor 已提交
159

160 161
	return gpio_get_value(host->board->rdy_pin) ^
                !!host->board->rdy_pin_active_low;
A
Andrew Victor 已提交
162 163
}

164 165 166
/*
 * Minimal-overhead PIO for data access.
 */
167
static void atmel_read_buf8(struct mtd_info *mtd, u8 *buf, int len)
168 169 170 171 172 173 174 175 176 177 178 179 180
{
	struct nand_chip	*nand_chip = mtd->priv;

	__raw_readsb(nand_chip->IO_ADDR_R, buf, len);
}

static void atmel_read_buf16(struct mtd_info *mtd, u8 *buf, int len)
{
	struct nand_chip	*nand_chip = mtd->priv;

	__raw_readsw(nand_chip->IO_ADDR_R, buf, len / 2);
}

181
static void atmel_write_buf8(struct mtd_info *mtd, const u8 *buf, int len)
182 183 184 185 186 187 188 189 190 191 192 193 194
{
	struct nand_chip	*nand_chip = mtd->priv;

	__raw_writesb(nand_chip->IO_ADDR_W, buf, len);
}

static void atmel_write_buf16(struct mtd_info *mtd, const u8 *buf, int len)
{
	struct nand_chip	*nand_chip = mtd->priv;

	__raw_writesw(nand_chip->IO_ADDR_W, buf, len / 2);
}

195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213
static void dma_complete_func(void *completion)
{
	complete(completion);
}

static int atmel_nand_dma_op(struct mtd_info *mtd, void *buf, int len,
			       int is_read)
{
	struct dma_device *dma_dev;
	enum dma_ctrl_flags flags;
	dma_addr_t dma_src_addr, dma_dst_addr, phys_addr;
	struct dma_async_tx_descriptor *tx = NULL;
	dma_cookie_t cookie;
	struct nand_chip *chip = mtd->priv;
	struct atmel_nand_host *host = chip->priv;
	void *p = buf;
	int err = -EIO;
	enum dma_data_direction dir = is_read ? DMA_FROM_DEVICE : DMA_TO_DEVICE;

214 215
	if (buf >= high_memory)
		goto err_buf;
216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270

	dma_dev = host->dma_chan->device;

	flags = DMA_CTRL_ACK | DMA_PREP_INTERRUPT | DMA_COMPL_SKIP_SRC_UNMAP |
		DMA_COMPL_SKIP_DEST_UNMAP;

	phys_addr = dma_map_single(dma_dev->dev, p, len, dir);
	if (dma_mapping_error(dma_dev->dev, phys_addr)) {
		dev_err(host->dev, "Failed to dma_map_single\n");
		goto err_buf;
	}

	if (is_read) {
		dma_src_addr = host->io_phys;
		dma_dst_addr = phys_addr;
	} else {
		dma_src_addr = phys_addr;
		dma_dst_addr = host->io_phys;
	}

	tx = dma_dev->device_prep_dma_memcpy(host->dma_chan, dma_dst_addr,
					     dma_src_addr, len, flags);
	if (!tx) {
		dev_err(host->dev, "Failed to prepare DMA memcpy\n");
		goto err_dma;
	}

	init_completion(&host->comp);
	tx->callback = dma_complete_func;
	tx->callback_param = &host->comp;

	cookie = tx->tx_submit(tx);
	if (dma_submit_error(cookie)) {
		dev_err(host->dev, "Failed to do DMA tx_submit\n");
		goto err_dma;
	}

	dma_async_issue_pending(host->dma_chan);
	wait_for_completion(&host->comp);

	err = 0;

err_dma:
	dma_unmap_single(dma_dev->dev, phys_addr, len, dir);
err_buf:
	if (err != 0)
		dev_warn(host->dev, "Fall back to CPU I/O\n");
	return err;
}

static void atmel_read_buf(struct mtd_info *mtd, u8 *buf, int len)
{
	struct nand_chip *chip = mtd->priv;
	struct atmel_nand_host *host = chip->priv;

271 272
	if (use_dma && len > mtd->oobsize)
		/* only use DMA for bigger than oob size: better performances */
273 274 275 276 277 278 279 280 281 282 283 284 285 286
		if (atmel_nand_dma_op(mtd, buf, len, 1) == 0)
			return;

	if (host->board->bus_width_16)
		atmel_read_buf16(mtd, buf, len);
	else
		atmel_read_buf8(mtd, buf, len);
}

static void atmel_write_buf(struct mtd_info *mtd, const u8 *buf, int len)
{
	struct nand_chip *chip = mtd->priv;
	struct atmel_nand_host *host = chip->priv;

287 288
	if (use_dma && len > mtd->oobsize)
		/* only use DMA for bigger than oob size: better performances */
289 290 291 292 293 294 295 296 297
		if (atmel_nand_dma_op(mtd, (void *)buf, len, 0) == 0)
			return;

	if (host->board->bus_width_16)
		atmel_write_buf16(mtd, buf, len);
	else
		atmel_write_buf8(mtd, buf, len);
}

298 299 300 301 302 303 304 305 306
/*
 * Calculate HW ECC
 *
 * function called after a write
 *
 * mtd:        MTD block structure
 * dat:        raw data (unused)
 * ecc_code:   buffer for ECC
 */
307
static int atmel_nand_calculate(struct mtd_info *mtd,
308 309 310
		const u_char *dat, unsigned char *ecc_code)
{
	struct nand_chip *nand_chip = mtd->priv;
311
	struct atmel_nand_host *host = nand_chip->priv;
312 313 314
	unsigned int ecc_value;

	/* get the first 2 ECC bytes */
315
	ecc_value = ecc_readl(host->ecc, PR);
316

317 318
	ecc_code[0] = ecc_value & 0xFF;
	ecc_code[1] = (ecc_value >> 8) & 0xFF;
319 320

	/* get the last 2 ECC bytes */
321
	ecc_value = ecc_readl(host->ecc, NPR) & ATMEL_ECC_NPARITY;
322

323 324
	ecc_code[2] = ecc_value & 0xFF;
	ecc_code[3] = (ecc_value >> 8) & 0xFF;
325 326 327 328 329 330 331 332 333 334 335

	return 0;
}

/*
 * HW ECC read page function
 *
 * mtd:        mtd info structure
 * chip:       nand chip info structure
 * buf:        buffer to store read data
 */
336
static int atmel_nand_read_page(struct mtd_info *mtd,
337
		struct nand_chip *chip, uint8_t *buf, int page)
338 339 340 341 342 343 344 345 346
{
	int eccsize = chip->ecc.size;
	int eccbytes = chip->ecc.bytes;
	uint32_t *eccpos = chip->ecc.layout->eccpos;
	uint8_t *p = buf;
	uint8_t *oob = chip->oob_poi;
	uint8_t *ecc_pos;
	int stat;

347 348 349 350 351 352 353 354 355 356 357 358 359
	/*
	 * Errata: ALE is incorrectly wired up to the ECC controller
	 * on the AP7000, so it will include the address cycles in the
	 * ECC calculation.
	 *
	 * Workaround: Reset the parity registers before reading the
	 * actual data.
	 */
	if (cpu_is_at32ap7000()) {
		struct atmel_nand_host *host = chip->priv;
		ecc_writel(host->ecc, CR, ATMEL_ECC_RST);
	}

360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
	/* read the page */
	chip->read_buf(mtd, p, eccsize);

	/* move to ECC position if needed */
	if (eccpos[0] != 0) {
		/* This only works on large pages
		 * because the ECC controller waits for
		 * NAND_CMD_RNDOUTSTART after the
		 * NAND_CMD_RNDOUT.
		 * anyway, for small pages, the eccpos[0] == 0
		 */
		chip->cmdfunc(mtd, NAND_CMD_RNDOUT,
				mtd->writesize + eccpos[0], -1);
	}

	/* the ECC controller needs to read the ECC just after the data */
	ecc_pos = oob + eccpos[0];
	chip->read_buf(mtd, ecc_pos, eccbytes);

	/* check if there's an error */
	stat = chip->ecc.correct(mtd, p, oob, NULL);

	if (stat < 0)
		mtd->ecc_stats.failed++;
	else
		mtd->ecc_stats.corrected += stat;

	/* get back to oob start (end of page) */
	chip->cmdfunc(mtd, NAND_CMD_RNDOUT, mtd->writesize, -1);

	/* read the oob */
	chip->read_buf(mtd, oob, mtd->oobsize);

	return 0;
}

/*
 * HW ECC Correction
 *
 * function called after a read
 *
 * mtd:        MTD block structure
 * dat:        raw data read from the chip
 * read_ecc:   ECC from the chip (unused)
 * isnull:     unused
 *
 * Detect and correct a 1 bit error for a page
 */
408
static int atmel_nand_correct(struct mtd_info *mtd, u_char *dat,
409 410 411
		u_char *read_ecc, u_char *isnull)
{
	struct nand_chip *nand_chip = mtd->priv;
412
	struct atmel_nand_host *host = nand_chip->priv;
413 414 415 416 417 418 419
	unsigned int ecc_status;
	unsigned int ecc_word, ecc_bit;

	/* get the status from the Status Register */
	ecc_status = ecc_readl(host->ecc, SR);

	/* if there's no error */
420
	if (likely(!(ecc_status & ATMEL_ECC_RECERR)))
421 422 423
		return 0;

	/* get error bit offset (4 bits) */
424
	ecc_bit = ecc_readl(host->ecc, PR) & ATMEL_ECC_BITADDR;
425
	/* get word address (12 bits) */
426
	ecc_word = ecc_readl(host->ecc, PR) & ATMEL_ECC_WORDADDR;
427 428 429
	ecc_word >>= 4;

	/* if there are multiple errors */
430
	if (ecc_status & ATMEL_ECC_MULERR) {
431 432
		/* check if it is a freshly erased block
		 * (filled with 0xff) */
433 434
		if ((ecc_bit == ATMEL_ECC_BITADDR)
				&& (ecc_word == (ATMEL_ECC_WORDADDR >> 4))) {
435 436 437 438 439 440
			/* the block has just been erased, return OK */
			return 0;
		}
		/* it doesn't seems to be a freshly
		 * erased block.
		 * We can't correct so many errors */
441
		dev_dbg(host->dev, "atmel_nand : multiple errors detected."
442 443 444 445 446
				" Unable to correct.\n");
		return -EIO;
	}

	/* if there's a single bit error : we can correct it */
447
	if (ecc_status & ATMEL_ECC_ECCERR) {
448 449 450
		/* there's nothing much to do here.
		 * the bit error is on the ECC itself.
		 */
451
		dev_dbg(host->dev, "atmel_nand : one bit error on ECC code."
452 453 454 455
				" Nothing to correct\n");
		return 0;
	}

456
	dev_dbg(host->dev, "atmel_nand : one bit error on data."
457 458 459 460 461 462 463 464 465 466 467
			" (word offset in the page :"
			" 0x%x bit offset : 0x%x)\n",
			ecc_word, ecc_bit);
	/* correct the error */
	if (nand_chip->options & NAND_BUSWIDTH_16) {
		/* 16 bits words */
		((unsigned short *) dat)[ecc_word] ^= (1 << ecc_bit);
	} else {
		/* 8 bits words */
		dat[ecc_word] ^= (1 << ecc_bit);
	}
468
	dev_dbg(host->dev, "atmel_nand : error corrected\n");
469 470 471 472
	return 1;
}

/*
473
 * Enable HW ECC : unused on most chips
474
 */
475 476 477 478 479 480 481 482
static void atmel_nand_hwctl(struct mtd_info *mtd, int mode)
{
	if (cpu_is_at32ap7000()) {
		struct nand_chip *nand_chip = mtd->priv;
		struct atmel_nand_host *host = nand_chip->priv;
		ecc_writel(host->ecc, CR, ATMEL_ECC_RST);
	}
}
483

A
Andrew Victor 已提交
484 485 486
/*
 * Probe for the NAND device.
 */
487
static int __init atmel_nand_probe(struct platform_device *pdev)
A
Andrew Victor 已提交
488
{
489
	struct atmel_nand_host *host;
A
Andrew Victor 已提交
490 491
	struct mtd_info *mtd;
	struct nand_chip *nand_chip;
492 493
	struct resource *regs;
	struct resource *mem;
A
Andrew Victor 已提交
494 495
	int res;

496 497 498 499 500 501
	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!mem) {
		printk(KERN_ERR "atmel_nand: can't get I/O resource mem\n");
		return -ENXIO;
	}

A
Andrew Victor 已提交
502
	/* Allocate memory for the device structure (and zero it) */
503
	host = kzalloc(sizeof(struct atmel_nand_host), GFP_KERNEL);
A
Andrew Victor 已提交
504
	if (!host) {
505
		printk(KERN_ERR "atmel_nand: failed to allocate device structure.\n");
A
Andrew Victor 已提交
506 507 508
		return -ENOMEM;
	}

509 510
	host->io_phys = (dma_addr_t)mem->start;

511
	host->io_base = ioremap(mem->start, resource_size(mem));
A
Andrew Victor 已提交
512
	if (host->io_base == NULL) {
513
		printk(KERN_ERR "atmel_nand: ioremap failed\n");
514 515
		res = -EIO;
		goto err_nand_ioremap;
A
Andrew Victor 已提交
516 517 518 519 520
	}

	mtd = &host->mtd;
	nand_chip = &host->nand_chip;
	host->board = pdev->dev.platform_data;
521
	host->dev = &pdev->dev;
A
Andrew Victor 已提交
522 523 524 525 526 527 528 529

	nand_chip->priv = host;		/* link the private data structures */
	mtd->priv = nand_chip;
	mtd->owner = THIS_MODULE;

	/* Set address of NAND IO lines */
	nand_chip->IO_ADDR_R = host->io_base;
	nand_chip->IO_ADDR_W = host->io_base;
530
	nand_chip->cmd_ctrl = atmel_nand_cmd_ctrl;
I
Ivan Kuten 已提交
531 532

	if (host->board->rdy_pin)
533
		nand_chip->dev_ready = atmel_nand_device_ready;
I
Ivan Kuten 已提交
534

535 536
	regs = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	if (!regs && hard_ecc) {
537
		printk(KERN_ERR "atmel_nand: can't get I/O resource "
538 539 540
				"regs\nFalling back on software ECC\n");
	}

A
Andrew Victor 已提交
541
	nand_chip->ecc.mode = NAND_ECC_SOFT;	/* enable ECC */
542 543 544
	if (no_ecc)
		nand_chip->ecc.mode = NAND_ECC_NONE;
	if (hard_ecc && regs) {
545
		host->ecc = ioremap(regs->start, resource_size(regs));
546
		if (host->ecc == NULL) {
547
			printk(KERN_ERR "atmel_nand: ioremap failed\n");
548 549 550
			res = -EIO;
			goto err_ecc_ioremap;
		}
551
		nand_chip->ecc.mode = NAND_ECC_HW;
552 553 554 555
		nand_chip->ecc.calculate = atmel_nand_calculate;
		nand_chip->ecc.correct = atmel_nand_correct;
		nand_chip->ecc.hwctl = atmel_nand_hwctl;
		nand_chip->ecc.read_page = atmel_nand_read_page;
556 557 558
		nand_chip->ecc.bytes = 4;
	}

A
Andrew Victor 已提交
559 560
	nand_chip->chip_delay = 20;		/* 20us command delay time */

561
	if (host->board->bus_width_16)	/* 16-bit bus width */
562
		nand_chip->options |= NAND_BUSWIDTH_16;
563 564 565

	nand_chip->read_buf = atmel_read_buf;
	nand_chip->write_buf = atmel_write_buf;
566

A
Andrew Victor 已提交
567
	platform_set_drvdata(pdev, host);
568
	atmel_nand_enable(host);
A
Andrew Victor 已提交
569 570

	if (host->board->det_pin) {
571
		if (gpio_get_value(host->board->det_pin)) {
572
			printk(KERN_INFO "No SmartMedia card inserted.\n");
R
Roel Kluin 已提交
573
			res = -ENXIO;
574
			goto err_no_card;
A
Andrew Victor 已提交
575 576 577
		}
	}

578 579
	if (on_flash_bbt) {
		printk(KERN_INFO "atmel_nand: Use On Flash BBT\n");
580
		nand_chip->bbt_options |= NAND_BBT_USE_FLASH;
581 582
	}

583 584 585 586
	if (!cpu_has_dma())
		use_dma = 0;

	if (use_dma) {
587 588 589 590 591 592 593 594 595 596 597
		dma_cap_mask_t mask;

		dma_cap_zero(mask);
		dma_cap_set(DMA_MEMCPY, mask);
		host->dma_chan = dma_request_channel(mask, 0, NULL);
		if (!host->dma_chan) {
			dev_err(host->dev, "Failed to request DMA channel\n");
			use_dma = 0;
		}
	}
	if (use_dma)
598 599
		dev_info(host->dev, "Using %s for DMA transfers.\n",
					dma_chan_name(host->dma_chan));
600 601 602
	else
		dev_info(host->dev, "No DMA support for NAND access.\n");

603
	/* first scan to find the device and get the page size */
604
	if (nand_scan_ident(mtd, 1, NULL)) {
605
		res = -ENXIO;
606
		goto err_scan_ident;
607 608
	}

609
	if (nand_chip->ecc.mode == NAND_ECC_HW) {
610 611 612 613 614 615
		/* ECC is calculated for the whole page (1 step) */
		nand_chip->ecc.size = mtd->writesize;

		/* set ECC page size and oob layout */
		switch (mtd->writesize) {
		case 512:
616 617
			nand_chip->ecc.layout = &atmel_oobinfo_small;
			ecc_writel(host->ecc, MR, ATMEL_ECC_PAGESIZE_528);
618 619
			break;
		case 1024:
620 621
			nand_chip->ecc.layout = &atmel_oobinfo_large;
			ecc_writel(host->ecc, MR, ATMEL_ECC_PAGESIZE_1056);
622 623
			break;
		case 2048:
624 625
			nand_chip->ecc.layout = &atmel_oobinfo_large;
			ecc_writel(host->ecc, MR, ATMEL_ECC_PAGESIZE_2112);
626 627
			break;
		case 4096:
628 629
			nand_chip->ecc.layout = &atmel_oobinfo_large;
			ecc_writel(host->ecc, MR, ATMEL_ECC_PAGESIZE_4224);
630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647
			break;
		default:
			/* page size not handled by HW ECC */
			/* switching back to soft ECC */
			nand_chip->ecc.mode = NAND_ECC_SOFT;
			nand_chip->ecc.calculate = NULL;
			nand_chip->ecc.correct = NULL;
			nand_chip->ecc.hwctl = NULL;
			nand_chip->ecc.read_page = NULL;
			nand_chip->ecc.postpad = 0;
			nand_chip->ecc.prepad = 0;
			nand_chip->ecc.bytes = 0;
			break;
		}
	}

	/* second phase scan */
	if (nand_scan_tail(mtd)) {
A
Andrew Victor 已提交
648
		res = -ENXIO;
649
		goto err_scan_tail;
A
Andrew Victor 已提交
650 651
	}

652
	mtd->name = "atmel_nand";
653 654
	res = mtd_device_parse_register(mtd, NULL, 0,
			host->board->parts, host->board->num_parts);
A
Andrew Victor 已提交
655 656 657
	if (!res)
		return res;

658 659 660
err_scan_tail:
err_scan_ident:
err_no_card:
661
	atmel_nand_disable(host);
A
Andrew Victor 已提交
662
	platform_set_drvdata(pdev, NULL);
663 664
	if (host->dma_chan)
		dma_release_channel(host->dma_chan);
665 666 667
	if (host->ecc)
		iounmap(host->ecc);
err_ecc_ioremap:
A
Andrew Victor 已提交
668
	iounmap(host->io_base);
669
err_nand_ioremap:
A
Andrew Victor 已提交
670 671 672 673 674 675 676
	kfree(host);
	return res;
}

/*
 * Remove a NAND device.
 */
677
static int __exit atmel_nand_remove(struct platform_device *pdev)
A
Andrew Victor 已提交
678
{
679
	struct atmel_nand_host *host = platform_get_drvdata(pdev);
A
Andrew Victor 已提交
680 681 682 683
	struct mtd_info *mtd = &host->mtd;

	nand_release(mtd);

684
	atmel_nand_disable(host);
A
Andrew Victor 已提交
685

686 687
	if (host->ecc)
		iounmap(host->ecc);
688 689 690 691

	if (host->dma_chan)
		dma_release_channel(host->dma_chan);

A
Andrew Victor 已提交
692 693 694 695 696 697
	iounmap(host->io_base);
	kfree(host);

	return 0;
}

698
static struct platform_driver atmel_nand_driver = {
699
	.remove		= __exit_p(atmel_nand_remove),
A
Andrew Victor 已提交
700
	.driver		= {
701
		.name	= "atmel_nand",
A
Andrew Victor 已提交
702 703 704 705
		.owner	= THIS_MODULE,
	},
};

706
static int __init atmel_nand_init(void)
A
Andrew Victor 已提交
707
{
708
	return platform_driver_probe(&atmel_nand_driver, atmel_nand_probe);
A
Andrew Victor 已提交
709 710 711
}


712
static void __exit atmel_nand_exit(void)
A
Andrew Victor 已提交
713
{
714
	platform_driver_unregister(&atmel_nand_driver);
A
Andrew Victor 已提交
715 716 717
}


718 719
module_init(atmel_nand_init);
module_exit(atmel_nand_exit);
A
Andrew Victor 已提交
720 721 722

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Rick Bronson");
723
MODULE_DESCRIPTION("NAND/SmartMedia driver for AT91 / AVR32");
724
MODULE_ALIAS("platform:atmel_nand");