m25p80.c 19.9 KB
Newer Older
1
/*
2
 * MTD SPI driver for ST M25Pxx (and similar) serial flash chips
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
 *
 * Author: Mike Lavender, mike@steroidmicros.com
 *
 * Copyright (c) 2005, Intec Automation Inc.
 *
 * Some parts are based on lart.c by Abraham Van Der Merwe
 *
 * Cleaned up and generalized based on mtd_dataflash.c
 *
 * This code 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/init.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/interrupt.h>
D
David Brownell 已提交
22
#include <linux/mutex.h>
23
#include <linux/math64.h>
D
David Brownell 已提交
24

25 26
#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
D
David Brownell 已提交
27

28 29 30 31 32 33 34
#include <linux/spi/spi.h>
#include <linux/spi/flash.h>


#define FLASH_PAGESIZE		256

/* Flash opcodes. */
35 36
#define	OPCODE_WREN		0x06	/* Write enable */
#define	OPCODE_RDSR		0x05	/* Read status register */
37
#define	OPCODE_WRSR		0x01	/* Write status register 1 byte */
38
#define	OPCODE_NORM_READ	0x03	/* Read data bytes (low frequency) */
39 40
#define	OPCODE_FAST_READ	0x0b	/* Read data bytes (high frequency) */
#define	OPCODE_PP		0x02	/* Page program (up to 256 bytes) */
41
#define	OPCODE_BE_4K		0x20	/* Erase 4KiB block */
42
#define	OPCODE_BE_32K		0x52	/* Erase 32KiB block */
43
#define	OPCODE_CHIP_ERASE	0xc7	/* Erase whole flash chip */
44
#define	OPCODE_SE		0xd8	/* Sector erase (usually 64KiB) */
45 46 47 48 49
#define	OPCODE_RDID		0x9f	/* Read JEDEC ID */

/* Status Register bits. */
#define	SR_WIP			1	/* Write in progress */
#define	SR_WEL			2	/* Write enable latch */
50
/* meaning of other SR_* bits may differ between vendors */
51 52 53 54 55 56
#define	SR_BP0			4	/* Block protect 0 */
#define	SR_BP1			8	/* Block protect 1 */
#define	SR_BP2			0x10	/* Block protect 2 */
#define	SR_SRWD			0x80	/* SR write protect */

/* Define max times to check status register before we give up. */
57
#define	MAX_READY_WAIT_JIFFIES	(40 * HZ)	/* M25P16 specs 40s max chip erase */
58
#define	CMD_SIZE		4
59

60 61 62 63 64 65 66
#ifdef CONFIG_M25PXX_USE_FAST_READ
#define OPCODE_READ 	OPCODE_FAST_READ
#define FAST_READ_DUMMY_BYTE 1
#else
#define OPCODE_READ 	OPCODE_NORM_READ
#define FAST_READ_DUMMY_BYTE 0
#endif
67 68 69 70 71

/****************************************************************************/

struct m25p {
	struct spi_device	*spi;
D
David Brownell 已提交
72
	struct mutex		lock;
73
	struct mtd_info		mtd;
74 75
	unsigned		partitioned:1;
	u8			erase_opcode;
76
	u8			command[CMD_SIZE + FAST_READ_DUMMY_BYTE];
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
};

static inline struct m25p *mtd_to_m25p(struct mtd_info *mtd)
{
	return container_of(mtd, struct m25p, mtd);
}

/****************************************************************************/

/*
 * Internal helper functions
 */

/*
 * Read the status register, returning its value in the location
 * Return the status register value.
 * Returns negative if error occurred.
 */
static int read_sr(struct m25p *flash)
{
	ssize_t retval;
	u8 code = OPCODE_RDSR;
	u8 val;

	retval = spi_write_then_read(flash->spi, &code, 1, &val, 1);

	if (retval < 0) {
		dev_err(&flash->spi->dev, "error %d reading SR\n",
				(int) retval);
		return retval;
	}

	return val;
}

112 113 114 115 116 117 118 119 120 121 122
/*
 * Write status register 1 byte
 * Returns negative if error occurred.
 */
static int write_sr(struct m25p *flash, u8 val)
{
	flash->command[0] = OPCODE_WRSR;
	flash->command[1] = val;

	return spi_write(flash->spi, flash->command, 2);
}
123 124 125 126 127 128 129 130 131

