au1550nd.c 12.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12
/*
 *  drivers/mtd/nand/au1550nd.c
 *
 *  Copyright (C) 2004 Embedded Edge, LLC
 *
 * 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.
 *
 */

#include <linux/slab.h>
13
#include <linux/gpio.h>
L
Linus Torvalds 已提交
14 15
#include <linux/init.h>
#include <linux/module.h>
16
#include <linux/interrupt.h>
L
Linus Torvalds 已提交
17 18 19
#include <linux/mtd/mtd.h>
#include <linux/mtd/nand.h>
#include <linux/mtd/partitions.h>
20
#include <linux/platform_device.h>
L
Linus Torvalds 已提交
21
#include <asm/io.h>
22 23
#include <asm/mach-au1x00/au1000.h>
#include <asm/mach-au1x00/au1550nd.h>
L
Linus Torvalds 已提交
24 25


26 27 28
struct au1550nd_ctx {
	struct mtd_info info;
	struct nand_chip chip;
L
Linus Torvalds 已提交
29

30 31 32
	int cs;
	void __iomem *base;
	void (*write_byte)(struct mtd_info *, u_char);
L
Linus Torvalds 已提交
33 34 35 36 37 38
};

/**
 * au_read_byte -  read one byte from the chip
 * @mtd:	MTD device structure
 *
39
 * read function for 8bit buswidth
L
Linus Torvalds 已提交
40 41 42 43 44 45 46 47 48 49 50 51 52 53
 */
static u_char au_read_byte(struct mtd_info *mtd)
{
	struct nand_chip *this = mtd->priv;
	u_char ret = readb(this->IO_ADDR_R);
	au_sync();
	return ret;
}

/**
 * au_write_byte -  write one byte to the chip
 * @mtd:	MTD device structure
 * @byte:	pointer to data byte to write
 *
54
 * write function for 8it buswidth
L
Linus Torvalds 已提交
55 56 57 58 59 60 61 62 63
 */
static void au_write_byte(struct mtd_info *mtd, u_char byte)
{
	struct nand_chip *this = mtd->priv;
	writeb(byte, this->IO_ADDR_W);
	au_sync();
}

/**
64
 * au_read_byte16 -  read one byte endianness aware from the chip
L
Linus Torvalds 已提交
65 66
 * @mtd:	MTD device structure
 *
67
 * read function for 16bit buswidth with endianness conversion
L
Linus Torvalds 已提交
68 69 70 71 72 73 74 75 76 77
 */
static u_char au_read_byte16(struct mtd_info *mtd)
{
	struct nand_chip *this = mtd->priv;
	u_char ret = (u_char) cpu_to_le16(readw(this->IO_ADDR_R));
	au_sync();
	return ret;
}

/**
78
 * au_write_byte16 -  write one byte endianness aware to the chip
L
Linus Torvalds 已提交
79 80 81
 * @mtd:	MTD device structure
 * @byte:	pointer to data byte to write
 *
82
 * write function for 16bit buswidth with endianness conversion
L
Linus Torvalds 已提交
83 84 85 86 87 88 89 90 91 92 93 94
 */
static void au_write_byte16(struct mtd_info *mtd, u_char byte)
{
	struct nand_chip *this = mtd->priv;
	writew(le16_to_cpu((u16) byte), this->IO_ADDR_W);
	au_sync();
}

/**
 * au_read_word -  read one word from the chip
 * @mtd:	MTD device structure
 *
95
 * read function for 16bit buswidth without endianness conversion
L
Linus Torvalds 已提交
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
 */
static u16 au_read_word(struct mtd_info *mtd)
{
	struct nand_chip *this = mtd->priv;
	u16 ret = readw(this->IO_ADDR_R);
	au_sync();
	return ret;
}

/**
 * au_write_buf -  write buffer to chip
 * @mtd:	MTD device structure
 * @buf:	data buffer
 * @len:	number of bytes to write
 *
111
 * write function for 8bit buswidth
L
Linus Torvalds 已提交
112 113 114 115 116 117
 */
