[people/ms/u-boot.git] / drivers / mtd / spi / spansion.c

/*
 * Copyright (C) 2009 Freescale Semiconductor, Inc.
 *
 * Author: Mingkai Hu (Mingkai.hu@freescale.com)
 * Based on stmicro.c by Wolfgang Denk (wd@denx.de),
 * TsiChung Liew (Tsi-Chung.Liew@freescale.com),
 * and  Jason McMullan (mcmullan@netapp.com)
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */

#include <common.h>
#include <malloc.h>
#include <spi_flash.h>

#include "spi_flash_internal.h"

/* S25FLxx-specific commands */
#define CMD_S25FLXX_READ	0x03	/* Read Data Bytes */
#define CMD_S25FLXX_FAST_READ	0x0b	/* Read Data Bytes at Higher Speed */
#define CMD_S25FLXX_READID	0x90	/* Read Manufacture ID and Device ID */
#define CMD_S25FLXX_WREN	0x06	/* Write Enable */
#define CMD_S25FLXX_WRDI	0x04	/* Write Disable */
#define CMD_S25FLXX_RDSR	0x05	/* Read Status Register */
#define CMD_S25FLXX_WRSR	0x01	/* Write Status Register */
#define CMD_S25FLXX_PP		0x02	/* Page Program */
#define CMD_S25FLXX_SE		0xd8	/* Sector Erase */
#define CMD_S25FLXX_BE		0xc7	/* Bulk Erase */
#define CMD_S25FLXX_DP		0xb9	/* Deep Power-down */
#define CMD_S25FLXX_RES		0xab	/* Release from DP, and Read Signature */

#define SPSN_ID_S25FL008A	0x0213
#define SPSN_ID_S25FL016A	0x0214
#define SPSN_ID_S25FL032A	0x0215
#define SPSN_ID_S25FL064A	0x0216
#define SPSN_ID_S25FL128P	0x2018
#define SPSN_EXT_ID_S25FL128P_256KB	0x0300
#define SPSN_EXT_ID_S25FL128P_64KB	0x0301
#define SPSN_EXT_ID_S25FL032P		0x4d00

struct spansion_spi_flash_params {
	u16 idcode1;
	u16 idcode2;
	u16 page_size;
	u16 pages_per_sector;
	u16 nr_sectors;
	const char *name;
};

struct spansion_spi_flash {
	struct spi_flash flash;
	const struct spansion_spi_flash_params *params;
};

static inline struct spansion_spi_flash *to_spansion_spi_flash(struct spi_flash
							     *flash)
{
	return container_of(flash, struct spansion_spi_flash, flash);
}

static const struct spansion_spi_flash_params spansion_spi_flash_table[] = {
	{
		.idcode1 = SPSN_ID_S25FL008A,
		.idcode2 = 0,
		.page_size = 256,
		.pages_per_sector = 256,
		.nr_sectors = 16,
		.name = "S25FL008A",
	},
	{
		.idcode1 = SPSN_ID_S25FL016A,
		.idcode2 = 0,
		.page_size = 256,
		.pages_per_sector = 256,
		.nr_sectors = 32,
		.name = "S25FL016A",
	},
	{
		.idcode1 = SPSN_ID_S25FL032A,
		.idcode2 = 0,
		.page_size = 256,
		.pages_per_sector = 256,
		.nr_sectors = 64,
		.name = "S25FL032A",
	},
	{
		.idcode1 = SPSN_ID_S25FL064A,
		.idcode2 = 0,
		.page_size = 256,
		.pages_per_sector = 256,
		.nr_sectors = 128,
		.name = "S25FL064A",
	},
	{
		.idcode1 = SPSN_ID_S25FL128P,
		.idcode2 = SPSN_EXT_ID_S25FL128P_64KB,
		.page_size = 256,
		.pages_per_sector = 256,
		.nr_sectors = 256,
		.name = "S25FL128P_64K",
	},
	{
		.idcode1 = SPSN_ID_S25FL128P,
		.idcode2 = SPSN_EXT_ID_S25FL128P_256KB,
		.page_size = 256,
		.pages_per_sector = 1024,
		.nr_sectors = 64,
		.name = "S25FL128P_256K",
	},
	{
		.idcode1 = SPSN_ID_S25FL032A,
		.idcode2 = SPSN_EXT_ID_S25FL032P,
		.page_size = 256,
		.pages_per_sector = 256,
		.nr_sectors = 64,
		.name = "S25FL032P",
	},
};