/*
 * Set write enable latch with Write Enable command.
 * Returns negative if error occurred.
 */
static inline int write_enable(struct m25p *flash)
{
	u8	code = OPCODE_WREN;

132
	return spi_write_then_read(flash->spi, &code, 1, NULL, 0);
133 134 135 136 137 138 139 140 141
}


/*
 * Service routine to read status register until ready, or timeout occurs.
 * Returns non-zero if error.
 */
static int wait_till_ready(struct m25p *flash)
{
P
Peter Horton 已提交
142
	unsigned long deadline;
143 144
	int sr;

P
Peter Horton 已提交
145 146 147
	deadline = jiffies + MAX_READY_WAIT_JIFFIES;

	do {
148 149 150 151 152
		if ((sr = read_sr(flash)) < 0)
			break;
		else if (!(sr & SR_WIP))
			return 0;

P
Peter Horton 已提交
153 154 155
		cond_resched();

	} while (!time_after_eq(jiffies, deadline));
156 157 158 159

	return 1;
}

C
Chen Gong 已提交
160 161 162 163 164
/*
 * Erase the whole flash memory
 *
 * Returns 0 if successful, non-zero otherwise.
 */
165
static int erase_chip(struct m25p *flash)
C
Chen Gong 已提交
166
{
167
	DEBUG(MTD_DEBUG_LEVEL3, "%s: %s %lldKiB\n",
168 169
	      dev_name(&flash->spi->dev), __func__,
	      (long long)(flash->mtd.size >> 10));
C
Chen Gong 已提交
170 171 172 173 174 175 176 177 178

	/* Wait until finished previous write command. */
	if (wait_till_ready(flash))
		return 1;

	/* Send write enable, then erase commands. */
	write_enable(flash);

	/* Set up command buffer. */
179
	flash->command[0] = OPCODE_CHIP_ERASE;
C
Chen Gong 已提交
180 181 182 183 184

	spi_write(flash->spi, flash->command, 1);

	return 0;
}
185 186 187 188 189 190 191 192 193

/*
 * Erase one sector of flash memory at offset ``offset'' which is any
 * address within the sector which should be erased.
 *
 * Returns 0 if successful, non-zero otherwise.
 */
static int erase_sector(struct m25p *flash, u32 offset)
{
194
	DEBUG(MTD_DEBUG_LEVEL3, "%s: %s %dKiB at 0x%08x\n",
195
			dev_name(&flash->spi->dev), __func__,
196
			flash->mtd.erasesize / 1024, offset);
197 198 199 200 201 202 203 204 205

	/* Wait until finished previous write command. */
	if (wait_till_ready(flash))
		return 1;

	/* Send write enable, then erase commands. */
	write_enable(flash);

	/* Set up command buffer. */
206
	flash->command[0] = flash->erase_opcode;
207 208 209 210
	flash->command[1] = offset >> 16;
	flash->command[2] = offset >> 8;
	flash->command[3] = offset;

211
	spi_write(flash->spi, flash->command, CMD_SIZE);
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229

	return 0;
}

/****************************************************************************/

/*
 * MTD implementation
 */

/*
 * Erase an address range on the flash chip.  The address range may extend
 * one or more erase sectors.  Return an error is there is a problem erasing.
 */
