LXR uboot/include/spi

   1/*
   2 * Common SPI flash Interface
   3 *
   4 * Copyright (C) 2008 Atmel Corporation
   5 * Copyright (C) 2013 Jagannadha Sutradharudu Teki, Xilinx Inc.
   6 *
   7 * SPDX-License-Identifier:     GPL-2.0
   8 */
   9
  10#ifndef _SPI_FLASH_H_
  11#define _SPI_FLASH_H_
  12
  13#include <dm.h> /* Because we dereference struct udevice here */
  14#include <linux/types.h>
  15
  16#ifndef CONFIG_SF_DEFAULT_SPEED
  17# define CONFIG_SF_DEFAULT_SPEED        1000000
  18#endif
  19#ifndef CONFIG_SF_DEFAULT_MODE
  20# define CONFIG_SF_DEFAULT_MODE         SPI_MODE_3
  21#endif
  22#ifndef CONFIG_SF_DEFAULT_CS
  23# define CONFIG_SF_DEFAULT_CS           0
  24#endif
  25#ifndef CONFIG_SF_DEFAULT_BUS
  26# define CONFIG_SF_DEFAULT_BUS          0
  27#endif
  28
  29struct spi_slave;
  30
  31/**
  32 * struct spi_flash - SPI flash structure
  33 *
  34 * @spi:                SPI slave
  35 * @dev:                SPI flash device
  36 * @name:               Name of SPI flash
  37 * @dual_flash:         Indicates dual flash memories - dual stacked, parallel
  38 * @shift:              Flash shift useful in dual parallel
  39 * @flags:              Indication of spi flash flags
  40 * @size:               Total flash size
  41 * @page_size:          Write (page) size
  42 * @sector_size:        Sector size
  43 * @erase_size:         Erase size
  44 * @bank_read_cmd:      Bank read cmd
  45 * @bank_write_cmd:     Bank write cmd
  46 * @bank_curr:          Current flash bank
  47 * @erase_cmd:          Erase cmd 4K, 32K, 64K
  48 * @read_cmd:           Read cmd - Array Fast, Extn read and quad read.
  49 * @write_cmd:          Write cmd - page and quad program.
  50 * @dummy_byte:         Dummy cycles for read operation.
  51 * @memory_map:         Address of read-only SPI flash access
  52 * @flash_lock:         lock a region of the SPI Flash
  53 * @flash_unlock:       unlock a region of the SPI Flash
  54 * @flash_is_locked:    check if a region of the SPI Flash is completely locked
  55 * @read:               Flash read ops: Read len bytes at offset into buf
  56 *                      Supported cmds: Fast Array Read
  57 * @write:              Flash write ops: Write len bytes from buf into offset
  58 *                      Supported cmds: Page Program
  59 * @erase:              Flash erase ops: Erase len bytes from offset
  60 *                      Supported cmds: Sector erase 4K, 32K, 64K
  61 * return 0 - Success, 1 - Failure
  62 */
  63struct spi_flash {
  64        struct spi_slave *spi;
  65#ifdef CONFIG_DM_SPI_FLASH
  66        struct udevice *dev;
  67#endif
  68        const char *name;
  69        u8 dual_flash;
  70        u8 shift;
  71        u16 flags;
  72
  73        u32 size;
  74        u32 page_size;
  75        u32 sector_size;
  76        u32 erase_size;
  77#ifdef CONFIG_SPI_FLASH_BAR
  78        u8 bank_read_cmd;
  79        u8 bank_write_cmd;
  80        u8 bank_curr;
  81#endif
  82        u8 erase_cmd;
  83        u8 read_cmd;
  84        u8 write_cmd;
  85        u8 dummy_byte;
  86
  87        void *memory_map;
  88
  89        int (*flash_lock)(struct spi_flash *flash, u32 ofs, size_t len);
  90        int (*flash_unlock)(struct spi_flash *flash, u32 ofs, size_t len);
  91        int (*flash_is_locked)(struct spi_flash *flash, u32 ofs, size_t len);
  92#ifndef CONFIG_DM_SPI_FLASH
  93        /*
  94         * These are not strictly needed for driver model, but keep them here
  95         * while the transition is in progress.
  96         *
  97         * Normally each driver would provide its own operations, but for
  98         * SPI flash most chips use the same algorithms. One approach is
  99         * to create a 'common' SPI flash device which knows how to talk
 100         * to most devices, and then allow other drivers to be used instead
 101         * if required, perhaps with a way of scanning through the list to
 102         * find the driver that matches the device.
 103         */
 104        int (*read)(struct spi_flash *flash, u32 offset, size_t len, void *buf);
 105        int (*write)(struct spi_flash *flash, u32 offset, size_t len,
 106                        const void *buf);
 107        int (*erase)(struct spi_flash *flash, u32 offset, size_t len);
 108#endif
 109};
 110
 111struct dm_spi_flash_ops {
 112        int (*read)(struct udevice *dev, u32 offset, size_t len, void *buf);
 113        int (*write)(struct udevice *dev, u32 offset, size_t len,
 114                     const void *buf);
 115        int (*erase)(struct udevice *dev, u32 offset, size_t len);
 116};
 117
 118/* Access the serial operations for a device */
 119#define sf_get_ops(dev) ((struct dm_spi_flash_ops *)(dev)->driver->ops)
 120
 121#ifdef CONFIG_DM_SPI_FLASH
 122/**
 123 * spi_flash_read_dm() - Read data from SPI flash
 124 *
 125 * @dev:        SPI flash device
 126 * @offset:     Offset into device in bytes to read from
 127 * @len:        Number of bytes to read
 128 * @buf:        Buffer to put the data that is read
 129 * @return 0 if OK, -ve on error
 130 */
 131int spi_flash_read_dm(struct udevice *dev, u32 offset, size_t len, void *buf);
 132
 133/**
 134 * spi_flash_write_dm() - Write data to SPI flash
 135 *
 136 * @dev:        SPI flash device
 137 * @offset:     Offset into device in bytes to write to
 138 * @len:        Number of bytes to write
 139 * @buf:        Buffer containing bytes to write
 140 * @return 0 if OK, -ve on error
 141 */
 142int spi_flash_write_dm(struct udevice *dev, u32 offset, size_t len,
 143                       const void *buf);
 144
 145/**
 146 * spi_flash_erase_dm() - Erase blocks of the SPI flash
 147 *
 148 * Note that @len must be a muiltiple of the flash sector size.
 149 *
 150 * @dev:        SPI flash device
 151 * @offset:     Offset into device in bytes to start erasing
 152 * @len:        Number of bytes to erase
 153 * @return 0 if OK, -ve on error
 154 */
 155int spi_flash_erase_dm(struct udevice *dev, u32 offset, size_t len);
 156
 157int spi_flash_probe_bus_cs(unsigned int busnum, unsigned int cs,
 158                           unsigned int max_hz, unsigned int spi_mode,
 159                           struct udevice **devp);
 160
 161/* Compatibility function - this is the old U-Boot API */
 162struct spi_flash *spi_flash_probe(unsigned int bus, unsigned int cs,
 163                                  unsigned int max_hz, unsigned int spi_mode);
 164
 165/* Compatibility function - this is the old U-Boot API */
 166void spi_flash_free(struct spi_flash *flash);
 167
 168static inline int spi_flash_read(struct spi_flash *flash, u32 offset,
 169                                 size_t len, void *buf)
 170{
 171        return spi_flash_read_dm(flash->dev, offset, len, buf);
 172}
 173
 174static inline int spi_flash_write(struct spi_flash *flash, u32 offset,
 175                                  size_t len, const void *buf)
 176{
 177        return spi_flash_write_dm(flash->dev, offset, len, buf);
 178}
 179
 180static inline int spi_flash_erase(struct spi_flash *flash, u32 offset,
 181                                  size_t len)
 182{
 183        return spi_flash_erase_dm(flash->dev, offset, len);
 184}
 185
 186struct sandbox_state;
 187
 188int sandbox_sf_bind_emul(struct sandbox_state *state, int busnum, int cs,
 189                         struct udevice *bus, int of_offset, const char *spec);
 190
 191void sandbox_sf_unbind_emul(struct sandbox_state *state, int busnum, int cs);
 192
 193#else
 194struct spi_flash *spi_flash_probe(unsigned int bus, unsigned int cs,
 195                unsigned int max_hz, unsigned int spi_mode);
 196
 197/**
 198 * Set up a new SPI flash from an fdt node
 199 *
 200 * @param blob          Device tree blob
 201 * @param slave_node    Pointer to this SPI slave node in the device tree
 202 * @param spi_node      Cached pointer to the SPI interface this node belongs
 203 *                      to
 204 * @return 0 if ok, -1 on error
 205 */
 206struct spi_flash *spi_flash_probe_fdt(const void *blob, int slave_node,
 207                                      int spi_node);
 208
 209void spi_flash_free(struct spi_flash *flash);
 210
 211static inline int spi_flash_read(struct spi_flash *flash, u32 offset,
 212                size_t len, void *buf)
 213{
 214        return flash->read(flash, offset, len, buf);
 215}
 216
 217static inline int spi_flash_write(struct spi_flash *flash, u32 offset,
 218                size_t len, const void *buf)
 219{
 220        return flash->write(flash, offset, len, buf);
 221}
 222
 223static inline int spi_flash_erase(struct spi_flash *flash, u32 offset,
 224                size_t len)
 225{
 226        return flash->erase(flash, offset, len);
 227}
 228#endif
 229
 230static inline int spi_flash_protect(struct spi_flash *flash, u32 ofs, u32 len,
 231                                        bool prot)
 232{
 233        if (!flash->flash_lock || !flash->flash_unlock)
 234                return -EOPNOTSUPP;
 235
 236        if (prot)
 237                return flash->flash_lock(flash, ofs, len);
 238        else
 239                return flash->flash_unlock(flash, ofs, len);
 240}
 241
 242#endif /* _SPI_FLASH_H_ */
 243