static void au_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
{
	int i;
	struct nand_chip *this = mtd->priv;

118
	for (i = 0; i < len; i++) {
L
Linus Torvalds 已提交
119 120 121 122 123 124
		writeb(buf[i], this->IO_ADDR_W);
		au_sync();
	}
}

/**
125
 * au_read_buf -  read chip data into buffer
L
Linus Torvalds 已提交
126 127 128 129
 * @mtd:	MTD device structure
 * @buf:	buffer to store date
 * @len:	number of bytes to read
 *
130
 * read function for 8bit buswidth
L
Linus Torvalds 已提交
131 132 133 134 135 136
 */
static void au_read_buf(struct mtd_info *mtd, u_char *buf, int len)
{
	int i;
	struct nand_chip *this = mtd->priv;

137
	for (i = 0; i < len; i++) {
L
Linus Torvalds 已提交
138
		buf[i] = readb(this->IO_ADDR_R);
139
		au_sync();
L
Linus Torvalds 已提交
140 141 142 143 144 145 146 147 148
	}
}

/**
 * au_write_buf16 -  write buffer to chip
 * @mtd:	MTD device structure
 * @buf:	data buffer
 * @len:	number of bytes to write
 *
149
 * write function for 16bit buswidth
L
Linus Torvalds 已提交
150 151 152 153 154 155 156
 */
static void au_write_buf16(struct mtd_info *mtd, const u_char *buf, int len)
{
	int i;
	struct nand_chip *this = mtd->priv;
	u16 *p = (u16 *) buf;
	len >>= 1;
157

158
	for (i = 0; i < len; i++) {
L
Linus Torvalds 已提交
159 160 161
		writew(p[i], this->IO_ADDR_W);
		au_sync();
	}
162

L
Linus Torvalds 已提交
163 164 165
}

/**
166
 * au_read_buf16 -  read chip data into buffer
L
Linus Torvalds 已提交
167 168 169 170
 * @mtd:	MTD device structure
 * @buf:	buffer to store date
 * @len:	number of bytes to read
 *
171
 * read function for 16bit buswidth
L
Linus Torvalds 已提交
172 173 174 175 176 177 178 179
 */
static void au_read_buf16(struct mtd_info *mtd, u_char *buf, int len)
{
	int i;
	struct nand_chip *this = mtd->priv;
	u16 *p = (u16 *) buf;
	len >>= 1;

180
	for (i = 0; i < len; i++) {
L
Linus Torvalds 已提交
181 182 183 184 185
		p[i] = readw(this->IO_ADDR_R);
		au_sync();
	}
}

186 187 188 189 190 191 192 193 194 195 196 197
/* Select the chip by setting nCE to low */
#define NAND_CTL_SETNCE		1
/* Deselect the chip by setting nCE to high */
#define NAND_CTL_CLRNCE		2
/* Select the command latch by setting CLE to high */
#define NAND_CTL_SETCLE		3
/* Deselect the command latch by setting CLE to low */
#define NAND_CTL_CLRCLE		4
/* Select the address latch by setting ALE to high */
#define NAND_CTL_SETALE		5
/* Deselect the address latch by setting ALE to low */
#define NAND_CTL_CLRALE		6
L
Linus Torvalds 已提交
198 199 200

