Merge branch 'next'
[platform/kernel/u-boot.git] / 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          * get_sw_write_prot() - Check state of software write-protect feature
39          *
40          * SPI flash chips can lock a region of the flash defined by a
41          * 'protected area'. This function checks if this protected area is
42          * defined.
43          *
44          * @dev:        SPI flash device
45          * @return 0 if no region is write-protected, 1 if a region is
46          *      write-protected, -ENOSYS if the driver does not implement this,
47          *      other -ve value on error
48          */
49         int (*get_sw_write_prot)(struct udevice *dev);
50 };
51
52 /* Access the serial operations for a device */
53 #define sf_get_ops(dev) ((struct dm_spi_flash_ops *)(dev)->driver->ops)
54
55 #ifdef CONFIG_DM_SPI_FLASH
56 /**
57  * spi_flash_read_dm() - Read data from SPI flash
58  *
59  * @dev:        SPI flash device
60  * @offset:     Offset into device in bytes to read from
61  * @len:        Number of bytes to read
62  * @buf:        Buffer to put the data that is read
63  * @return 0 if OK, -ve on error
64  */
65 int spi_flash_read_dm(struct udevice *dev, u32 offset, size_t len, void *buf);
66
67 /**
68  * spi_flash_write_dm() - Write data to SPI flash
69  *
70  * @dev:        SPI flash device
71  * @offset:     Offset into device in bytes to write to
72  * @len:        Number of bytes to write
73  * @buf:        Buffer containing bytes to write
74  * @return 0 if OK, -ve on error
75  */
76 int spi_flash_write_dm(struct udevice *dev, u32 offset, size_t len,
77                        const void *buf);
78
79 /**
80  * spi_flash_erase_dm() - Erase blocks of the SPI flash
81  *
82  * Note that @len must be a muiltiple of the flash sector size.
83  *
84  * @dev:        SPI flash device
85  * @offset:     Offset into device in bytes to start erasing
86  * @len:        Number of bytes to erase
87  * @return 0 if OK, -ve on error
88  */
89 int spi_flash_erase_dm(struct udevice *dev, u32 offset, size_t len);
90
91 /**
92  * spl_flash_get_sw_write_prot() - Check state of software write-protect feature
93  *
94  * SPI flash chips can lock a region of the flash defined by a
95  * 'protected area'. This function checks if this protected area is
96  * defined.
97  *
98  * @dev:        SPI flash device
99  * @return 0 if no region is write-protected, 1 if a region is
100  *      write-protected, -ENOSYS if the driver does not implement this,
101  *      other -ve value on error
102  */
103 int spl_flash_get_sw_write_prot(struct udevice *dev);
104
105 /**
106  * spi_flash_std_probe() - Probe a SPI flash device
107  *
108  * This is the standard internal method for probing a SPI flash device to
109  * determine its type. It can be used in chip-specific drivers which need to
110  * do this, typically with of-platdata
111  *
112  * @dev: SPI-flash device to probe
113  * @return 0 if OK, -ve on error
114  */
115 int spi_flash_std_probe(struct udevice *dev);
116
117 int spi_flash_probe_bus_cs(unsigned int busnum, unsigned int cs,
118                            unsigned int max_hz, unsigned int spi_mode,
119                            struct udevice **devp);
120
121 /* Compatibility function - this is the old U-Boot API */
122 struct spi_flash *spi_flash_probe(unsigned int bus, unsigned int cs,
123                                   unsigned int max_hz, unsigned int spi_mode);
124
125 /* Compatibility function - this is the old U-Boot API */
126 void spi_flash_free(struct spi_flash *flash);
127
128 static inline int spi_flash_read(struct spi_flash *flash, u32 offset,
129                                  size_t len, void *buf)
130 {
131         return spi_flash_read_dm(flash->dev, offset, len, buf);
132 }
133
134 static inline int spi_flash_write(struct spi_flash *flash, u32 offset,
135                                   size_t len, const void *buf)
136 {
137         return spi_flash_write_dm(flash->dev, offset, len, buf);
138 }
139
140 static inline int spi_flash_erase(struct spi_flash *flash, u32 offset,
141                                   size_t len)
142 {
143         return spi_flash_erase_dm(flash->dev, offset, len);
144 }
145
146 struct sandbox_state;
147
148 int sandbox_sf_bind_emul(struct sandbox_state *state, int busnum, int cs,
149                          struct udevice *bus, ofnode node, const char *spec);
150
151 void sandbox_sf_unbind_emul(struct sandbox_state *state, int busnum, int cs);
152
153 #else
154 struct spi_flash *spi_flash_probe(unsigned int bus, unsigned int cs,
155                 unsigned int max_hz, unsigned int spi_mode);
156
157 void spi_flash_free(struct spi_flash *flash);
158
159 static inline int spi_flash_read(struct spi_flash *flash, u32 offset,
160                 size_t len, void *buf)
161 {
162         struct mtd_info *mtd = &flash->mtd;
163         size_t retlen;
164
165         return mtd->_read(mtd, offset, len, &retlen, buf);
166 }
167
168 static inline int spi_flash_write(struct spi_flash *flash, u32 offset,
169                 size_t len, const void *buf)
170 {
171         struct mtd_info *mtd = &flash->mtd;
172         size_t retlen;
173
174         return mtd->_write(mtd, offset, len, &retlen, buf);
175 }
176
177 static inline int spi_flash_erase(struct spi_flash *flash, u32 offset,
178                 size_t len)
179 {
180         struct mtd_info *mtd = &flash->mtd;
181         struct erase_info instr;
182
183         if (offset % mtd->erasesize || len % mtd->erasesize) {
184                 printf("SF: Erase offset/length not multiple of erase size\n");
185                 return -EINVAL;
186         }
187
188         memset(&instr, 0, sizeof(instr));
189         instr.addr = offset;
190         instr.len = len;
191
192         return mtd->_erase(mtd, &instr);
193 }
194 #endif
195
196 static inline int spi_flash_protect(struct spi_flash *flash, u32 ofs, u32 len,
197                                         bool prot)
198 {
199         if (!flash->flash_lock || !flash->flash_unlock)
200                 return -EOPNOTSUPP;
201
202         if (prot)
203                 return flash->flash_lock(flash, ofs, len);
204         else
205                 return flash->flash_unlock(flash, ofs, len);
206 }
207
208 #endif /* _SPI_FLASH_H_ */