[U-Boot] [PATCH 5/6] mtd/spi: add sst25l driver

Mikhail Kshevetskiy mikhail.kshevetskiy at gmail.com
Tue Jun 26 12:33:13 CEST 2012


current SST driver does not support well this types of flash, so use
linux-3.3 code as a base.

Signed-off-by: Mikhail Kshevetskiy <mikhail.kshevetskiy at gmail.com>
---
 drivers/mtd/spi/Makefile             |    3 +-
 drivers/mtd/spi/spi_flash.c          |    3 +
 drivers/mtd/spi/spi_flash_internal.h |    1 +
 drivers/mtd/spi/sst25l.c             |  372 ++++++++++++++++++++++++++++++++++
 4 files changed, 378 insertions(+), 1 deletion(-)
 create mode 100644 drivers/mtd/spi/sst25l.c

diff --git a/drivers/mtd/spi/Makefile b/drivers/mtd/spi/Makefile
index 90f8392..9285bf7 100644
--- a/drivers/mtd/spi/Makefile
+++ b/drivers/mtd/spi/Makefile
@@ -34,7 +34,8 @@ COBJS-$(CONFIG_SPI_FLASH_ATMEL)	+= atmel.o
 COBJS-$(CONFIG_SPI_FLASH_EON)	+= eon.o
 COBJS-$(CONFIG_SPI_FLASH_MACRONIX)	+= macronix.o
 COBJS-$(CONFIG_SPI_FLASH_SPANSION)	+= spansion.o
-COBJS-$(CONFIG_SPI_FLASH_SST)	+= sst.o
+COBJS-$(CONFIG_SPI_FLASH_SST)		+= sst.o
+COBJS-$(CONFIG_SPI_FLASH_SST25L)	+= sst25l.o
 COBJS-$(CONFIG_SPI_FLASH_STMICRO)	+= stmicro.o
 COBJS-$(CONFIG_SPI_FLASH_WINBOND)	+= winbond.o
 COBJS-$(CONFIG_SPI_FRAM_RAMTRON)	+= ramtron.o