static void au1550_hwcontrol(struct mtd_info *mtd, int cmd)
{
201 202
	struct au1550nd_ctx *ctx = container_of(mtd, struct au1550nd_ctx, info);
	struct nand_chip *this = mtd->priv;
L
Linus Torvalds 已提交
203

204 205 206
	switch (cmd) {

	case NAND_CTL_SETCLE:
207
		this->IO_ADDR_W = ctx->base + MEM_STNAND_CMD;
208 209 210
		break;

	case NAND_CTL_CLRCLE:
211
		this->IO_ADDR_W = ctx->base + MEM_STNAND_DATA;
212
		break;
L
Linus Torvalds 已提交
213

214
	case NAND_CTL_SETALE:
215
		this->IO_ADDR_W = ctx->base + MEM_STNAND_ADDR;
216
		break;
L
Linus Torvalds 已提交
217

218
	case NAND_CTL_CLRALE:
219
		this->IO_ADDR_W = ctx->base + MEM_STNAND_DATA;
220
		/* FIXME: Nobody knows why this is necessary,
L
Linus Torvalds 已提交
221
		 * but it works only that way */
222
		udelay(1);
L
Linus Torvalds 已提交
223 224
		break;

225
	case NAND_CTL_SETNCE:
L
Linus Torvalds 已提交
226
		/* assert (force assert) chip enable */
227
		au_writel((1 << (4 + ctx->cs)), MEM_STNDCTL);
L
Linus Torvalds 已提交
228 229
		break;

230
	case NAND_CTL_CLRNCE:
231 232
		/* deassert chip enable */
		au_writel(0, MEM_STNDCTL);
L
Linus Torvalds 已提交
233 234 235 236
		break;
	}

	this->IO_ADDR_R = this->IO_ADDR_W;
237

L
Linus Torvalds 已提交
238 239 240 241 242 243 244 245 246 247 248
	/* Drain the writebuffer */
	au_sync();
}

int au1550_device_ready(struct mtd_info *mtd)
{
	int ret = (au_readl(MEM_STSTAT) & 0x1) ? 1 : 0;
	au_sync();
	return ret;
}

249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
/**
 * au1550_select_chip - control -CE line
 *	Forbid driving -CE manually permitting the NAND controller to do this.
 *	Keeping -CE asserted during the whole sector reads interferes with the
 *	NOR flash and PCMCIA drivers as it causes contention on the static bus.
 *	We only have to hold -CE low for the NAND read commands since the flash
 *	chip needs it to be asserted during chip not ready time but the NAND
 *	controller keeps it released.
 *
 * @mtd:	MTD device structure
 * @chip:	chipnumber to select, -1 for deselect
 */
static void au1550_select_chip(struct mtd_info *mtd, int chip)
{
}

/**
 * au1550_command - Send command to NAND device
 * @mtd:	MTD device structure
 * @command:	the command to be sent
 * @column:	the column address for this command, -1 if none
 * @page_addr:	the page address for this command, -1 if none
 */