static int spansion_write(struct spi_flash *flash,
			 u32 offset, size_t len, const void *buf)
{
	struct spansion_spi_flash *spsn = to_spansion_spi_flash(flash);
	unsigned long page_addr;
	unsigned long byte_addr;
	unsigned long page_size;
	size_t chunk_len;
	size_t actual;
	int ret;
	u8 cmd[4];

	page_size = spsn->params->page_size;
	page_addr = offset / page_size;
	byte_addr = offset % page_size;

	ret = spi_claim_bus(flash->spi);
	if (ret) {
		debug("SF: Unable to claim SPI bus\n");
		return ret;
	}

	ret = 0;
	for (actual = 0; actual < len; actual += chunk_len) {
		chunk_len = min(len - actual, page_size - byte_addr);

		cmd[0] = CMD_S25FLXX_PP;
		cmd[1] = page_addr >> 8;
		cmd[2] = page_addr;
		cmd[3] = byte_addr;

		debug
		    ("PP: 0x%p => cmd = { 0x%02x 0x%02x%02x%02x } chunk_len = %d\n",
		     buf + actual, cmd[0], cmd[1], cmd[2], cmd[3], chunk_len);

		ret = spi_flash_cmd(flash->spi, CMD_S25FLXX_WREN, NULL, 0);
		if (ret < 0) {
			debug("SF: Enabling Write failed\n");
			break;
		}

		ret = spi_flash_cmd_write(flash->spi, cmd, 4,
					  buf + actual, chunk_len);
		if (ret < 0) {
			debug("SF: SPANSION Page Program failed\n");
			break;
		}

		ret = spi_flash_cmd_wait_ready(flash, SPI_FLASH_PROG_TIMEOUT);
		if (ret)
			break;

		page_addr++;
		byte_addr = 0;
	}

	debug("SF: SPANSION: Successfully programmed %u bytes @ 0x%x\n",
	      len, offset);

	spi_release_bus(flash->spi);
	return ret;
}

static int spansion_erase(struct spi_flash *flash, u32 offset, size_t len)
{
	return spi_flash_cmd_erase(flash, CMD_S25FLXX_SE, offset, len);
}

struct spi_flash *spi_flash_probe_spansion(struct spi_slave *spi, u8 *idcode)
{
	const struct spansion_spi_flash_params *params;
	struct spansion_spi_flash *spsn;
	unsigned int i;
	unsigned short jedec, ext_jedec;

	jedec = idcode[1] << 8 | idcode[2];
	ext_jedec = idcode[3] << 8 | idcode[4];

	for (i = 0; i < ARRAY_SIZE(spansion_spi_flash_table); i++) {
		params = &spansion_spi_flash_table[i];
		if (params->idcode1 == jedec) {
			if (params->idcode2 == ext_jedec)
				break;
		}
	}

	if (i == ARRAY_SIZE(spansion_spi_flash_table)) {
		debug("SF: Unsupported SPANSION ID %04x %04x\n", jedec, ext_jedec);
		return NULL;
	}

	spsn = malloc(sizeof(struct spansion_spi_flash));
	if (!spsn) {
		debug("SF: Failed to allocate memory\n");
		return NULL;
	}

	spsn->params = params;
	spsn->flash.spi = spi;
	spsn->flash.name = params->name;

	spsn->flash.write = spansion_write;
	spsn->flash.erase = spansion_erase;
	spsn->flash.read = spi_flash_cmd_read_fast;
	spsn->flash.sector_size = params->page_size * params->pages_per_sector;
	spsn->flash.size = spsn->flash.sector_size * params->nr_sectors;

