4 * Copyright (C) 2008 Atmel Corporation
5 * Copyright (C) 2010 Reinhard Meyer, EMK Elektronik
7 * Licensed under the GPL-2 or later.
13 #include <spi_flash.h>
16 #include "spi_flash_internal.h"
18 static void spi_flash_addr(u32 addr
, u8
*cmd
)
20 /* cmd[0] is actual command */
26 static int spi_flash_read_write(struct spi_slave
*spi
,
27 const u8
*cmd
, size_t cmd_len
,
28 const u8
*data_out
, u8
*data_in
,
31 unsigned long flags
= SPI_XFER_BEGIN
;
35 flags
|= SPI_XFER_END
;
37 ret
= spi_xfer(spi
, cmd_len
* 8, cmd
, NULL
, flags
);
39 debug("SF: Failed to send command (%zu bytes): %d\n",
41 } else if (data_len
!= 0) {
42 ret
= spi_xfer(spi
, data_len
* 8, data_out
, data_in
, SPI_XFER_END
);
44 debug("SF: Failed to transfer %zu bytes of data: %d\n",
51 int spi_flash_cmd(struct spi_slave
*spi
, u8 cmd
, void *response
, size_t len
)
53 return spi_flash_cmd_read(spi
, &cmd
, 1, response
, len
);
56 int spi_flash_cmd_read(struct spi_slave
*spi
, const u8
*cmd
,
57 size_t cmd_len
, void *data
, size_t data_len
)
59 return spi_flash_read_write(spi
, cmd
, cmd_len
, NULL
, data
, data_len
);
62 int spi_flash_cmd_write(struct spi_slave
*spi
, const u8
*cmd
, size_t cmd_len
,
63 const void *data
, size_t data_len
)
65 return spi_flash_read_write(spi
, cmd
, cmd_len
, data
, NULL
, data_len
);
68 int spi_flash_read_common(struct spi_flash
*flash
, const u8
*cmd
,
69 size_t cmd_len
, void *data
, size_t data_len
)
71 struct spi_slave
*spi
= flash
->spi
;
75 ret
= spi_flash_cmd_read(spi
, cmd
, cmd_len
, data
, data_len
);
81 int spi_flash_cmd_read_fast(struct spi_flash
*flash
, u32 offset
,
82 size_t len
, void *data
)
86 cmd
[0] = CMD_READ_ARRAY_FAST
;
87 spi_flash_addr(offset
, cmd
);
90 return spi_flash_read_common(flash
, cmd
, sizeof(cmd
), data
, len
);
93 int spi_flash_cmd_poll_bit(struct spi_flash
*flash
, unsigned long timeout
,
96 struct spi_slave
*spi
= flash
->spi
;
97 unsigned long timebase
;
101 ret
= spi_xfer(spi
, 8, &cmd
, NULL
, SPI_XFER_BEGIN
);
103 debug("SF: Failed to send command %02x: %d\n", cmd
, ret
);
107 timebase
= get_timer(0);
111 ret
= spi_xfer(spi
, 8, NULL
, &status
, 0);
115 if ((status
& poll_bit
) == 0)
118 } while (get_timer(timebase
) < timeout
);
120 spi_xfer(spi
, 0, NULL
, NULL
, SPI_XFER_END
);
122 if ((status
& poll_bit
) == 0)
126 debug("SF: time out!\n");
130 int spi_flash_cmd_wait_ready(struct spi_flash
*flash
, unsigned long timeout
)
132 return spi_flash_cmd_poll_bit(flash
, timeout
,
133 CMD_READ_STATUS
, STATUS_WIP
);
136 int spi_flash_cmd_erase(struct spi_flash
*flash
, u8 erase_cmd
,
137 u32 offset
, size_t len
)
139 u32 start
, end
, erase_size
;
143 erase_size
= flash
->sector_size
;
144 if (offset
% erase_size
|| len
% erase_size
) {
145 debug("SF: Erase offset/length not multiple of erase size\n");
149 ret
= spi_claim_bus(flash
->spi
);
151 debug("SF: Unable to claim SPI bus\n");
159 while (offset
< end
) {
160 spi_flash_addr(offset
, cmd
);
161 offset
+= erase_size
;
163 debug("SF: erase %2x %2x %2x %2x (%x)\n", cmd
[0], cmd
[1],
164 cmd
[2], cmd
[3], offset
);
166 ret
= spi_flash_cmd(flash
->spi
, CMD_WRITE_ENABLE
, NULL
, 0);
170 ret
= spi_flash_cmd_write(flash
->spi
, cmd
, sizeof(cmd
), NULL
, 0);
174 ret
= spi_flash_cmd_wait_ready(flash
, SPI_FLASH_PAGE_ERASE_TIMEOUT
);
179 debug("SF: Successfully erased %lu bytes @ %#x\n",
180 len
* erase_size
, start
);
183 spi_release_bus(flash
->spi
);
188 * The following table holds all device probe functions
190 * shift: number of continuation bytes before the ID
191 * idcode: the expected IDCODE or 0xff for non JEDEC devices
192 * probe: the function to call
194 * Non JEDEC devices should be ordered in the table such that
195 * the probe functions with best detection algorithms come first.
197 * Several matching entries are permitted, they will be tried
198 * in sequence until a probe function returns non NULL.
200 * IDCODE_CONT_LEN may be redefined if a device needs to declare a
201 * larger "shift" value. IDCODE_PART_LEN generally shouldn't be
202 * changed. This is the max number of bytes probe functions may
203 * examine when looking up part-specific identification info.
205 * Probe functions will be given the idcode buffer starting at their
206 * manu id byte (the "idcode" in the table below). In other words,
207 * all of the continuation bytes will be skipped (the "shift" below).
209 #define IDCODE_CONT_LEN 0
210 #define IDCODE_PART_LEN 5
211 static const struct {
214 struct spi_flash
*(*probe
) (struct spi_slave
*spi
, u8
*idcode
);
216 /* Keep it sorted by define name */
217 #ifdef CONFIG_SPI_FLASH_ATMEL
218 { 0, 0x1f, spi_flash_probe_atmel
, },
220 #ifdef CONFIG_SPI_FLASH_EON
221 { 0, 0x1c, spi_flash_probe_eon
, },
223 #ifdef CONFIG_SPI_FLASH_MACRONIX
224 { 0, 0xc2, spi_flash_probe_macronix
, },
226 #ifdef CONFIG_SPI_FLASH_SPANSION
227 { 0, 0x01, spi_flash_probe_spansion
, },
229 #ifdef CONFIG_SPI_FLASH_SST
230 { 0, 0xbf, spi_flash_probe_sst
, },
232 #ifdef CONFIG_SPI_FLASH_STMICRO
233 { 0, 0x20, spi_flash_probe_stmicro
, },
235 #ifdef CONFIG_SPI_FLASH_WINBOND
236 { 0, 0xef, spi_flash_probe_winbond
, },
238 #ifdef CONFIG_SPI_FRAM_RAMTRON
239 { 6, 0xc2, spi_fram_probe_ramtron
, },
240 # undef IDCODE_CONT_LEN
241 # define IDCODE_CONT_LEN 6
243 /* Keep it sorted by best detection */
244 #ifdef CONFIG_SPI_FLASH_STMICRO
245 { 0, 0xff, spi_flash_probe_stmicro
, },
247 #ifdef CONFIG_SPI_FRAM_RAMTRON_NON_JEDEC
248 { 0, 0xff, spi_fram_probe_ramtron
, },
251 #define IDCODE_LEN (IDCODE_CONT_LEN + IDCODE_PART_LEN)
253 struct spi_flash
*spi_flash_probe(unsigned int bus
, unsigned int cs
,
254 unsigned int max_hz
, unsigned int spi_mode
)
256 struct spi_slave
*spi
;
257 struct spi_flash
*flash
= NULL
;
259 u8 idcode
[IDCODE_LEN
], *idp
;
261 spi
= spi_setup_slave(bus
, cs
, max_hz
, spi_mode
);
263 printf("SF: Failed to set up slave\n");
267 ret
= spi_claim_bus(spi
);
269 debug("SF: Failed to claim SPI bus: %d\n", ret
);
273 /* Read the ID codes */
274 ret
= spi_flash_cmd(spi
, CMD_READ_ID
, idcode
, sizeof(idcode
));
279 printf("SF: Got idcodes\n");
280 print_buffer(0, idcode
, 1, sizeof(idcode
), 0);
283 /* count the number of continuation bytes */
284 for (shift
= 0, idp
= idcode
;
285 shift
< IDCODE_CONT_LEN
&& *idp
== 0x7f;
289 /* search the table for matches in shift and id */
290 for (i
= 0; i
< ARRAY_SIZE(flashes
); ++i
)
291 if (flashes
[i
].shift
== shift
&& flashes
[i
].idcode
== *idp
) {
292 /* we have a match, call probe */
293 flash
= flashes
[i
].probe(spi
, idp
);
299 printf("SF: Unsupported manufacturer %02x\n", *idp
);
300 goto err_manufacturer_probe
;
303 printf("SF: Detected %s with page size ", flash
->name
);
304 print_size(flash
->sector_size
, ", total ");
305 print_size(flash
->size
, "\n");
307 spi_release_bus(spi
);
311 err_manufacturer_probe
:
313 spi_release_bus(spi
);
319 void spi_flash_free(struct spi_flash
*flash
)
321 spi_free_slave(flash
->spi
);