include/spi_flash.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Common SPI flash Interface
   4  *
   5  * Copyright (C) 2008 Atmel Corporation
   6  * Copyright (C) 2013 Jagannadha Sutradharudu Teki, Xilinx Inc.
   7  */
   8
   9 #ifndef _SPI_FLASH_H_
  10 #define _SPI_FLASH_H_
  11
  12 #include <dm.h> /* Because we dereference struct udevice here */
  13 #include <linux/types.h>
  14 #include <linux/mtd/spi-nor.h>
  15
  16 /* by default ENV use the same parameters than SF command */
  17 #ifndef CONFIG_ENV_SPI_BUS
  18 # define CONFIG_ENV_SPI_BUS     CONFIG_SF_DEFAULT_BUS
  19 #endif
  20 #ifndef CONFIG_ENV_SPI_CS
  21 # define CONFIG_ENV_SPI_CS      CONFIG_SF_DEFAULT_CS
  22 #endif
  23 #ifndef CONFIG_ENV_SPI_MAX_HZ
  24 # define CONFIG_ENV_SPI_MAX_HZ  CONFIG_SF_DEFAULT_SPEED
  25 #endif
  26 #ifndef CONFIG_ENV_SPI_MODE
  27 # define CONFIG_ENV_SPI_MODE    CONFIG_SF_DEFAULT_MODE
  28 #endif
  29
  30 struct spi_slave;
  31
  32 struct dm_spi_flash_ops {
  33         int (*read)(struct udevice *dev, u32 offset, size_t len, void *buf);
  34         int (*write)(struct udevice *dev, u32 offset, size_t len,
  35                      const void *buf);
  36         int (*erase)(struct udevice *dev, u32 offset, size_t len);
  37 };
  38
  39 /* Access the serial operations for a device */
  40 #define sf_get_ops(dev) ((struct dm_spi_flash_ops *)(dev)->driver->ops)
  41
  42 #ifdef CONFIG_DM_SPI_FLASH
  43 /**
  44  * spi_flash_read_dm() - Read data from SPI flash
  45  *
  46  * @dev:        SPI flash device
  47  * @offset:     Offset into device in bytes to read from
  48  * @len:        Number of bytes to read
  49  * @buf:        Buffer to put the data that is read
  50  * @return 0 if OK, -ve on error
  51  */
  52 int spi_flash_read_dm(struct udevice *dev, u32 offset, size_t len, void *buf);
  53
  54 /**
  55  * spi_flash_write_dm() - Write data to SPI flash
  56  *
  57  * @dev:        SPI flash device
  58  * @offset:     Offset into device in bytes to write to
  59  * @len:        Number of bytes to write
  60  * @buf:        Buffer containing bytes to write
  61  * @return 0 if OK, -ve on error
  62  */
  63 int spi_flash_write_dm(struct udevice *dev, u32 offset, size_t len,
  64                        const void *buf);
  65
  66 /**
  67  * spi_flash_erase_dm() - Erase blocks of the SPI flash
  68  *
  69  * Note that @len must be a muiltiple of the flash sector size.
  70  *
  71  * @dev:        SPI flash device
  72  * @offset:     Offset into device in bytes to start erasing
  73  * @len:        Number of bytes to erase
  74  * @return 0 if OK, -ve on error
  75  */
  76 int spi_flash_erase_dm(struct udevice *dev, u32 offset, size_t len);
  77
  78 /**
  79  * spi_flash_std_probe() - Probe a SPI flash device
  80  *
  81  * This is the standard internal method for probing a SPI flash device to
  82  * determine its type. It can be used in chip-specific drivers which need to
  83  * do this, typically with of-platdata
  84  *
  85  * @dev: SPI-flash device to probe
  86  * @return 0 if OK, -ve on error
  87  */
  88 int spi_flash_std_probe(struct udevice *dev);
  89
  90 int spi_flash_probe_bus_cs(unsigned int busnum, unsigned int cs,
  91                            unsigned int max_hz, unsigned int spi_mode,
  92                            struct udevice **devp);
  93
  94 /* Compatibility function - this is the old U-Boot API */
  95 struct spi_flash *spi_flash_probe(unsigned int bus, unsigned int cs,
  96                                   unsigned int max_hz, unsigned int spi_mode);
  97
  98 /* Compatibility function - this is the old U-Boot API */
  99 void spi_flash_free(struct spi_flash *flash);
 100
 101 static inline int spi_flash_read(struct spi_flash *flash, u32 offset,
 102                                  size_t len, void *buf)
 103 {
 104         return spi_flash_read_dm(flash->dev, offset, len, buf);
 105 }
 106
 107 static inline int spi_flash_write(struct spi_flash *flash, u32 offset,
 108                                   size_t len, const void *buf)
 109 {
 110         return spi_flash_write_dm(flash->dev, offset, len, buf);
 111 }
 112
 113 static inline int spi_flash_erase(struct spi_flash *flash, u32 offset,
 114                                   size_t len)
 115 {
 116         return spi_flash_erase_dm(flash->dev, offset, len);
 117 }
 118
 119 struct sandbox_state;
 120
 121 int sandbox_sf_bind_emul(struct sandbox_state *state, int busnum, int cs,
 122                          struct udevice *bus, ofnode node, const char *spec);
 123
 124 void sandbox_sf_unbind_emul(struct sandbox_state *state, int busnum, int cs);
 125
 126 #else
 127 struct spi_flash *spi_flash_probe(unsigned int bus, unsigned int cs,
 128                 unsigned int max_hz, unsigned int spi_mode);
 129
 130 void spi_flash_free(struct spi_flash *flash);
 131
 132 static inline int spi_flash_read(struct spi_flash *flash, u32 offset,
 133                 size_t len, void *buf)
 134 {
 135         struct mtd_info *mtd = &flash->mtd;
 136         size_t retlen;
 137
 138         return mtd->_read(mtd, offset, len, &retlen, buf);
 139 }
 140
 141 static inline int spi_flash_write(struct spi_flash *flash, u32 offset,
 142                 size_t len, const void *buf)
 143 {
 144         struct mtd_info *mtd = &flash->mtd;
 145         size_t retlen;
 146
 147         return mtd->_write(mtd, offset, len, &retlen, buf);
 148 }
 149
 150 static inline int spi_flash_erase(struct spi_flash *flash, u32 offset,
 151                 size_t len)
 152 {
 153         struct mtd_info *mtd = &flash->mtd;
 154         struct erase_info instr;
 155
 156         if (offset % mtd->erasesize || len % mtd->erasesize) {
 157                 printf("SF: Erase offset/length not multiple of erase size\n");
 158                 return -EINVAL;
 159         }
 160
 161         memset(&instr, 0, sizeof(instr));
 162         instr.addr = offset;
 163         instr.len = len;
 164
 165         return mtd->_erase(mtd, &instr);
 166 }
 167 #endif
 168
 169 static inline int spi_flash_protect(struct spi_flash *flash, u32 ofs, u32 len,
 170                                         bool prot)
 171 {
 172         if (!flash->flash_lock || !flash->flash_unlock)
 173                 return -EOPNOTSUPP;
 174
 175         if (prot)
 176                 return flash->flash_lock(flash, ofs, len);
 177         else
 178                 return flash->flash_unlock(flash, ofs, len);
 179 }
 180
 181 #endif /* _SPI_FLASH_H_ */