mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-20 00:48:52 +09:00
![Lukasz Majewski](/assets/img/avatar_default.png)
This change allows more fine tuning of driver model based SPI support in SPL and TPL. It is now possible to explicitly enable/disable the DM_SPI support in SPL and TPL via Kconfig option. Before this change it was necessary to use: /* SPI Flash Configs */ #if defined(CONFIG_SPL_BUILD) #undef CONFIG_DM_SPI #undef CONFIG_DM_SPI_FLASH #undef CONFIG_SPI_FLASH_MTD #endif in the ./include/configs/<board>.h, which is error prone and shall be avoided when we strive to switch to Kconfig. The goal of this patch: Provide distinction for DM_SPI support in both U-Boot proper and SPL (TPL). Valid use case is when U-Boot proper wants to use DM_SPI, but SPL must still support non DM driver. Another use case is the conversion of non DM/DTS SPI driver to support DM/DTS. When such driver needs to work in both SPL and U-Boot proper, the distinction is needed in Kconfig (also if SPL version of the driver supports OF_PLATDATA). In the end of the day one would have to support following use cases (in single driver file - e.g. mxs_spi.c): - U-Boot proper driver supporting DT/DTS - U-Boot proper driver without DT/DTS support (deprecated) - SPL driver without DT/DTS support - SPL (and TPL) driver with DT/DTS (when the SoC has enough resources to run full blown DT/DTS) - SPL driver with DT/DTS and SPL_OF_PLATDATA (when one have constrained environment with no fitImage and OF_LIBFDT support). Some boards do require SPI support (with DM) in SPL (TPL) and some only have DM_SPI{_FLASH} defined to allow compiling SPL. This patch converts #ifdef CONFIG_DM_SPI* to #if CONFIG_IS_ENABLED(DM_SPI) and provides corresponding defines in Kconfig. Signed-off-by: Lukasz Majewski <lukma@denx.de> Tested-by: Adam Ford <aford173@gmail.com> #da850-evm Signed-off-by: Hou Zhiqiang <Zhiqiang.Hou@nxp.com> [trini: Fixup a few platforms] Signed-off-by: Tom Rini <trini@konsulko.com>
182 lines
4.9 KiB
C
182 lines
4.9 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
/*
|
|
* Common SPI flash Interface
|
|
*
|
|
* Copyright (C) 2008 Atmel Corporation
|
|
* Copyright (C) 2013 Jagannadha Sutradharudu Teki, Xilinx Inc.
|
|
*/
|
|
|
|
#ifndef _SPI_FLASH_H_
|
|
#define _SPI_FLASH_H_
|
|
|
|
#include <dm.h> /* Because we dereference struct udevice here */
|
|
#include <linux/types.h>
|
|
#include <linux/mtd/spi-nor.h>
|
|
|
|
/* by default ENV use the same parameters than SF command */
|
|
#ifndef CONFIG_ENV_SPI_BUS
|
|
# define CONFIG_ENV_SPI_BUS CONFIG_SF_DEFAULT_BUS
|
|
#endif
|
|
#ifndef CONFIG_ENV_SPI_CS
|
|
# define CONFIG_ENV_SPI_CS CONFIG_SF_DEFAULT_CS
|
|
#endif
|
|
#ifndef CONFIG_ENV_SPI_MAX_HZ
|
|
# define CONFIG_ENV_SPI_MAX_HZ CONFIG_SF_DEFAULT_SPEED
|
|
#endif
|
|
#ifndef CONFIG_ENV_SPI_MODE
|
|
# define CONFIG_ENV_SPI_MODE CONFIG_SF_DEFAULT_MODE
|
|
#endif
|
|
|
|
struct spi_slave;
|
|
|
|
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)
|
|
|
|
#if CONFIG_IS_ENABLED(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);
|
|
|
|
/**
|
|
* spi_flash_std_probe() - Probe a SPI flash device
|
|
*
|
|
* This is the standard internal method for probing a SPI flash device to
|
|
* determine its type. It can be used in chip-specific drivers which need to
|
|
* do this, typically with of-platdata
|
|
*
|
|
* @dev: SPI-flash device to probe
|
|
* @return 0 if OK, -ve on error
|
|
*/
|
|
int spi_flash_std_probe(struct udevice *dev);
|
|
|
|
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);
|
|
|
|
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, ofnode node, 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);
|
|
|
|
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)
|
|
{
|
|
struct mtd_info *mtd = &flash->mtd;
|
|
size_t retlen;
|
|
|
|
return mtd->_read(mtd, offset, len, &retlen, buf);
|
|
}
|
|
|
|
static inline int spi_flash_write(struct spi_flash *flash, u32 offset,
|
|
size_t len, const void *buf)
|
|
{
|
|
struct mtd_info *mtd = &flash->mtd;
|
|
size_t retlen;
|
|
|
|
return mtd->_write(mtd, offset, len, &retlen, buf);
|
|
}
|
|
|
|
static inline int spi_flash_erase(struct spi_flash *flash, u32 offset,
|
|
size_t len)
|
|
{
|
|
struct mtd_info *mtd = &flash->mtd;
|
|
struct erase_info instr;
|
|
|
|
if (offset % mtd->erasesize || len % mtd->erasesize) {
|
|
printf("SF: Erase offset/length not multiple of erase size\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
memset(&instr, 0, sizeof(instr));
|
|
instr.addr = offset;
|
|
instr.len = len;
|
|
|
|
return mtd->_erase(mtd, &instr);
|
|
}
|
|
#endif
|
|
|
|
static inline int spi_flash_protect(struct spi_flash *flash, u32 ofs, u32 len,
|
|
bool prot)
|
|
{
|
|
if (!flash->flash_lock || !flash->flash_unlock)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (prot)
|
|
return flash->flash_lock(flash, ofs, len);
|
|
else
|
|
return flash->flash_unlock(flash, ofs, len);
|
|
}
|
|
|
|
#endif /* _SPI_FLASH_H_ */
|