static int m25p80_erase(struct mtd_info *mtd, struct erase_info *instr)
{
	struct m25p *flash = mtd_to_m25p(mtd);
	u32 addr,len;
230
	uint32_t rem;
231

232
	DEBUG(MTD_DEBUG_LEVEL2, "%s: %s %s 0x%llx, len %lld\n",
233 234
	      dev_name(&flash->spi->dev), __func__, "at",
	      (long long)instr->addr, (long long)instr->len);
235 236 237 238

	/* sanity checks */
	if (instr->addr + instr->len > flash->mtd.size)
		return -EINVAL;
239 240
	div_u64_rem(instr->len, mtd->erasesize, &rem);
	if (rem)
241 242 243 244 245
		return -EINVAL;

	addr = instr->addr;
	len = instr->len;

D
David Brownell 已提交
246
	mutex_lock(&flash->lock);
247

248
	/* whole-chip erase? */
249 250 251 252 253 254
	if (len == flash->mtd.size) {
		if (erase_chip(flash)) {
			instr->state = MTD_ERASE_FAILED;
			mutex_unlock(&flash->lock);
			return -EIO;
		}
255 256 257 258 259 260 261

	/* REVISIT in some cases we could speed up erasing large regions
	 * by using OPCODE_SE instead of OPCODE_BE_4K.  We may have set up
	 * to use "small sector erase", but that's not always optimal.
	 */

	/* "sector"-at-a-time erase */
C
Chen Gong 已提交
262 263 264 265 266 267 268 269 270 271
	} else {
		while (len) {
			if (erase_sector(flash, addr)) {
				instr->state = MTD_ERASE_FAILED;
				mutex_unlock(&flash->lock);
				return -EIO;
			}

			addr += mtd->erasesize;
			len -= mtd->erasesize;
272 273 274
		}
	}

D
David Brownell 已提交
275
	mutex_unlock(&flash->lock);
276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294

	instr->state = MTD_ERASE_DONE;
	mtd_erase_callback(instr);

	return 0;
}

/*
 * Read an address range from the flash chip.  The address range
 * may be any size provided it is within the physical boundaries.
 */
static int m25p80_read(struct mtd_info *mtd, loff_t from, size_t len,
	size_t *retlen, u_char *buf)
{
	struct m25p *flash = mtd_to_m25p(mtd);
	struct spi_transfer t[2];
	struct spi_message m;

	DEBUG(MTD_DEBUG_LEVEL2, "%s: %s %s 0x%08x, len %zd\n",
295
			dev_name(&flash->spi->dev), __func__, "from",
296 297 298 299 300 301 302 303 304
			(u32)from, len);

	/* sanity checks */
	if (!len)
		return 0;

	if (from + len > flash->mtd.size)
		return -EINVAL;

305 306 307
	spi_message_init(&m);
	memset(t, 0, (sizeof t));

308 309 310 311
	/* NOTE:
	 * OPCODE_FAST_READ (if available) is faster.
	 * Should add 1 byte DUMMY_BYTE.
	 */
312
	t[0].tx_buf = flash->command;
313
	t[0].len = CMD_SIZE + FAST_READ_DUMMY_BYTE;
314 315 316 317 318 319 320 321 322 323
	spi_message_add_tail(&t[0], &m);

	t[1].rx_buf = buf;
	t[1].len = len;
	spi_message_add_tail(&t[1], &m);

	/* Byte count starts at zero. */
	if (retlen)
		*retlen = 0;

D
David Brownell 已提交
324
	mutex_lock(&flash->lock);
325 326 327 328

	/* Wait till previous write/erase is done. */
	if (wait_till_ready(flash)) {
		/* REVISIT status return?? */
D
David Brownell 已提交
329
		mutex_unlock(&flash->lock);
330 331 332
		return 1;
	}

333 334 335 336
	/* FIXME switch to OPCODE_FAST_READ.  It's required for higher
	 * clocks; and at this writing, every chip this driver handles
	 * supports that opcode.
	 */
337 338 339 340 341 342 343 344 345

	/* Set up the write data buffer. */
	flash->command[0] = OPCODE_READ;
	flash->command[1] = from >> 16;
	flash->command[2] = from >> 8;
	flash->command[3] = from;

	spi_sync(flash->spi, &m);

346
	*retlen = m.actual_length - CMD_SIZE - FAST_READ_DUMMY_BYTE;
347

D
David Brownell 已提交
348
	mutex_unlock(&flash->lock);
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366

	return 0;
}

/*
 * Write an address range to the flash chip.  Data must be written in
 * FLASH_PAGESIZE chunks.  The address range may be any size provided
 * it is within the physical boundaries.
 */
