// SPDX-License-Identifier: GPL-2.0-or-later/* * Atmel AT45xxx DataFlash MTD driver for lightweight SPI framework * * Largely derived from at91_dataflash.c: *  Copyright (C) 2003-2005 SAN People (Pty) Ltd*/#include <linux/module.h>#include <linux/slab.h>#include <linux/delay.h>#include <linux/device.h>#include <linux/mutex.h>#include <linux/err.h>#include <linux/math64.h>#include <linux/of.h> #include <linux/spi/spi.h>#include <linux/spi/flash.h> #include <linux/mtd/mtd.h>#include <linux/mtd/partitions.h> /* * DataFlash is a kind of SPI flash.  Most AT45 chips have two buffers in * each chip, which may be used for double buffered I/O; but this driver * doesn't (yet) use these for any kind of i/o overlap or prefetching. * * Sometimes DataFlash is packaged in MMC-format cards, although the * MMC stack can't (yet?) distinguish between MMC and DataFlash * protocols during enumeration. */ /* reads can bypass the buffers */#define OP_READ_CONTINUOUS	0xE8#define OP_READ_PAGE		0xD2 /* group B requests can run even while status reports "busy" */#define OP_READ_STATUS		0xD7	/* group B */ /* move data between host and buffer */#define OP_READ_BUFFER1		0xD4	/* group B */#define OP_READ_BUFFER2		0xD6	/* group B */#define OP_WRITE_BUFFER1	0x84	/* group B */#define OP_WRITE_BUFFER2	0x87	/* group B */ /* erasing flash */#define OP_ERASE_PAGE		0x81#define OP_ERASE_BLOCK		0x50 /* move data between buffer and flash */#define OP_TRANSFER_BUF1	0x53#define OP_TRANSFER_BUF2	0x55#define OP_MREAD_BUFFER1	0xD4#define OP_MREAD_BUFFER2	0xD6#define OP_MWERASE_BUFFER1	0x83#define OP_MWERASE_BUFFER2	0x86#define OP_MWRITE_BUFFER1	0x88	/* sector must be pre-erased */#define OP_MWRITE_BUFFER2	0x89	/* sector must be pre-erased */ /* write to buffer, then write-erase to flash */#define OP_PROGRAM_VIA_BUF1	0x82#define OP_PROGRAM_VIA_BUF2	0x85 /* compare buffer to flash */#define OP_COMPARE_BUF1		0x60#define OP_COMPARE_BUF2		0x61 /* read flash to buffer, then write-erase to flash */#define OP_REWRITE_VIA_BUF1	0x58#define OP_REWRITE_VIA_BUF2	0x59 /* newer chips report JEDEC manufacturer and device IDs; chip * serial number and OTP bits; and per-sector writeprotect. */#define OP_READ_ID		0x9F#define OP_READ_SECURITY	0x77#define OP_WRITE_SECURITY_REVC	0x9A#define OP_WRITE_SECURITY	0x9B	/* revision D */ #define CFI_MFR_ATMEL		0x1F #define DATAFLASH_SHIFT_EXTID	24#define DATAFLASH_SHIFT_ID	40 struct dataflash {	u8			command[4];	char			name[24]; 	unsigned short		page_offset;	/* offset in flash address */	unsigned int		page_size;	/* of bytes per page */ 	struct mutex		lock;	struct spi_device	*spi; 	struct mtd_info		mtd;}; #ifdef CONFIG_OFstatic const struct of_device_id dataflash_dt_ids[] = {	{ .compatible = "atmel,at45", },	{ .compatible = "atmel,dataflash", },	{ /* sentinel */ }};MODULE_DEVICE_TABLE(of, dataflash_dt_ids);#endif static const struct spi_device_id dataflash_spi_ids[] = {	{ .name = "at45", },	{ .name = "dataflash", },	{ /* sentinel */ }};MODULE_DEVICE_TABLE(spi, dataflash_spi_ids); /* ......................................................................... */ /* * Return the status of the DataFlash device. */static inline int dataflash_status(struct spi_device *spi){	/* NOTE:  at45db321c over 25 MHz wants to write	 * a dummy byte after the opcode...	 */	return spi_w8r8(spi, OP_READ_STATUS);} /* * Poll the DataFlash device until it is READY. * This usually takes 5-20 msec or so; more for sector erase. */static int dataflash_waitready(struct spi_device *spi){	int	status; 	for (;;) {		status = dataflash_status(spi);		if (status < 0) {			dev_dbg(&spi->dev, "status %d?\n", status);			status = 0;		} 		if (status & (1 << 7))	/* RDY/nBSY */			return status; 		usleep_range(3000, 4000);	}} /* ......................................................................... */ /* * Erase pages of flash. */static int dataflash_erase(struct mtd_info *mtd, struct erase_info *instr){	struct dataflash	*priv = mtd->priv;	struct spi_device	*spi = priv->spi;	struct spi_transfer	x = { };	struct spi_message	msg;	unsigned		blocksize = priv->page_size << 3;	u8			*command;	u32			rem; 	dev_dbg(&spi->dev, "erase addr=0x%llx len 0x%llx\n",		(long long)instr->addr, (long long)instr->len); 	div_u64_rem(instr->len, priv->page_size, &rem);	if (rem)		return -EINVAL;	div_u64_rem(instr->addr, priv->page_size, &rem);	if (rem)		return -EINVAL; 	spi_message_init(&msg); 	x.tx_buf = command = priv->command;	x.len = 4;	spi_message_add_tail(&x, &msg); 	mutex_lock(&priv->lock);	while (instr->len > 0) {		unsigned int	pageaddr;		int		status;		int		do_block; 		/* Calculate flash page address; use block erase (for speed) if		 * we're at a block boundary and need to erase the whole block.		 */		pageaddr = div_u64(instr->addr, priv->page_size);		do_block = (pageaddr & 0x7) == 0 && instr->len >= blocksize;		pageaddr = pageaddr << priv->page_offset; 		command[0] = do_block ? OP_ERASE_BLOCK : OP_ERASE_PAGE;		command[1] = (u8)(pageaddr >> 16);		command[2] = (u8)(pageaddr >> 8);		command[3] = 0; 		dev_dbg(&spi->dev, "ERASE %s: (%x) %x %x %x [%i]\n",			do_block ? "block" : "page",			command[0], command[1], command[2], command[3],			pageaddr); 		status = spi_sync(spi, &msg);		(void) dataflash_waitready(spi); 		if (status < 0) {			dev_err(&spi->dev, "erase %x, err %d\n",				pageaddr, status);			/* REVISIT:  can retry instr->retries times; or			 * giveup and instr->fail_addr = instr->addr;			 */			continue;		} 		if (do_block) {			instr->addr += blocksize;			instr->len -= blocksize;		} else {			instr->addr += priv->page_size;			instr->len -= priv->page_size;		}	}	mutex_unlock(&priv->lock); 	return 0;} /* * Read from the DataFlash device. *   from   : Start offset in flash device *   len    : Amount to read *   retlen : About of data actually read *   buf    : Buffer containing the data */static int dataflash_read(struct mtd_info *mtd, loff_t from, size_t len,			       size_t *retlen, u_char *buf){	struct dataflash	*priv = mtd->priv;	struct spi_transfer	x[2] = { };	struct spi_message	msg;	unsigned int		addr;	u8			*command;	int			status; 	dev_dbg(&priv->spi->dev, "read 0x%x..0x%x\n",		  (unsigned int)from, (unsigned int)(from + len)); 	/* Calculate flash page/byte address */	addr = (((unsigned)from / priv->page_size) << priv->page_offset)		+ ((unsigned)from % priv->page_size); 	command = priv->command; 	dev_dbg(&priv->spi->dev, "READ: (%x) %x %x %x\n",		command[0], command[1], command[2], command[3]); 	spi_message_init(&msg); 	x[0].tx_buf = command;	x[0].len = 8;	spi_message_add_tail(&x[0], &msg); 	x[1].rx_buf = buf;	x[1].len = len;	spi_message_add_tail(&x[1], &msg); 	mutex_lock(&priv->lock); 	/* Continuous read, max clock = f(car) which may be less than	 * the peak rate available.  Some chips support commands with	 * fewer "don't care" bytes.  Both buffers stay unchanged.	 */	command[0] = OP_READ_CONTINUOUS;	command[1] = (u8)(addr >> 16);	command[2] = (u8)(addr >> 8);	command[3] = (u8)(addr >> 0);	/* plus 4 "don't care" bytes */ 	status = spi_sync(priv->spi, &msg);	mutex_unlock(&priv->lock); 	if (status >= 0) {		*retlen = msg.actual_length - 8;		status = 0;	} else		dev_dbg(&priv->spi->dev, "read %x..%x --> %d\n",			(unsigned)from, (unsigned)(from + len),			status);	return status;} /* * Write to the DataFlash device. *   to     : Start offset in flash device *   len    : Amount to write *   retlen : Amount of data actually written *   buf    : Buffer containing the data */static int dataflash_write(struct mtd_info *mtd, loff_t to, size_t len,				size_t * retlen, const u_char * buf){	struct dataflash	*priv = mtd->priv;	struct spi_device	*spi = priv->spi;	struct spi_transfer	x[2] = { };	struct spi_message	msg;	unsigned int		pageaddr, addr, offset, writelen;	size_t			remaining = len;	u_char			*writebuf = (u_char *) buf;	int			status = -EINVAL;	u8			*command; 	dev_dbg(&spi->dev, "write 0x%x..0x%x\n",		(unsigned int)to, (unsigned int)(to + len)); 	spi_message_init(&msg); 	x[0].tx_buf = command = priv->command;	x[0].len = 4;	spi_message_add_tail(&x[0], &msg); 	pageaddr = ((unsigned)to / priv->page_size);	offset = ((unsigned)to % priv->page_size);	if (offset + len > priv->page_size)		writelen = priv->page_size - offset;	else		writelen = len; 	mutex_lock(&priv->lock);	while (remaining > 0) {		dev_dbg(&spi->dev, "write @ %i:%i len=%i\n",			pageaddr, offset, writelen); 		/* REVISIT:		 * (a) each page in a sector must be rewritten at least		 *     once every 10K sibling erase/program operations.		 * (b) for pages that are already erased, we could		 *     use WRITE+MWRITE not PROGRAM for ~30% speedup.		 * (c) WRITE to buffer could be done while waiting for		 *     a previous MWRITE/MWERASE to complete ...		 * (d) error handling here seems to be mostly missing.		 *		 * Two persistent bits per page, plus a per-sector counter,		 * could support (a) and (b) ... we might consider using		 * the second half of sector zero, which is just one block,		 * to track that state.  (On AT91, that sector should also		 * support boot-from-DataFlash.)		 */ 		addr = pageaddr << priv->page_offset; 		/* (1) Maybe transfer partial page to Buffer1 */		if (writelen != priv->page_size) {			command[0] = OP_TRANSFER_BUF1;			command[1] = (addr & 0x00FF0000) >> 16;			command[2] = (addr & 0x0000FF00) >> 8;			command[3] = 0; 			dev_dbg(&spi->dev, "TRANSFER: (%x) %x %x %x\n",				command[0], command[1], command[2], command[3]); 			status = spi_sync(spi, &msg);			if (status < 0)				dev_dbg(&spi->dev, "xfer %u -> %d\n",					addr, status); 			(void) dataflash_waitready(priv->spi);		} 		/* (2) Program full page via Buffer1 */		addr += offset;		command[0] = OP_PROGRAM_VIA_BUF1;		command[1] = (addr & 0x00FF0000) >> 16;		command[2] = (addr & 0x0000FF00) >> 8;		command[3] = (addr & 0x000000FF); 		dev_dbg(&spi->dev, "PROGRAM: (%x) %x %x %x\n",			command[0], command[1], command[2], command[3]); 		x[1].tx_buf = writebuf;		x[1].len = writelen;		spi_message_add_tail(x + 1, &msg);		status = spi_sync(spi, &msg);		spi_transfer_del(x + 1);		if (status < 0)			dev_dbg(&spi->dev, "pgm %u/%u -> %d\n",				addr, writelen, status); 		(void) dataflash_waitready(priv->spi);  #ifdef CONFIG_MTD_DATAFLASH_WRITE_VERIFY 		/* (3) Compare to Buffer1 */		addr = pageaddr << priv->page_offset;		command[0] = OP_COMPARE_BUF1;		command[1] = (addr & 0x00FF0000) >> 16;		command[2] = (addr & 0x0000FF00) >> 8;		command[3] = 0; 		dev_dbg(&spi->dev, "COMPARE: (%x) %x %x %x\n",			command[0], command[1], command[2], command[3]); 		status = spi_sync(spi, &msg);		if (status < 0)			dev_dbg(&spi->dev, "compare %u -> %d\n",				addr, status); 		status = dataflash_waitready(priv->spi); 		/* Check result of the compare operation */		if (status & (1 << 6)) {			dev_err(&spi->dev, "compare page %u, err %d\n",				pageaddr, status);			remaining = 0;			status = -EIO;			break;		} else			status = 0; #endif	/* CONFIG_MTD_DATAFLASH_WRITE_VERIFY */ 		remaining = remaining - writelen;		pageaddr++;		offset = 0;		writebuf += writelen;		*retlen += writelen; 		if (remaining > priv->page_size)			writelen = priv->page_size;		else			writelen = remaining;	}	mutex_unlock(&priv->lock); 	return status;} /* ......................................................................... */ #ifdef CONFIG_MTD_DATAFLASH_OTP static int dataflash_get_otp_info(struct mtd_info *mtd, size_t len,				  size_t *retlen, struct otp_info *info){	/* Report both blocks as identical:  bytes 0..64, locked.	 * Unless the user block changed from all-ones, we can't	 * tell whether it's still writable; so we assume it isn't.	 */	info->start = 0;	info->length = 64;	info->locked = 1;	*retlen = sizeof(*info);	return 0;} static ssize_t otp_read(struct spi_device *spi, unsigned base,		u8 *buf, loff_t off, size_t len){	struct spi_message	m;	size_t			l;	u8			*scratch;	struct spi_transfer	t;	int			status; 	if (off > 64)		return -EINVAL; 	if ((off + len) > 64)		len = 64 - off; 	spi_message_init(&m); 	l = 4 + base + off + len;	scratch = kzalloc(l, GFP_KERNEL);	if (!scratch)		return -ENOMEM; 	/* OUT: OP_READ_SECURITY, 3 don't-care bytes, zeroes	 * IN:  ignore 4 bytes, data bytes 0..N (max 127)	 */	scratch[0] = OP_READ_SECURITY; 	memset(&t, 0, sizeof t);	t.tx_buf = scratch;	t.rx_buf = scratch;	t.len = l;	spi_message_add_tail(&t, &m); 	dataflash_waitready(spi); 	status = spi_sync(spi, &m);	if (status >= 0) {		memcpy(buf, scratch + 4 + base + off, len);		status = len;	} 	kfree(scratch);	return status;} 

Lines 1–500 of 946. Load more