	return &spsn->flash;
}
Commit	Line	Data
6805e4bf MH	1	/*
	2	* Copyright (C) 2009 Freescale Semiconductor, Inc.
	3	*
	4	* Author: Mingkai Hu (Mingkai.hu@freescale.com)
	5	* Based on stmicro.c by Wolfgang Denk (wd@denx.de),
	6	* TsiChung Liew (Tsi-Chung.Liew@freescale.com),
	7	* and Jason McMullan (mcmullan@netapp.com)
	8	*
	9	* See file CREDITS for list of people who contributed to this
	10	* project.
	11	*
	12	* This program is free software; you can redistribute it and/or
	13	* modify it under the terms of the GNU General Public License as
	14	* published by the Free Software Foundation; either version 2 of
	15	* the License, or (at your option) any later version.
	16	*
	17	* This program is distributed in the hope that it will be useful,
	18	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	20	* GNU General Public License for more details.
	21	*
	22	* You should have received a copy of the GNU General Public License
	23	* along with this program; if not, write to the Free Software
	24	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	25	* MA 02111-1307 USA
	26	*/
	27
	28	#include <common.h>
	29	#include <malloc.h>
	30	#include <spi_flash.h>
	31
	32	#include "spi_flash_internal.h"
	33
	34	/* S25FLxx-specific commands */
	35	#define CMD_S25FLXX_READ 0x03 /* Read Data Bytes */
	36	#define CMD_S25FLXX_FAST_READ 0x0b /* Read Data Bytes at Higher Speed */
	37	#define CMD_S25FLXX_READID 0x90 /* Read Manufacture ID and Device ID */
	38	#define CMD_S25FLXX_WREN 0x06 /* Write Enable */
	39	#define CMD_S25FLXX_WRDI 0x04 /* Write Disable */
	40	#define CMD_S25FLXX_RDSR 0x05 /* Read Status Register */
	41	#define CMD_S25FLXX_WRSR 0x01 /* Write Status Register */
	42	#define CMD_S25FLXX_PP 0x02 /* Page Program */
	43	#define CMD_S25FLXX_SE 0xd8 /* Sector Erase */
	44	#define CMD_S25FLXX_BE 0xc7 /* Bulk Erase */
	45	#define CMD_S25FLXX_DP 0xb9 /* Deep Power-down */
	46	#define CMD_S25FLXX_RES 0xab /* Release from DP, and Read Signature */
	47
	48	#define SPSN_ID_S25FL008A 0x0213
	49	#define SPSN_ID_S25FL016A 0x0214
	50	#define SPSN_ID_S25FL032A 0x0215
	51	#define SPSN_ID_S25FL064A 0x0216
	52	#define SPSN_ID_S25FL128P 0x2018
	53	#define SPSN_EXT_ID_S25FL128P_256KB 0x0300
	54	#define SPSN_EXT_ID_S25FL128P_64KB 0x0301
ff0dc2c4	55	#define SPSN_EXT_ID_S25FL032P 0x4d00
6805e4bf	56
6805e4bf MH	57	struct spansion_spi_flash_params {
	58	u16 idcode1;
	59	u16 idcode2;
	60	u16 page_size;
	61	u16 pages_per_sector;
	62	u16 nr_sectors;
	63	const char *name;
	64	};
	65
	66	struct spansion_spi_flash {
	67	struct spi_flash flash;
	68	const struct spansion_spi_flash_params *params;
	69	};
	70
	71	static inline struct spansion_spi_flash *to_spansion_spi_flash(struct spi_flash
	72	*flash)
	73	{
	74	return container_of(flash, struct spansion_spi_flash, flash);
	75	}
	76
	77	static const struct spansion_spi_flash_params spansion_spi_flash_table[] = {
	78	{
	79	.idcode1 = SPSN_ID_S25FL008A,
	80	.idcode2 = 0,
	81	.page_size = 256,
	82	.pages_per_sector = 256,
	83	.nr_sectors = 16,
	84	.name = "S25FL008A",
	85	},
	86	{
	87	.idcode1 = SPSN_ID_S25FL016A,
	88	.idcode2 = 0,
	89	.page_size = 256,
	90	.pages_per_sector = 256,
	91	.nr_sectors = 32,
	92	.name = "S25FL016A",
	93	},
	94	{
	95	.idcode1 = SPSN_ID_S25FL032A,
	96	.idcode2 = 0,
	97	.page_size = 256,
	98	.pages_per_sector = 256,
	99	.nr_sectors = 64,
	100	.name = "S25FL032A",
	101	},
	102	{
	103	.idcode1 = SPSN_ID_S25FL064A,
	104	.idcode2 = 0,
	105	.page_size = 256,
	106	.pages_per_sector = 256,
	107	.nr_sectors = 128,
	108	.name = "S25FL064A",
	109	},
	110	{
	111	.idcode1 = SPSN_ID_S25FL128P,
	112	.idcode2 = SPSN_EXT_ID_S25FL128P_64KB,
	113	.page_size = 256,
	114	.pages_per_sector = 256,
	115	.nr_sectors = 256,
	116	.name = "S25FL128P_64K",
	117	},
	118	{
	119	.idcode1 = SPSN_ID_S25FL128P,
	120	.idcode2 = SPSN_EXT_ID_S25FL128P_256KB,
121	.page_size = 256,
122	.pages_per_sector = 1024,
123	.nr_sectors = 64,
124	.name = "S25FL128P_256K",
125	},
ff0dc2c4 DJ	126	{
	127	.idcode1 = SPSN_ID_S25FL032A,
	128	.idcode2 = SPSN_EXT_ID_S25FL032P,
	129	.page_size = 256,
	130	.pages_per_sector = 256,
	131	.nr_sectors = 64,
	132	.name = "S25FL032P",
	133	},
6805e4bf MH	134	};
6805e4bf MH	135
6805e4bf MH	136	static int spansion_write(struct spi_flash *flash,
	137	u32 offset, size_t len, const void *buf)
	138	{
	139	struct spansion_spi_flash *spsn = to_spansion_spi_flash(flash);
	140	unsigned long page_addr;
	141	unsigned long byte_addr;
	142	unsigned long page_size;
	143	size_t chunk_len;
	144	size_t actual;
	145	int ret;
	146	u8 cmd[4];
	147
	148	page_size = spsn->params->page_size;
	149	page_addr = offset / page_size;
	150	byte_addr = offset % page_size;
	151
	152	ret = spi_claim_bus(flash->spi);
	153	if (ret) {
	154	debug("SF: Unable to claim SPI bus\n");
	155	return ret;
	156	}
	157
	158	ret = 0;
	159	for (actual = 0; actual < len; actual += chunk_len) {
	160	chunk_len = min(len - actual, page_size - byte_addr);
	161
	162	cmd[0] = CMD_S25FLXX_PP;
	163	cmd[1] = page_addr >> 8;
	164	cmd[2] = page_addr;
	165	cmd[3] = byte_addr;
	166
	167	debug
	168	("PP: 0x%p => cmd = { 0x%02x 0x%02x%02x%02x } chunk_len = %d\n",
	169	buf + actual, cmd[0], cmd[1], cmd[2], cmd[3], chunk_len);
	170
	171	ret = spi_flash_cmd(flash->spi, CMD_S25FLXX_WREN, NULL, 0);
	172	if (ret < 0) {
	173	debug("SF: Enabling Write failed\n");
	174	break;
	175	}
	176
	177	ret = spi_flash_cmd_write(flash->spi, cmd, 4,
	178	buf + actual, chunk_len);
	179	if (ret < 0) {
	180	debug("SF: SPANSION Page Program failed\n");
	181	break;
	182	}
	183
6163045b MF	184	ret = spi_flash_cmd_wait_ready(flash, SPI_FLASH_PROG_TIMEOUT);
6163045b MF	185	if (ret)
6805e4bf	186	break;
6805e4bf MH	187
	188	page_addr++;
	189	byte_addr = 0;
	190	}
	191
	192	debug("SF: SPANSION: Successfully programmed %u bytes @ 0x%x\n",
	193	len, offset);
	194
	195	spi_release_bus(flash->spi);
	196	return ret;
	197	}
	198
