mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-07-12 14:16:17 +09:00
c3c016cf75
Many SPI flashes have protection bits (BP2, BP1 and BP0) in the status register that can protect selected regions of the SPI NOR. Take these bits into account when performing erase operations, making sure that the protected areas are skipped. Tested on a mx6qsabresd: => sf probe SF: Detected M25P32 with page size 256 Bytes, erase size 64 KiB, total 4 MiB => sf protect lock 0x3f0000 0x10000 => sf erase 0x3f0000 0x10000 offset 0x3f0000 is protected and cannot be erased SF: 65536 bytes @ 0x3f0000 Erased: ERROR => sf protect unlock 0x3f0000 0x10000 => sf erase 0x3f0000 0x10000 SF: 65536 bytes @ 0x3f0000 Erased: OK Signed-off-by: Fabio Estevam <fabio.estevam@freescale.com> [re-worked to fit the lock common to dm and non-dm] Signed-off-by: Jagan Teki <jteki@openedev.com> Reviewed-by: Tom Rini <trini@konsulko.com> Reviewed-by: Heiko Schocher <hs@denx.de> Reviewed-by: Jagan Teki <jteki@openedev.com>
253 lines
7.3 KiB
C
253 lines
7.3 KiB
C
/*
|
|
* Common SPI flash Interface
|
|
*
|
|
* Copyright (C) 2008 Atmel Corporation
|
|
* Copyright (C) 2013 Jagannadha Sutradharudu Teki, Xilinx Inc.
|
|
*
|
|
* 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
|
|
* version 2 as published by the Free Software Foundation.
|
|
*/
|
|
|
|
#ifndef _SPI_FLASH_H_
|
|
#define _SPI_FLASH_H_
|
|
|
|
#include <dm.h> /* Because we dereference struct udevice here */
|
|
#include <linux/types.h>
|
|
|
|
#ifndef CONFIG_SF_DEFAULT_SPEED
|
|
# define CONFIG_SF_DEFAULT_SPEED 1000000
|
|
#endif
|
|
#ifndef CONFIG_SF_DEFAULT_MODE
|
|
# define CONFIG_SF_DEFAULT_MODE SPI_MODE_3
|
|
#endif
|
|
#ifndef CONFIG_SF_DEFAULT_CS
|
|
# define CONFIG_SF_DEFAULT_CS 0
|
|
#endif
|
|
#ifndef CONFIG_SF_DEFAULT_BUS
|
|
# define CONFIG_SF_DEFAULT_BUS 0
|
|
#endif
|
|
|
|
struct spi_slave;
|
|
|
|
/**
|
|
* struct spi_flash - SPI flash structure
|
|
*
|
|
* @spi: SPI slave
|
|
* @dev: SPI flash device
|
|
* @name: Name of SPI flash
|
|
* @dual_flash: Indicates dual flash memories - dual stacked, parallel
|
|
* @shift: Flash shift useful in dual parallel
|
|
* @flags: Indication of spi flash flags
|
|
* @size: Total flash size
|
|
* @page_size: Write (page) size
|
|
* @sector_size: Sector size
|
|
* @erase_size: Erase size
|
|
* @bank_read_cmd: Bank read cmd
|
|
* @bank_write_cmd: Bank write cmd
|
|
* @bank_curr: Current flash bank
|
|
* @erase_cmd: Erase cmd 4K, 32K, 64K
|
|
* @read_cmd: Read cmd - Array Fast, Extn read and quad read.
|
|
* @write_cmd: Write cmd - page and quad program.
|
|
* @dummy_byte: Dummy cycles for read operation.
|
|
* @memory_map: Address of read-only SPI flash access
|
|
* @flash_lock: lock a region of the SPI Flash
|
|
* @flash_unlock: unlock a region of the SPI Flash
|
|
* @flash_is_locked: check if a region of the SPI Flash is completely locked
|
|
* @read: Flash read ops: Read len bytes at offset into buf
|
|
* Supported cmds: Fast Array Read
|
|
* @write: Flash write ops: Write len bytes from buf into offset
|
|
* Supported cmds: Page Program
|
|
* @erase: Flash erase ops: Erase len bytes from offset
|
|
* Supported cmds: Sector erase 4K, 32K, 64K
|
|
* return 0 - Success, 1 - Failure
|
|
*/
|
|
struct spi_flash {
|
|
struct spi_slave *spi;
|
|
#ifdef CONFIG_DM_SPI_FLASH
|
|
struct udevice *dev;
|
|
#endif
|
|
const char *name;
|
|
u8 dual_flash;
|
|
u8 shift;
|
|
u16 flags;
|
|
|
|
u32 size;
|
|
u32 page_size;
|
|
u32 sector_size;
|
|
u32 erase_size;
|
|
#ifdef CONFIG_SPI_FLASH_BAR
|
|
u8 bank_read_cmd;
|
|
u8 bank_write_cmd;
|
|
u8 bank_curr;
|
|
#endif
|
|
u8 erase_cmd;
|
|
u8 read_cmd;
|
|
u8 write_cmd;
|
|
u8 dummy_byte;
|
|
|
|
void *memory_map;
|
|
|
|
int (*flash_lock)(struct spi_flash *flash, u32 ofs, size_t len);
|
|
int (*flash_unlock)(struct spi_flash *flash, u32 ofs, size_t len);
|
|
int (*flash_is_locked)(struct spi_flash *flash, u32 ofs, size_t len);
|
|
#ifndef CONFIG_DM_SPI_FLASH
|
|
/*
|
|
* These are not strictly needed for driver model, but keep them here
|
|
* while the transition is in progress.
|
|
*
|
|
* Normally each driver would provide its own operations, but for
|
|
* SPI flash most chips use the same algorithms. One approach is
|
|
* to create a 'common' SPI flash device which knows how to talk
|
|
* to most devices, and then allow other drivers to be used instead
|
|
* if required, perhaps with a way of scanning through the list to
|
|
* find the driver that matches the device.
|
|
*/
|
|
int (*read)(struct spi_flash *flash, u32 offset, size_t len, void *buf);
|
|
int (*write)(struct spi_flash *flash, u32 offset, size_t len,
|
|
const void *buf);
|
|
int (*erase)(struct spi_flash *flash, u32 offset, size_t len);
|
|
#endif
|
|
};
|
|
|
|
struct dm_spi_flash_ops {
|
|
int (*read)(struct udevice *dev, u32 offset, size_t len, void *buf);
|
|
int (*write)(struct udevice *dev, u32 offset, size_t len,
|
|
const void *buf);
|
|
int (*erase)(struct udevice *dev, u32 offset, size_t len);
|
|
};
|
|
|
|
/* Access the serial operations for a device */
|
|
#define sf_get_ops(dev) ((struct dm_spi_flash_ops *)(dev)->driver->ops)
|
|
|
|
#ifdef CONFIG_DM_SPI_FLASH
|
|
/**
|
|
* spi_flash_read_dm() - Read data from SPI flash
|
|
*
|
|
* @dev: SPI flash device
|
|
* @offset: Offset into device in bytes to read from
|
|
* @len: Number of bytes to read
|
|
* @buf: Buffer to put the data that is read
|
|
* @return 0 if OK, -ve on error
|
|
*/
|
|
int spi_flash_read_dm(struct udevice *dev, u32 offset, size_t len, void *buf);
|
|
|
|
/**
|
|
* spi_flash_write_dm() - Write data to SPI flash
|
|
*
|
|
* @dev: SPI flash device
|
|
* @offset: Offset into device in bytes to write to
|
|
* @len: Number of bytes to write
|
|
* @buf: Buffer containing bytes to write
|
|
* @return 0 if OK, -ve on error
|
|
*/
|
|
int spi_flash_write_dm(struct udevice *dev, u32 offset, size_t len,
|
|
const void *buf);
|
|
|
|
/**
|
|
* spi_flash_erase_dm() - Erase blocks of the SPI flash
|
|
*
|
|
* Note that @len must be a muiltiple of the flash sector size.
|
|
*
|
|
* @dev: SPI flash device
|
|
* @offset: Offset into device in bytes to start erasing
|
|
* @len: Number of bytes to erase
|
|
* @return 0 if OK, -ve on error
|
|
*/
|
|
int spi_flash_erase_dm(struct udevice *dev, u32 offset, size_t len);
|
|
|
|
int spi_flash_probe_bus_cs(unsigned int busnum, unsigned int cs,
|
|
unsigned int max_hz, unsigned int spi_mode,
|
|
struct udevice **devp);
|
|
|
|
/* Compatibility function - this is the old U-Boot API */
|
|
struct spi_flash *spi_flash_probe(unsigned int bus, unsigned int cs,
|
|
unsigned int max_hz, unsigned int spi_mode);
|
|
|
|
/* Compatibility function - this is the old U-Boot API */
|
|
void spi_flash_free(struct spi_flash *flash);
|
|
|
|
int spi_flash_remove(struct udevice *flash);
|
|
|
|
static inline int spi_flash_read(struct spi_flash *flash, u32 offset,
|
|
size_t len, void *buf)
|
|
{
|
|
return spi_flash_read_dm(flash->dev, offset, len, buf);
|
|
}
|
|
|
|
static inline int spi_flash_write(struct spi_flash *flash, u32 offset,
|
|
size_t len, const void *buf)
|
|
{
|
|
return spi_flash_write_dm(flash->dev, offset, len, buf);
|
|
}
|
|
|
|
static inline int spi_flash_erase(struct spi_flash *flash, u32 offset,
|
|
size_t len)
|
|
{
|
|
return spi_flash_erase_dm(flash->dev, offset, len);
|
|
}
|
|
|
|
struct sandbox_state;
|
|
|
|
int sandbox_sf_bind_emul(struct sandbox_state *state, int busnum, int cs,
|
|
struct udevice *bus, int of_offset, const char *spec);
|
|
|
|
void sandbox_sf_unbind_emul(struct sandbox_state *state, int busnum, int cs);
|
|
|
|
#else
|
|
struct spi_flash *spi_flash_probe(unsigned int bus, unsigned int cs,
|
|
unsigned int max_hz, unsigned int spi_mode);
|
|
|
|
/**
|
|
* Set up a new SPI flash from an fdt node
|
|
*
|
|
* @param blob Device tree blob
|
|
* @param slave_node Pointer to this SPI slave node in the device tree
|
|
* @param spi_node Cached pointer to the SPI interface this node belongs
|
|
* to
|
|
* @return 0 if ok, -1 on error
|
|
*/
|
|
struct spi_flash *spi_flash_probe_fdt(const void *blob, int slave_node,
|
|
int spi_node);
|
|
|
|
void spi_flash_free(struct spi_flash *flash);
|
|
|
|
static inline int spi_flash_read(struct spi_flash *flash, u32 offset,
|
|
size_t len, void *buf)
|
|
{
|
|
return flash->read(flash, offset, len, buf);
|
|
}
|
|
|
|
static inline int spi_flash_write(struct spi_flash *flash, u32 offset,
|
|
size_t len, const void *buf)
|
|
{
|
|
return flash->write(flash, offset, len, buf);
|
|
}
|
|
|
|
static inline int spi_flash_erase(struct spi_flash *flash, u32 offset,
|
|
size_t len)
|
|
{
|
|
return flash->erase(flash, offset, len);
|
|
}
|
|
#endif
|
|
|
|
static inline int spi_flash_protect(struct spi_flash *flash, u32 ofs, u32 len,
|
|
bool prot)
|
|
{
|
|
if (!flash->flash_lock)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (prot)
|
|
return flash->flash_lock(flash, ofs, len);
|
|
else
|
|
return flash->flash_unlock(flash, ofs, len);
|
|
}
|
|
|
|
void spi_boot(void) __noreturn;
|
|
void spi_spl_load_image(uint32_t offs, unsigned int size, void *vdst);
|
|
|
|
#endif /* _SPI_FLASH_H_ */
|