static int m25p80_write(struct mtd_info *mtd, loff_t to, size_t len,
	size_t *retlen, const u_char *buf)
{
	struct m25p *flash = mtd_to_m25p(mtd);
	u32 page_offset, page_size;
	struct spi_transfer t[2];
	struct spi_message m;

	DEBUG(MTD_DEBUG_LEVEL2, "%s: %s %s 0x%08x, len %zd\n",
367
			dev_name(&flash->spi->dev), __func__, "to",
368 369 370 371 372 373 374 375 376 377 378 379
			(u32)to, len);

	if (retlen)
		*retlen = 0;

	/* sanity checks */
	if (!len)
		return(0);

	if (to + len > flash->mtd.size)
		return -EINVAL;

380 381 382 383
	spi_message_init(&m);
	memset(t, 0, (sizeof t));

	t[0].tx_buf = flash->command;
384
	t[0].len = CMD_SIZE;
385 386 387 388 389
	spi_message_add_tail(&t[0], &m);

	t[1].tx_buf = buf;
	spi_message_add_tail(&t[1], &m);

D
David Brownell 已提交
390
	mutex_lock(&flash->lock);
391 392

	/* Wait until finished previous write command. */
C
Chen Gong 已提交
393 394
	if (wait_till_ready(flash)) {
		mutex_unlock(&flash->lock);
395
		return 1;
C
Chen Gong 已提交
396
	}
397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414

	write_enable(flash);

	/* Set up the opcode in the write buffer. */
	flash->command[0] = OPCODE_PP;
	flash->command[1] = to >> 16;
	flash->command[2] = to >> 8;
	flash->command[3] = to;

	/* what page do we start with? */
	page_offset = to % FLASH_PAGESIZE;

	/* do all the bytes fit onto one page? */
	if (page_offset + len <= FLASH_PAGESIZE) {
		t[1].len = len;

		spi_sync(flash->spi, &m);

415
		*retlen = m.actual_length - CMD_SIZE;
416 417 418 419 420 421 422 423 424
	} else {
		u32 i;

		/* the size of data remaining on the first page */
		page_size = FLASH_PAGESIZE - page_offset;

		t[1].len = page_size;
		spi_sync(flash->spi, &m);

425
		*retlen = m.actual_length - CMD_SIZE;
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446

		/* write everything in PAGESIZE chunks */
		for (i = page_size; i < len; i += page_size) {
			page_size = len - i;
			if (page_size > FLASH_PAGESIZE)
				page_size = FLASH_PAGESIZE;

			/* write the next page to flash */
			flash->command[1] = (to + i) >> 16;
			flash->command[2] = (to + i) >> 8;
			flash->command[3] = (to + i);

			t[1].tx_buf = buf + i;
			t[1].len = page_size;

			wait_till_ready(flash);

			write_enable(flash);

			spi_sync(flash->spi, &m);

D
David Brownell 已提交
447
			if (retlen)
448
				*retlen += m.actual_length - CMD_SIZE;
D
David Brownell 已提交
449 450
		}
	}
451

D
David Brownell 已提交
452
	mutex_unlock(&flash->lock);
453 454 455 456 457 458 459 460 461 462 463 464 465

	return 0;
}


/****************************************************************************/

/*
 * SPI device driver setup and teardown
 */

struct flash_info {
	char		*name;
466 467 468 469 470 471

	/* JEDEC id zero means "no ID" (most older chips); otherwise it has
	 * a high byte of zero plus three data bytes: the manufacturer id,
	 * then a two byte device id.
	 */
	u32		jedec_id;
472
	u16             ext_id;
473 474 475 476

	/* The size listed here is what works with OPCODE_SE, which isn't
	 * necessarily called a "sector" by the vendor.
	 */
477
	unsigned	sector_size;
478 479 480 481
	u16		n_sectors;

	u16		flags;
#define	SECT_4K		0x01		/* OPCODE_BE_4K works uniformly */
482 483
};

484 485 486 487 488

/* NOTE: double check command sets and memory organization when you add
 * more flash chips.  This current list focusses on newer chips, which
 * have been converging on command sets which including JEDEC ID.
 */
489
static struct flash_info __devinitdata m25p_data [] = {
490 491