static void au1550_command(struct mtd_info *mtd, unsigned command, int column, int page_addr)
{
274 275
	struct au1550nd_ctx *ctx = container_of(mtd, struct au1550nd_ctx, info);
	struct nand_chip *this = mtd->priv;
276
	int ce_override = 0, i;
277
	unsigned long flags = 0;
278 279

	/* Begin command latch cycle */
280
	au1550_hwcontrol(mtd, NAND_CTL_SETCLE);
281 282 283 284 285 286
	/*
	 * Write out the command to the device.
	 */
	if (command == NAND_CMD_SEQIN) {
		int readcmd;

J
Joern Engel 已提交
287
		if (column >= mtd->writesize) {
288
			/* OOB area */
J
Joern Engel 已提交
289
			column -= mtd->writesize;
290 291 292 293 294 295 296 297
			readcmd = NAND_CMD_READOOB;
		} else if (column < 256) {
			/* First 256 bytes --> READ0 */
			readcmd = NAND_CMD_READ0;
		} else {
			column -= 256;
			readcmd = NAND_CMD_READ1;
		}
298
		ctx->write_byte(mtd, readcmd);
299
	}
300
	ctx->write_byte(mtd, command);
301 302

	/* Set ALE and clear CLE to start address cycle */
303
	au1550_hwcontrol(mtd, NAND_CTL_CLRCLE);
304 305

	if (column != -1 || page_addr != -1) {
306
		au1550_hwcontrol(mtd, NAND_CTL_SETALE);
307 308 309 310 311 312

		/* Serially input address */
		if (column != -1) {
			/* Adjust columns for 16 bit buswidth */
			if (this->options & NAND_BUSWIDTH_16)
				column >>= 1;
313
			ctx->write_byte(mtd, column);
314 315
		}
		if (page_addr != -1) {
316
			ctx->write_byte(mtd, (u8)(page_addr & 0xff));
317 318 319 320 321 322 323 324 325 326 327 328 329 330

			if (command == NAND_CMD_READ0 ||
			    command == NAND_CMD_READ1 ||
			    command == NAND_CMD_READOOB) {
				/*
				 * NAND controller will release -CE after
				 * the last address byte is written, so we'll
				 * have to forcibly assert it. No interrupts
				 * are allowed while we do this as we don't
				 * want the NOR flash or PCMCIA drivers to
				 * steal our precious bytes of data...
				 */
				ce_override = 1;
				local_irq_save(flags);
331
				au1550_hwcontrol(mtd, NAND_CTL_SETNCE);
332 333
			}

334
			ctx->write_byte(mtd, (u8)(page_addr >> 8));
335 336 337

			/* One more address cycle for devices > 32MiB */
			if (this->chipsize > (32 << 20))
338 339
				ctx->write_byte(mtd,
						((page_addr >> 16) & 0x0f));
340 341
		}
		/* Latch in address */
342
		au1550_hwcontrol(mtd, NAND_CTL_CLRALE);
343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
	}

	/*
	 * Program and erase have their own busy handlers.
	 * Status and sequential in need no delay.
	 */
	switch (command) {

	case NAND_CMD_PAGEPROG:
	case NAND_CMD_ERASE1:
	case NAND_CMD_ERASE2:
	case NAND_CMD_SEQIN:
	case NAND_CMD_STATUS:
		return;

	case NAND_CMD_RESET:
		break;

	case NAND_CMD_READ0:
	case NAND_CMD_READ1:
	case NAND_CMD_READOOB:
		/* Check if we're really driving -CE low (just in case) */
		if (unlikely(!ce_override))
			break;

		/* Apply a short delay always to ensure that we do wait tWB. */
		ndelay(100);
		/* Wait for a chip to become ready... */
		for (i = this->chip_delay; !this->dev_ready(mtd) && i > 0; --i)
			udelay(1);

		/* Release -CE and re-enable interrupts. */
375
		au1550_hwcontrol(mtd, NAND_CTL_CLRNCE);
376 377 378 379 380 381 382 383 384
		local_irq_restore(flags);
		return;
	}
	/* Apply this short delay always to ensure that we do wait tWB. */
	ndelay(100);

	while(!this->dev_ready(mtd));
}

B
Bill Pemberton 已提交
385
static int find_nand_cs(unsigned long nand_base)
L
Linus Torvalds 已提交
386
{
387 388 389 390
	void __iomem *base =
			(void __iomem *)KSEG1ADDR(AU1000_STATIC_MEM_PHYS_ADDR);
	unsigned long addr, staddr, start, mask, end;
	int i;
391

392 393 394 395 396 397 398 399 400 401
	for (i = 0; i < 4; i++) {
		addr = 0x1000 + (i * 0x10);			/* CSx */
		staddr = __raw_readl(base + addr + 0x08);	/* STADDRx */
		/* figure out the decoded range of this CS */
		start = (staddr << 4) & 0xfffc0000;
		mask = (staddr << 18) & 0xfffc0000;
		end = (start | (start - 1)) & ~(start ^ mask);
		if ((nand_base >= start) && (nand_base < end))
			return i;
	}
L
Linus Torvalds 已提交
402

403 404
	return -ENODEV;
}
L
Linus Torvalds 已提交
405

B
Bill Pemberton 已提交
406
static int au1550nd_probe(struct platform_device *pdev)
407 408 409 410 411 412
{
	struct au1550nd_platdata *pd;
	struct au1550nd_ctx *ctx;
	struct nand_chip *this;
	struct resource *r;
	int ret, cs;
413

J
Jingoo Han 已提交
414
	pd = dev_get_platdata(&pdev->dev);
415 416 417
	if (!pd) {
		dev_err(&pdev->dev, "missing platform data\n");
		return -ENODEV;
L
Linus Torvalds 已提交
418
	}
419 420 421 422 423

	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
	if (!ctx) {
		dev_err(&pdev->dev, "no memory for NAND context\n");
		return -ENOMEM;
424
	}
425 426 427 428 429 430

	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!r) {
		dev_err(&pdev->dev, "no NAND memory resource\n");
		ret = -ENODEV;
		goto out1;
431
	}