f8f0757d	199	static int spansion_erase(struct spi_flash *flash, u32 offset, size_t len)
6805e4bf	200	{
4e6a5158	201	return spi_flash_cmd_erase(flash, CMD_S25FLXX_SE, offset, len);
6805e4bf MH	202	}
	203
	204	struct spi_flash spi_flash_probe_spansion(struct spi_slave spi, u8 *idcode)
	205	{
	206	const struct spansion_spi_flash_params *params;
	207	struct spansion_spi_flash *spsn;
	208	unsigned int i;
	209	unsigned short jedec, ext_jedec;
6805e4bf	210
0dcdbb17 MF	211	jedec = idcode[1] << 8 \| idcode[2];
0dcdbb17 MF	212	ext_jedec = idcode[3] << 8 \| idcode[4];
6805e4bf MH	213
	214	for (i = 0; i < ARRAY_SIZE(spansion_spi_flash_table); i++) {
	215	params = &spansion_spi_flash_table[i];
	216	if (params->idcode1 == jedec) {
	217	if (params->idcode2 == ext_jedec)
	218	break;
	219	}
	220	}
	221
	222	if (i == ARRAY_SIZE(spansion_spi_flash_table)) {
	223	debug("SF: Unsupported SPANSION ID %04x %04x\n", jedec, ext_jedec);
	224	return NULL;
	225	}
	226
	227	spsn = malloc(sizeof(struct spansion_spi_flash));
	228	if (!spsn) {
	229	debug("SF: Failed to allocate memory\n");
	230	return NULL;
	231	}
	232
	233	spsn->params = params;
	234	spsn->flash.spi = spi;
	235	spsn->flash.name = params->name;
	236
	237	spsn->flash.write = spansion_write;
	238	spsn->flash.erase = spansion_erase;
a4c3b40b	239	spsn->flash.read = spi_flash_cmd_read_fast;
4e6a5158 RR	240	spsn->flash.sector_size = params->page_size * params->pages_per_sector;
4e6a5158 RR	241	spsn->flash.size = spsn->flash.sector_size * params->nr_sectors;
6805e4bf MH	242
	243	return &spsn->flash;
	244	}