	/* Atmel -- some are (confusingly) marketed as "DataFlash" */
492 493
	{ "at25fs010",  0x1f6601, 0, 32 * 1024, 4, SECT_4K, },
	{ "at25fs040",  0x1f6604, 0, 64 * 1024, 8, SECT_4K, },
494

495 496
	{ "at25df041a", 0x1f4401, 0, 64 * 1024, 8, SECT_4K, },
	{ "at25df641",  0x1f4800, 0, 64 * 1024, 128, SECT_4K, },
497

498 499 500 501
	{ "at26f004",   0x1f0400, 0, 64 * 1024, 8, SECT_4K, },
	{ "at26df081a", 0x1f4501, 0, 64 * 1024, 16, SECT_4K, },
	{ "at26df161a", 0x1f4601, 0, 64 * 1024, 32, SECT_4K, },
	{ "at26df321",  0x1f4701, 0, 64 * 1024, 64, SECT_4K, },
502

503 504 505
	/* Macronix */
	{ "mx25l12805d", 0xc22018, 0, 64 * 1024, 256, },

506 507 508
	/* Spansion -- single (large) sector size only, at least
	 * for the chips listed here (without boot sectors).
	 */
509 510 511 512 513 514 515
	{ "s25sl004a", 0x010212, 0, 64 * 1024, 8, },
	{ "s25sl008a", 0x010213, 0, 64 * 1024, 16, },
	{ "s25sl016a", 0x010214, 0, 64 * 1024, 32, },
	{ "s25sl032a", 0x010215, 0, 64 * 1024, 64, },
	{ "s25sl064a", 0x010216, 0, 64 * 1024, 128, },
        { "s25sl12800", 0x012018, 0x0300, 256 * 1024, 64, },
	{ "s25sl12801", 0x012018, 0x0301, 64 * 1024, 256, },
516 517

	/* SST -- large erase sizes are "overlays", "sectors" are 4K */
518 519 520 521
	{ "sst25vf040b", 0xbf258d, 0, 64 * 1024, 8, SECT_4K, },
	{ "sst25vf080b", 0xbf258e, 0, 64 * 1024, 16, SECT_4K, },
	{ "sst25vf016b", 0xbf2541, 0, 64 * 1024, 32, SECT_4K, },
	{ "sst25vf032b", 0xbf254a, 0, 64 * 1024, 64, SECT_4K, },
522 523

	/* ST Microelectronics -- newer production may have feature updates */
524 525 526 527 528 529 530 531 532 533
	{ "m25p05",  0x202010,  0, 32 * 1024, 2, },
	{ "m25p10",  0x202011,  0, 32 * 1024, 4, },
	{ "m25p20",  0x202012,  0, 64 * 1024, 4, },
	{ "m25p40",  0x202013,  0, 64 * 1024, 8, },
	{ "m25p80",         0,  0, 64 * 1024, 16, },
	{ "m25p16",  0x202015,  0, 64 * 1024, 32, },
	{ "m25p32",  0x202016,  0, 64 * 1024, 64, },
	{ "m25p64",  0x202017,  0, 64 * 1024, 128, },
	{ "m25p128", 0x202018, 0, 256 * 1024, 64, },

534
	{ "m45pe10", 0x204011,  0, 64 * 1024, 2, },
535 536 537 538 539
	{ "m45pe80", 0x204014,  0, 64 * 1024, 16, },
	{ "m45pe16", 0x204015,  0, 64 * 1024, 32, },

	{ "m25pe80", 0x208014,  0, 64 * 1024, 16, },
	{ "m25pe16", 0x208015,  0, 64 * 1024, 32, SECT_4K, },
540

541
	/* Winbond -- w25x "blocks" are 64K, "sectors" are 4KiB */
542 543 544 545 546 547 548
	{ "w25x10", 0xef3011, 0, 64 * 1024, 2, SECT_4K, },
	{ "w25x20", 0xef3012, 0, 64 * 1024, 4, SECT_4K, },
	{ "w25x40", 0xef3013, 0, 64 * 1024, 8, SECT_4K, },
	{ "w25x80", 0xef3014, 0, 64 * 1024, 16, SECT_4K, },
	{ "w25x16", 0xef3015, 0, 64 * 1024, 32, SECT_4K, },
	{ "w25x32", 0xef3016, 0, 64 * 1024, 64, SECT_4K, },
	{ "w25x64", 0xef3017, 0, 64 * 1024, 128, SECT_4K, },
549 550
};

551 552 553 554
static struct flash_info *__devinit jedec_probe(struct spi_device *spi)
{
	int			tmp;
	u8			code = OPCODE_RDID;
555
	u8			id[5];
556
	u32			jedec;
557
	u16                     ext_jedec;
558 559 560 561 562 563
	struct flash_info	*info;