432 433 434 435
	if (request_mem_region(r->start, resource_size(r), "au1550-nand")) {
		dev_err(&pdev->dev, "cannot claim NAND memory area\n");
		ret = -ENOMEM;
		goto out1;
436
	}
437 438 439 440 441 442

	ctx->base = ioremap_nocache(r->start, 0x1000);
	if (!ctx->base) {
		dev_err(&pdev->dev, "cannot remap NAND memory area\n");
		ret = -ENODEV;
		goto out2;
443
	}
L
Linus Torvalds 已提交
444

445 446 447
	this = &ctx->chip;
	ctx->info.priv = this;
	ctx->info.owner = THIS_MODULE;
448

449 450 451 452 453 454 455 456
	/* figure out which CS# r->start belongs to */
	cs = find_nand_cs(r->start);
	if (cs < 0) {
		dev_err(&pdev->dev, "cannot detect NAND chipselect\n");
		ret = -ENODEV;
		goto out3;
	}
	ctx->cs = cs;
L
Linus Torvalds 已提交
457 458

	this->dev_ready = au1550_device_ready;
459 460 461
	this->select_chip = au1550_select_chip;
	this->cmdfunc = au1550_command;

L
Linus Torvalds 已提交
462
	/* 30 us command delay time */
463
	this->chip_delay = 30;
T
Thomas Gleixner 已提交
464
	this->ecc.mode = NAND_ECC_SOFT;
L
Linus Torvalds 已提交
465

466
	if (pd->devwidth)
L
Linus Torvalds 已提交
467 468
		this->options |= NAND_BUSWIDTH_16;

469 470
	this->read_byte = (pd->devwidth) ? au_read_byte16 : au_read_byte;
	ctx->write_byte = (pd->devwidth) ? au_write_byte16 : au_write_byte;
L
Linus Torvalds 已提交
471
	this->read_word = au_read_word;
472 473 474 475 476 477 478
	this->write_buf = (pd->devwidth) ? au_write_buf16 : au_write_buf;
	this->read_buf = (pd->devwidth) ? au_read_buf16 : au_read_buf;

	ret = nand_scan(&ctx->info, 1);
	if (ret) {
		dev_err(&pdev->dev, "NAND scan failed with %d\n", ret);
		goto out3;
L
Linus Torvalds 已提交
479 480
	}

481
	mtd_device_register(&ctx->info, pd->parts, pd->num_parts);
L
Linus Torvalds 已提交
482 483 484

	return 0;

485 486 487 488 489 490 491
out3:
	iounmap(ctx->base);
out2:
	release_mem_region(r->start, resource_size(r));
out1:
	kfree(ctx);
	return ret;
L
Linus Torvalds 已提交
492 493
}

B
Bill Pemberton 已提交
494
static int au1550nd_remove(struct platform_device *pdev)
L
Linus Torvalds 已提交
495
{
496 497
	struct au1550nd_ctx *ctx = platform_get_drvdata(pdev);
	struct resource *r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
L
Linus Torvalds 已提交
498

499 500 501 502 503
	nand_release(&ctx->info);
	iounmap(ctx->base);
	release_mem_region(r->start, 0x1000);
	kfree(ctx);
	return 0;
L
Linus Torvalds 已提交
504
}
505

506 507 508 509 510 511
static struct platform_driver au1550nd_driver = {
	.driver = {
		.name	= "au1550-nand",
		.owner	= THIS_MODULE,
	},
	.probe		= au1550nd_probe,
B
Bill Pemberton 已提交
512
	.remove		= au1550nd_remove,
513 514 515
};

module_platform_driver(au1550nd_driver);
L
Linus Torvalds 已提交
516 517 518 519

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Embedded Edge, LLC");
MODULE_DESCRIPTION("Board-specific glue layer for NAND flash on Pb1550 board");