diff --git a/drivers/mtd/spi/spi_flash.c b/drivers/mtd/spi/spi_flash.c
index 530b7b3..d2da542 100644
--- a/drivers/mtd/spi/spi_flash.c
+++ b/drivers/mtd/spi/spi_flash.c
@@ -285,6 +285,9 @@ static const struct {
 #ifdef CONFIG_SPI_FLASH_SST
 	{ 0, 0xbf, spi_flash_probe_sst, },
 #endif
+#ifdef CONFIG_SPI_FLASH_SST25L
+	{ 0, 0xbf, spi_flash_probe_sst25l, },
+#endif
 #ifdef CONFIG_SPI_FLASH_STMICRO
 	{ 0, 0x20, spi_flash_probe_stmicro, },
 #endif
diff --git a/drivers/mtd/spi/spi_flash_internal.h b/drivers/mtd/spi/spi_flash_internal.h
index b8bd5d5..89d9036 100644
--- a/drivers/mtd/spi/spi_flash_internal.h
+++ b/drivers/mtd/spi/spi_flash_internal.h
@@ -98,6 +98,7 @@ struct spi_flash *spi_flash_probe_atmel(struct spi_slave *spi, u8 *idcode);
 struct spi_flash *spi_flash_probe_eon(struct spi_slave *spi, u8 *idcode);
 struct spi_flash *spi_flash_probe_macronix(struct spi_slave *spi, u8 *idcode);
 struct spi_flash *spi_flash_probe_sst(struct spi_slave *spi, u8 *idcode);
+struct spi_flash *spi_flash_probe_sst25l(struct spi_slave *spi, u8 *idcode);
 struct spi_flash *spi_flash_probe_stmicro(struct spi_slave *spi, u8 *idcode);
 struct spi_flash *spi_flash_probe_winbond(struct spi_slave *spi, u8 *idcode);
 struct spi_flash *spi_fram_probe_ramtron(struct spi_slave *spi, u8 *idcode);
diff --git a/drivers/mtd/spi/sst25l.c b/drivers/mtd/spi/sst25l.c
new file mode 100644
index 0000000..9d7be0d
--- /dev/null
+++ b/drivers/mtd/spi/sst25l.c
@@ -0,0 +1,372 @@
+/*
+ * Driver for SST25L SPI Flash chips
+ *
+ * (C) Copyright 2000-2002
+ * Wolfgang Denk, DENX Software Engineering, wd at denx.de.
+ * Copyright 2008, Network Appliance Inc.
+ * Jason McMullan <mcmullan at netapp.com>
+ * Copyright (C) 2004-2007 Freescale Semiconductor, Inc.
+ * TsiChung Liew (Tsi-Chung.Liew at freescale.com)
+ * Copyright (c) 2008-2009 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <common.h>
+#include <malloc.h>
+#include <spi_flash.h>
+#include <watchdog.h>
+
+#include "spi_flash_internal.h"
+
+#define SST25L_CMD_WRSR		0x01	/* Write status register */
+#define SST25L_CMD_WRDI		0x04	/* Write disable */
+#define SST25L_CMD_RDSR		0x05	/* Read status register */
+#define SST25L_CMD_WREN		0x06	/* Write enable */
+#define SST25L_CMD_READ		0x03	/* High speed read */
+
+#define SST25L_CMD_EWSR		0x50	/* Enable write status register */
+#define SST25L_CMD_SECTOR_ERASE	0x20	/* Erase sector */
+#define SST25L_CMD_READ_ID	0x90	/* Read device ID */
+#define SST25L_CMD_AAI_PROGRAM	0xaf	/* Auto address increment */
+
+#define SST25L_STATUS_BUSY	(1 << 0)	/* Chip is busy */
+#define SST25L_STATUS_WREN	(1 << 1)	/* Write enabled */
+#define SST25L_STATUS_BP0	(1 << 2)	/* Block protection 0 */
+#define SST25L_STATUS_BP1	(1 << 3)	/* Block protection 1 */
+
+struct flash_info {
+	const char	*name;
+	u16		device_id;
+	u32		page_size;
+	u32		nr_pages;
+	u32		erase_size;
+};
+
+struct sst25l_spi_flash {
+	struct spi_flash	flash;
+	const struct flash_info	*flash_info;
+};
+
+#define to_sst25l_spi_flash(x) container_of(x, struct sst25l_spi_flash, flash)
+
+static struct flash_info sst25l_flash_info[] = {
+	{"sst25vf010a", 0xbf49, 256, 512,  4096},
+	{"sst25lf020a", 0xbf43, 256, 1024, 4096},
+	{"sst25lf040a", 0xbf44, 256, 2048, 4096},
+};
+
+static inline int spi_write_sync(struct spi_slave *spi,
+				const u8 *data, size_t len)
+{
+	return spi_xfer(spi, 8 * len, data,
+			NULL, SPI_XFER_BEGIN | SPI_XFER_END);
+}
+
+static int sst25l_status(struct spi_flash *flash, int *status)
+{
+	unsigned char	cmd_resp[2];
+	int		err;
+
+	cmd_resp[0] = SST25L_CMD_RDSR;
+	cmd_resp[1] = 0xff;
+
+	err = spi_xfer(flash->spi, 8 * sizeof(cmd_resp), cmd_resp, cmd_resp,
+			SPI_XFER_BEGIN | SPI_XFER_END);
+	if (err < 0)
+		return err;
+
+	*status = cmd_resp[1];
+	return 0;
+}
+
+static int sst25l_write_enable(struct spi_flash *flash, int enable)
+{
+	unsigned char	command[2];
+	int		status, err;
+
+	command[0] = enable ? SST25L_CMD_WREN : SST25L_CMD_WRDI;
+	err = spi_write_sync(flash->spi, command, 1);
+	if (err)
+		return err;
+
+	command[0] = SST25L_CMD_EWSR;
+	err = spi_write_sync(flash->spi, command, 1);
+	if (err)
+		return err;
+
+	command[0] = SST25L_CMD_WRSR;
+	command[1] = enable ? 0 : SST25L_STATUS_BP0 | SST25L_STATUS_BP1;
+	err = spi_write_sync(flash->spi, command, 2);
+	if (err)
+		return err;
+
+	if (enable) {
+		err = sst25l_status(flash, &status);
+		if (err)
+			return err;
+		if (!(status & SST25L_STATUS_WREN))
+			return -1;
+	}
+
+	return 0;
+}
+
+static int sst25l_wait_till_ready(struct spi_flash *flash,
+					unsigned long timeout)
+{
+	unsigned long	timebase;
+	int		status, err;
+
+	timebase = get_timer(0);
+	do {
+		WATCHDOG_RESET();
+
+		err = sst25l_status(flash, &status);
+		if (err)
+			return err;
+		if (!(status & SST25L_STATUS_BUSY))
+			return 0;
+
+	} while (get_timer(timebase) < timeout);
+
+	return -1;
+}
+
+static int sst25l_erase_sector(struct spi_flash *flash, u32 offset)
+{
+	unsigned char		command[4];
+	int			err;
+
+	err = sst25l_write_enable(flash, 1);
+	if (err)
+		return err;
+
+	command[0] = SST25L_CMD_SECTOR_ERASE;
+	command[1] = offset >> 16;
+	command[2] = offset >> 8;
+	command[3] = offset;
+	err = spi_write_sync(flash->spi, command, 4);
+	if (err)
+		return err;
+
+	err = sst25l_wait_till_ready(flash, SPI_FLASH_SECTOR_ERASE_TIMEOUT);
+	if (err)
+		return err;
+
+	return sst25l_write_enable(flash, 0);
+}
+
+static int sst25l_erase(struct spi_flash *flash, u32 offset, size_t len)
+{
+	struct sst25l_spi_flash	*sst25l = to_sst25l_spi_flash(flash);
+	const struct flash_info	*flash_info = sst25l->flash_info;
+	u32			end = offset + len;
+	int			err;
+
+	/* Sanity checks */
+	if (len % flash_info->erase_size)
+		return -1;
+
+	if (offset % flash_info->erase_size)
+		return -1;
+
+	err = sst25l_wait_till_ready(flash, SPI_FLASH_PROG_TIMEOUT);
+	if (err)
+		return err;
+
+	while (offset < end) {
+		err = sst25l_erase_sector(flash, offset);
+		if (err)
+			return err;
+		offset += flash_info->erase_size;
+	}
+	return 0;
+}
+
+static int sst25l_read(struct spi_flash *flash,
+			u32 offset, size_t len, void *data)
+{
+	unsigned char	command[4];
+	int		ret;
+
+	command[0] = SST25L_CMD_READ;
+	command[1] = offset >> 16;
+	command[2] = offset >> 8;
+	command[3] = offset;
+
+	/* Wait for previous write/erase to complete */
+	ret = sst25l_wait_till_ready(flash, SPI_FLASH_PROG_TIMEOUT);
+	if (ret)
+		return ret;
+
+	ret = spi_xfer(flash->spi, 8 * sizeof(command), command,
+			NULL, SPI_XFER_BEGIN);
+	if (ret)
+		return ret;
+
+	ret = spi_xfer(flash->spi, 8 * len, NULL, data, SPI_XFER_END);
+	if (ret)
+		return ret;
+
+	return 0;
+}
+
+static int sst25l_write(struct spi_flash *flash,
+			u32 offset, size_t len, const char *buf)
+{
+	struct sst25l_spi_flash	*sst25l = to_sst25l_spi_flash(flash);
+	const struct flash_info	*flash_info = sst25l->flash_info;
+	int			i, j, ret, bytes, copied = 0;
+	unsigned char		command[5];
+
+	if (offset % flash_info->page_size)
+		return -1;
+
+	ret = sst25l_write_enable(flash, 1);
+	if (ret)
+		goto out;
+
+	for (i = 0; i < len; i += flash_info->page_size) {
+		ret = sst25l_wait_till_ready(flash, SPI_FLASH_PROG_TIMEOUT);
+		if (ret)
+			goto out;
+
+		/* Write the first byte of the page */
+		command[0] = SST25L_CMD_AAI_PROGRAM;
+		command[1] = (offset + i) >> 16;
+		command[2] = (offset + i) >> 8;
+		command[3] = (offset + i);
+		command[4] = buf[i];
+		ret = spi_write_sync(flash->spi, command, 5);
+		if (ret < 0)
+			goto out;
+		copied++;
+
+		/*
+		 * Write the remaining bytes using auto address
+		 * increment mode
+		 */
+		bytes = min(flash_info->page_size, len - i);
+		for (j = 1; j < bytes; j++, copied++) {
+			ret = sst25l_wait_till_ready(flash,
+						SPI_FLASH_PROG_TIMEOUT);
+			if (ret)
+				goto out;
+
+			command[1] = buf[i + j];
+			ret = spi_write_sync(flash->spi, command, 2);
+			if (ret)
+				goto out;
+		}
+	}
+
+out:
+	ret = sst25l_write_enable(flash, 0);
+	if (ret)
+		return ret;
+
+	return (copied == len) ? 0 : -1;
+}
+
+static int sst25l_flash_erase(struct spi_flash *flash, u32 offset, size_t len)
+{
+	int ret;
+
+	ret = spi_claim_bus(flash->spi);
+	if (ret) {
+		debug("SF: unable to claim SPI bus\n");
+		return ret;
+	}
+
+	ret = sst25l_erase(flash, offset, len);
+	if (ret) {
+		debug("SF: unable to erase spi flash sector\n");
+		return ret;
+	}
+
+	spi_release_bus(flash->spi);
+	return ret;
+}
+
+static int sst25l_flash_read(struct spi_flash *flash,
+				u32 offset, size_t len, void *data)
+{
+	int ret;
+
+	ret = spi_claim_bus(flash->spi);
+	if (ret) {
+		debug("SF: unable to claim SPI bus\n");
+		return ret;
+	}
+
+	ret = sst25l_read(flash, offset, len, data);
+	if (ret) {
+		debug("SF: unable to read spi flash\n");
+		return ret;
+	}
+
+	spi_release_bus(flash->spi);
+	return ret;
+}
+
+static int sst25l_flash_write(struct spi_flash *flash,
+				u32 offset, size_t len, const void *buf)
+{
+	int ret;
+
+	ret = spi_claim_bus(flash->spi);
+	if (ret) {
+		debug("SF: unable to claim SPI bus\n");
+		return ret;
+	}
+
+	ret = sst25l_write(flash, offset, len, buf);
+	if (ret) {
+		debug("SF: unable to write spi flash\n");
+		return ret;
+	}
+
+	spi_release_bus(flash->spi);
+	return ret;
+}
+
+struct spi_flash *
+spi_flash_probe_sst25l(struct spi_slave *spi, u8 *idcode)
+{
+	const struct flash_info	*flash_info = NULL;
+	struct sst25l_spi_flash	*stm;
+	size_t			i;
+	u16			device_id = ((u16)idcode[0] << 8) + idcode[1];
+
+	for (i = 0; i < ARRAY_SIZE(sst25l_flash_info); ++i)
+		if (sst25l_flash_info[i].device_id == device_id) {
+			flash_info = &sst25l_flash_info[i];
+			break;
+		}
+
+	if (flash_info == NULL) {
+		debug("SF: Unsupported SST25L ID %04x\n", device_id);
+		return NULL;
+	}
+
+	stm = malloc(sizeof(*stm));
+	if (!stm) {
+		debug("SF: Failed to allocate memory\n");
+		return NULL;
+	}
+
+	stm->flash_info = flash_info;
+	stm->flash.spi  = spi;
+	stm->flash.name = flash_info->name;
+
+	stm->flash.read  = sst25l_flash_read;
+	stm->flash.write = sst25l_flash_write;
+	stm->flash.erase = sst25l_flash_erase;
+
+	stm->flash.page_size   = flash_info->page_size;
+	stm->flash.sector_size = flash_info->erase_size;
+	stm->flash.size        = flash_info->page_size * flash_info->nr_pages;
+
+	return &stm->flash;
+}
-- 
1.7.10



More information about the U-Boot mailing list