	/* JEDEC also defines an optional "extended device information"
	 * string for after vendor-specific data, after the three bytes
	 * we use here.  Supporting some chips might require using it.
	 */
564
	tmp = spi_write_then_read(spi, &code, 1, id, 5);
565 566
	if (tmp < 0) {
		DEBUG(MTD_DEBUG_LEVEL0, "%s: error %d reading JEDEC ID\n",
567
			dev_name(&spi->dev), tmp);
568 569 570 571 572 573 574 575
		return NULL;
	}
	jedec = id[0];
	jedec = jedec << 8;
	jedec |= id[1];
	jedec = jedec << 8;
	jedec |= id[2];

576 577
	ext_jedec = id[3] << 8 | id[4];

578 579 580
	for (tmp = 0, info = m25p_data;
			tmp < ARRAY_SIZE(m25p_data);
			tmp++, info++) {
581
		if (info->jedec_id == jedec) {
582
			if (info->ext_id != 0 && info->ext_id != ext_jedec)
583
				continue;
584
			return info;
585
		}
586 587 588 589 590 591
	}
	dev_err(&spi->dev, "unrecognized JEDEC id %06x\n", jedec);
	return NULL;
}


592 593 594 595 596 597 598 599 600 601 602 603 604
/*
 * board specific setup should have ensured the SPI clock used here
 * matches what the READ command supports, at least until this driver
 * understands FAST_READ (for clocks over 25 MHz).
 */
