]>
Commit | Line | Data |
---|---|---|
83d290c5 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
d25ce7d2 | 2 | /* |
a5e8199a | 3 | * Common SPI flash Interface |
d25ce7d2 HS |
4 | * |
5 | * Copyright (C) 2008 Atmel Corporation | |
a5e8199a | 6 | * Copyright (C) 2013 Jagannadha Sutradharudu Teki, Xilinx Inc. |
d25ce7d2 | 7 | */ |
a5e8199a | 8 | |
d25ce7d2 HS |
9 | #ifndef _SPI_FLASH_H_ |
10 | #define _SPI_FLASH_H_ | |
11 | ||
4c2dbefd | 12 | #include <dm.h> /* Because we dereference struct udevice here */ |
e06ab654 | 13 | #include <linux/types.h> |
c4e88623 | 14 | #include <linux/mtd/spi-nor.h> |
d25ce7d2 | 15 | |
abe66b1b PD |
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 | ||
ff0960f9 | 30 | struct spi_slave; |
33adfb5f | 31 | |
4c2dbefd SG |
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); | |
a58986ca SG |
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); | |
d25ce7d2 HS |
50 | }; |
51 | ||
4c2dbefd SG |
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 | |
8d987abc SG |
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 | ||
a58986ca SG |
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 | ||
4806fcea SG |
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 | ||
4c2dbefd SG |
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 | ||
4c2dbefd | 128 | static inline int spi_flash_read(struct spi_flash *flash, u32 offset, |
8d987abc | 129 | size_t len, void *buf) |
4c2dbefd | 130 | { |
8d987abc | 131 | return spi_flash_read_dm(flash->dev, offset, len, buf); |
4c2dbefd SG |
132 | } |
133 | ||
134 | static inline int spi_flash_write(struct spi_flash *flash, u32 offset, | |
8d987abc | 135 | size_t len, const void *buf) |
4c2dbefd | 136 | { |
8d987abc | 137 | return spi_flash_write_dm(flash->dev, offset, len, buf); |
4c2dbefd SG |
138 | } |
139 | ||
140 | static inline int spi_flash_erase(struct spi_flash *flash, u32 offset, | |
8d987abc | 141 | size_t len) |
4c2dbefd | 142 | { |
8d987abc | 143 | return spi_flash_erase_dm(flash->dev, offset, len); |
4c2dbefd SG |
144 | } |
145 | ||
146 | struct sandbox_state; | |
147 | ||
148 | int sandbox_sf_bind_emul(struct sandbox_state *state, int busnum, int cs, | |
008dcddf | 149 | struct udevice *bus, ofnode node, const char *spec); |
4c2dbefd SG |
150 | |
151 | void sandbox_sf_unbind_emul(struct sandbox_state *state, int busnum, int cs); | |
152 | ||
153 | #else | |
d25ce7d2 HS |
154 | struct spi_flash *spi_flash_probe(unsigned int bus, unsigned int cs, |
155 | unsigned int max_hz, unsigned int spi_mode); | |
0efc0249 | 156 | |
d25ce7d2 HS |
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 | { | |
c4e88623 V |
162 | struct mtd_info *mtd = &flash->mtd; |
163 | size_t retlen; | |
164 | ||
165 | return mtd->_read(mtd, offset, len, &retlen, buf); | |
d25ce7d2 HS |
166 | } |
167 | ||
168 | static inline int spi_flash_write(struct spi_flash *flash, u32 offset, | |
169 | size_t len, const void *buf) | |
170 | { | |
c4e88623 V |
171 | struct mtd_info *mtd = &flash->mtd; |
172 | size_t retlen; | |
173 | ||
174 | return mtd->_write(mtd, offset, len, &retlen, buf); | |
d25ce7d2 HS |
175 | } |
176 | ||
177 | static inline int spi_flash_erase(struct spi_flash *flash, u32 offset, | |
178 | size_t len) | |
179 | { | |
c4e88623 V |
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); | |
d25ce7d2 | 193 | } |
4c2dbefd | 194 | #endif |
d25ce7d2 | 195 | |
c3c016cf FE |
196 | static inline int spi_flash_protect(struct spi_flash *flash, u32 ofs, u32 len, |
197 | bool prot) | |
198 | { | |
439fcb9b | 199 | if (!flash->flash_lock || !flash->flash_unlock) |
c3c016cf FE |
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 | ||
d25ce7d2 | 208 | #endif /* _SPI_FLASH_H_ */ |