static int __devinit m25p_probe(struct spi_device *spi)
{
	struct flash_platform_data	*data;
	struct m25p			*flash;
	struct flash_info		*info;
	unsigned			i;

	/* Platform data helps sort out which chip type we have, as
605 606 607
	 * well as how this board partitions it.  If we don't have
	 * a chip ID, try the JEDEC id commands; they'll work for most
	 * newer chips, even if we don't recognize the particular chip.
608 609
	 */
	data = spi->dev.platform_data;
610 611 612 613 614 615 616
	if (data && data->type) {
		for (i = 0, info = m25p_data;
				i < ARRAY_SIZE(m25p_data);
				i++, info++) {
			if (strcmp(data->type, info->name) == 0)
				break;
		}
617

618 619 620
		/* unrecognized chip? */
		if (i == ARRAY_SIZE(m25p_data)) {
			DEBUG(MTD_DEBUG_LEVEL0, "%s: unrecognized id %s\n",
621
					dev_name(&spi->dev), data->type);
622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
			info = NULL;

		/* recognized; is that chip really what's there? */
		} else if (info->jedec_id) {
			struct flash_info	*chip = jedec_probe(spi);

			if (!chip || chip != info) {
				dev_warn(&spi->dev, "found %s, expected %s\n",
						chip ? chip->name : "UNKNOWN",
						info->name);
				info = NULL;
			}
		}
	} else
		info = jedec_probe(spi);

	if (!info)
639 640
		return -ENODEV;

641
	flash = kzalloc(sizeof *flash, GFP_KERNEL);
642 643 644 645
	if (!flash)
		return -ENOMEM;

	flash->spi = spi;
D
David Brownell 已提交
646
	mutex_init(&flash->lock);
647 648
	dev_set_drvdata(&spi->dev, flash);

649 650 651 652 653 654 655 656 657 658
	/*
	 * Atmel serial flash tend to power up
	 * with the software protection bits set
	 */

	if (info->jedec_id >> 16 == 0x1f) {
		write_enable(flash);
		write_sr(flash, 0);
	}

659
	if (data && data->name)
660 661
		flash->mtd.name = data->name;
	else
662
		flash->mtd.name = dev_name(&spi->dev);
663 664

	flash->mtd.type = MTD_NORFLASH;
665
	flash->mtd.writesize = 1;
666 667 668 669 670 671
	flash->mtd.flags = MTD_CAP_NORFLASH;
	flash->mtd.size = info->sector_size * info->n_sectors;
	flash->mtd.erase = m25p80_erase;
	flash->mtd.read = m25p80_read;
	flash->mtd.write = m25p80_write;

672 673 674 675 676 677 678 679 680
	/* prefer "small sector" erase if possible */
	if (info->flags & SECT_4K) {
		flash->erase_opcode = OPCODE_BE_4K;
		flash->mtd.erasesize = 4096;
	} else {
		flash->erase_opcode = OPCODE_SE;
		flash->mtd.erasesize = info->sector_size;
	}

681 682
	flash->mtd.dev.parent = &spi->dev;

683 684
	dev_info(&spi->dev, "%s (%lld Kbytes)\n", info->name,
			(long long)flash->mtd.size >> 10);
685 686

	DEBUG(MTD_DEBUG_LEVEL2,
687
		"mtd .name = %s, .size = 0x%llx (%lldMiB) "
688
			".erasesize = 0x%.8x (%uKiB) .numeraseregions = %d\n",
689
		flash->mtd.name,
690
		(long long)flash->mtd.size, (long long)(flash->mtd.size >> 20),
691 692 693 694 695 696
		flash->mtd.erasesize, flash->mtd.erasesize / 1024,
		flash->mtd.numeraseregions);

	if (flash->mtd.numeraseregions)
		for (i = 0; i < flash->mtd.numeraseregions; i++)
			DEBUG(MTD_DEBUG_LEVEL2,
697
				"mtd.eraseregions[%d] = { .offset = 0x%llx, "
698
				".erasesize = 0x%.8x (%uKiB), "
699
				".numblocks = %d }\n",
700
				i, (long long)flash->mtd.eraseregions[i].offset,
701 702 703 704 705 706 707 708 709 710 711 712
				flash->mtd.eraseregions[i].erasesize,
				flash->mtd.eraseregions[i].erasesize / 1024,
				flash->mtd.eraseregions[i].numblocks);


	/* partitions should match sector boundaries; and it may be good to
	 * use readonly partitions for writeprotected sectors (BP2..BP0).
	 */
	if (mtd_has_partitions()) {
		struct mtd_partition	*parts = NULL;
		int			nr_parts = 0;

713 714 715
		if (mtd_has_cmdlinepart()) {
			static const char *part_probes[]
					= { "cmdlinepart", NULL, };
716

717 718 719
			nr_parts = parse_mtd_partitions(&flash->mtd,
					part_probes, &parts, 0);
		}
720 721 722 723 724 725 726

		if (nr_parts <= 0 && data && data->parts) {
			parts = data->parts;
			nr_parts = data->nr_parts;
		}

		if (nr_parts > 0) {
727
			for (i = 0; i < nr_parts; i++) {
728
				DEBUG(MTD_DEBUG_LEVEL2, "partitions[%d] = "
729 730
					"{.name = %s, .offset = 0x%llx, "
						".size = 0x%llx (%lldKiB) }\n",
731
					i, parts[i].name,
732 733 734
					(long long)parts[i].offset,
					(long long)parts[i].size,
					(long long)(parts[i].size >> 10));
735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770
			}
			flash->partitioned = 1;
			return add_mtd_partitions(&flash->mtd, parts, nr_parts);
		}
	} else if (data->nr_parts)
		dev_warn(&spi->dev, "ignoring %d default partitions on %s\n",
				data->nr_parts, data->name);

	return add_mtd_device(&flash->mtd) == 1 ? -ENODEV : 0;
}


static int __devexit m25p_remove(struct spi_device *spi)
{
	struct m25p	*flash = dev_get_drvdata(&spi->dev);
	int		status;

	/* Clean up MTD stuff. */
	if (mtd_has_partitions() && flash->partitioned)
		status = del_mtd_partitions(&flash->mtd);
	else
		status = del_mtd_device(&flash->mtd);
	if (status == 0)
		kfree(flash);
	return 0;
}


static struct spi_driver m25p80_driver = {
	.driver = {
		.name	= "m25p80",
		.bus	= &spi_bus_type,
		.owner	= THIS_MODULE,
	},
	.probe	= m25p_probe,
	.remove	= __devexit_p(m25p_remove),
771 772 773 774 775

	/* REVISIT: many of these chips have deep power-down modes, which
	 * should clearly be entered on suspend() to minimize power use.
	 * And also when they're otherwise idle...
	 */
776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796
};


static int m25p80_init(void)
{
	return spi_register_driver(&m25p80_driver);
}


static void m25p80_exit(void)
{
	spi_unregister_driver(&m25p80_driver);
}


module_init(m25p80_init);
module_exit(m25p80_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mike Lavender");
MODULE_DESCRIPTION("MTD SPI driver for ST M25Pxx flash chips");