drivers: mtd: qspi: Add quad read support
[glsdk/glsdk-u-boot.git] / drivers / mtd / spi / spi_flash.c
1 /*
2  * SPI flash interface
3  *
4  * Copyright (C) 2008 Atmel Corporation
5  * Copyright (C) 2010 Reinhard Meyer, EMK Elektronik
6  *
7  * Licensed under the GPL-2 or later.
8  */
10 #include <common.h>
11 #include <fdtdec.h>
12 #include <malloc.h>
13 #include <spi.h>
14 #include <spi_flash.h>
15 #include <watchdog.h>
17 #include "spi_flash_internal.h"
19 DECLARE_GLOBAL_DATA_PTR;
21 static void spi_flash_addr(u32 addr, u8 *cmd)
22 {
23         /* cmd[0] is actual command */
24         cmd[1] = addr >> 16;
25         cmd[2] = addr >> 8;
26         cmd[3] = addr >> 0;
27 }
29 static int spi_flash_read_write(struct spi_slave *spi,
30                                 const u8 *cmd, size_t cmd_len,
31                                 const u8 *data_out, u8 *data_in,
32                                 size_t data_len)
33 {
34         unsigned long flags = SPI_XFER_BEGIN;
35         int ret;
37         if (data_len == 0)
38                 flags |= SPI_XFER_END;
40         ret = spi_xfer(spi, cmd_len * 8, cmd, NULL, flags);
41         if (ret) {
42                 debug("SF: Failed to send command (%zu bytes): %d\n",
43                                 cmd_len, ret);
44         } else if (data_len != 0) {
45                 if (spi->quad_enable)
46                         flags = SPI_6WIRE;
47                 else
48                         flags = 0;
50                 ret = spi_xfer(spi, data_len * 8, data_out, data_in, flags | SPI_XFER_END);
51                 if (ret)
52                         debug("SF: Failed to transfer %zu bytes of data: %d\n",
53                                         data_len, ret);
54         }
56         return ret;
57 }
59 int spi_flash_cmd(struct spi_slave *spi, u8 cmd, void *response, size_t len)
60 {
61         return spi_flash_cmd_read(spi, &cmd, 1, response, len);
62 }
64 int spi_flash_cmd_read(struct spi_slave *spi, const u8 *cmd,
65                 size_t cmd_len, void *data, size_t data_len)
66 {
67         return spi_flash_read_write(spi, cmd, cmd_len, NULL, data, data_len);
68 }
70 int spi_flash_cmd_write(struct spi_slave *spi, const u8 *cmd, size_t cmd_len,
71                 const void *data, size_t data_len)
72 {
73         return spi_flash_read_write(spi, cmd, cmd_len, data, NULL, data_len);
74 }
76 int spi_flash_cmd_wait_ready(struct spi_flash *flash, unsigned long timeout)
77 {
78         struct spi_slave *spi = flash->spi;
79         unsigned long timebase;
80         int ret;
81         u8 status;
82         u8 check_status = 0x0;
83         u8 poll_bit = STATUS_WIP;
84         u8 cmd = flash->poll_cmd;
86         if (cmd == CMD_FLAG_STATUS) {
87                 poll_bit = STATUS_PEC;
88                 check_status = poll_bit;
89         }
91         ret = spi_xfer(spi, 8, &cmd, NULL, SPI_XFER_BEGIN);
92         if (ret) {
93                 debug("SF: fail to read %s status register\n",
94                         cmd == CMD_READ_STATUS ? "read" : "flag");
95                 return ret;
96         }
98         timebase = get_timer(0);
99         do {
100                 WATCHDOG_RESET();
102                 ret = spi_xfer(spi, 8, NULL, &status, 0);
103                 if (ret)
104                         return -1;
106                 if ((status & poll_bit) == check_status)
107                         break;
109         } while (get_timer(timebase) < timeout);
111         spi_xfer(spi, 0, NULL, NULL, SPI_XFER_END);
113         if ((status & poll_bit) == check_status)
114                 return 0;
116         /* Timed out */
117         debug("SF: time out!\n");
118         return -1;
121 int spi_flash_write_common(struct spi_flash *flash, const u8 *cmd,
122                 size_t cmd_len, const void *buf, size_t buf_len)
124         struct spi_slave *spi = flash->spi;
125         unsigned long timeout = SPI_FLASH_PROG_TIMEOUT;
126         int ret;
128         if (buf == NULL)
129                 timeout = SPI_FLASH_PAGE_ERASE_TIMEOUT;
131         ret = spi_claim_bus(flash->spi);
132         if (ret) {
133                 debug("SF: unable to claim SPI bus\n");
134                 return ret;
135         }
137         ret = spi_flash_cmd_write_enable(flash);
138         if (ret < 0) {
139                 debug("SF: enabling write failed\n");
140                 return ret;
141         }
143         ret = spi_flash_cmd_write(spi, cmd, cmd_len, buf, buf_len);
144         if (ret < 0) {
145                 debug("SF: write cmd failed\n");
146                 return ret;
147         }
149         ret = spi_flash_cmd_wait_ready(flash, timeout);
150         if (ret < 0) {
151                 debug("SF: write %s timed out\n",
152                         timeout == SPI_FLASH_PROG_TIMEOUT ?
153                         "program" : "page erase");
154                 return ret;
155         }
157         spi_release_bus(spi);
159         return ret;
162 int spi_flash_cmd_erase(struct spi_flash *flash, u32 offset, size_t len)
164         u32 erase_size;
165         u8 cmd[4];
166         int ret = -1;
168         erase_size = flash->sector_size;
169         if (offset % erase_size || len % erase_size) {
170                 debug("SF: Erase offset/length not multiple of erase size\n");
171                 return -1;
172         }
174         if (erase_size == 4096)
175                 cmd[0] = CMD_ERASE_4K;
176         else
177                 cmd[0] = CMD_ERASE_64K;
179         while (len) {
180 #ifdef CONFIG_SPI_FLASH_BAR
181                 u8 bank_sel;
183                 bank_sel = offset / SPI_FLASH_16MB_BOUN;
185                 ret = spi_flash_cmd_bankaddr_write(flash, bank_sel);
186                 if (ret) {
187                         debug("SF: fail to set bank%d\n", bank_sel);
188                         return ret;
189                 }
190 #endif
191                 spi_flash_addr(offset, cmd);
193                 debug("SF: erase %2x %2x %2x %2x (%x)\n", cmd[0], cmd[1],
194                       cmd[2], cmd[3], offset);
196                 ret = spi_flash_write_common(flash, cmd, sizeof(cmd), NULL, 0);
197                 if (ret < 0) {
198                         debug("SF: erase failed\n");
199                         break;
200                 }
202                 offset += erase_size;
203                 len -= erase_size;
204         }
206         return ret;
209 int spi_flash_cmd_write_multi(struct spi_flash *flash, u32 offset,
210                 size_t len, const void *buf)
212         unsigned long byte_addr, page_size;
213         size_t chunk_len, actual;
214         u8 cmd[4];
215         int ret = -1;
217         page_size = flash->page_size;
219         cmd[0] = CMD_PAGE_PROGRAM;
220         for (actual = 0; actual < len; actual += chunk_len) {
221 #ifdef CONFIG_SPI_FLASH_BAR
222                 u8 bank_sel;
224                 bank_sel = offset / SPI_FLASH_16MB_BOUN;
226                 ret = spi_flash_cmd_bankaddr_write(flash, bank_sel);
227                 if (ret) {
228                         debug("SF: fail to set bank%d\n", bank_sel);
229                         return ret;
230                 }
231 #endif
232                 byte_addr = offset % page_size;
233                 chunk_len = min(len - actual, page_size - byte_addr);
235                 if (flash->spi->max_write_size)
236                         chunk_len = min(chunk_len, flash->spi->max_write_size);
238                 spi_flash_addr(offset, cmd);
240                 debug("PP: 0x%p => cmd = { 0x%02x 0x%02x%02x%02x } chunk_len = %zu\n",
241                       buf + actual, cmd[0], cmd[1], cmd[2], cmd[3], chunk_len);
243                 ret = spi_flash_write_common(flash, cmd, sizeof(cmd),
244                                         buf + actual, chunk_len);
245                 if (ret < 0) {
246                         debug("SF: write failed\n");
247                         break;
248                 }
250                 offset += chunk_len;
251         }
253         return ret;
256 int spi_flash_read_common(struct spi_flash *flash, const u8 *cmd,
257                 size_t cmd_len, void *data, size_t data_len)
259         struct spi_slave *spi = flash->spi;
260         int ret;
262         ret = spi_claim_bus(flash->spi);
263         if (ret) {
264                 debug("SF: unable to claim SPI bus\n");
265                 return ret;
266         }
268         ret = spi_flash_cmd_read(spi, cmd, cmd_len, data, data_len);
269         if (ret < 0) {
270                 debug("SF: read cmd failed\n");
271                 return ret;
272         }
274         spi_release_bus(spi);
276         return ret;
279 int spi_flash_cmd_read_quad(struct spi_flash *flash, u32 offset,
280                 size_t len, void *data)
282         struct spi_slave *spi = flash->spi;
284         unsigned long page_addr, byte_addr, page_size;
285         size_t chunk_len, actual;
286         int ret = 0;
287         u8 cmd[5];
289         spi->quad_enable = 1;
290         /* Handle memory-mapped SPI */
291         if (flash->memory_map)
292                 memcpy(data, flash->memory_map + offset, len);
294         page_size = flash->page_size;
295         page_addr = offset / page_size;
296         byte_addr = offset % page_size;
298         cmd[0] = CMD_READ_ARRAY_QUAD;
299         for (actual = 0; actual < len; actual += chunk_len) {
300                 chunk_len = min(len - actual, page_size - byte_addr);
302                 cmd[1] = page_addr >> 8;
303                 cmd[2] = page_addr;
304                 cmd[3] = byte_addr;
305                 cmd[4] = 0x0;
307                 ret = spi_flash_read_common(flash, cmd, sizeof(cmd),
308                                 data + actual, chunk_len);
309                 if (ret < 0) {
310                         debug("SF: read failed");
311                         break;
312                 }
314                 byte_addr += chunk_len;
315                 if (byte_addr == page_size) {
316                         page_addr++;
317                         byte_addr = 0;
318                 }
319         }
321         return ret;
324 int spi_flash_cmd_read_fast(struct spi_flash *flash, u32 offset,
325                 size_t len, void *data)
327         u8 cmd[5], bank_sel = 0;
328         u32 remain_len, read_len;
329         int ret = -1;
331         /* Handle memory-mapped SPI */
332         if (flash->memory_map)
333                 memcpy(data, flash->memory_map + offset, len);
335         cmd[0] = CMD_READ_ARRAY_FAST;
336         cmd[4] = 0x00;
338         while (len) {
339 #ifdef CONFIG_SPI_FLASH_BAR
340                 bank_sel = offset / SPI_FLASH_16MB_BOUN;
342                 ret = spi_flash_cmd_bankaddr_write(flash, bank_sel);
343                 if (ret) {
344                         debug("SF: fail to set bank%d\n", bank_sel);
345                         return ret;
346                 }
347 #endif
348                 remain_len = (SPI_FLASH_16MB_BOUN * (bank_sel + 1) - offset);
349                 if (len < remain_len)
350                         read_len = len;
351                 else
352                         read_len = remain_len;
354                 spi_flash_addr(offset, cmd);
356                 ret = spi_flash_read_common(flash, cmd, sizeof(cmd),
357                                                         data, read_len);
358                 if (ret < 0) {
359                         debug("SF: read failed\n");
360                         break;
361                 }
363                 offset += read_len;
364                 len -= read_len;
365                 data += read_len;
366         }
368         return ret;
371 int spi_flash_cmd_write_status(struct spi_flash *flash, u8 sr)
373         u8 cmd;
374         int ret;
376         cmd = CMD_WRITE_STATUS;
377         ret = spi_flash_write_common(flash, &cmd, 1, &sr, 1);
378         if (ret < 0) {
379                 debug("SF: fail to write status register\n");
380                 return ret;
381         }
383         return 0;
386 #ifdef CONFIG_SPI_FLASH_BAR
387 int spi_flash_cmd_bankaddr_write(struct spi_flash *flash, u8 bank_sel)
389         u8 cmd;
390         int ret;
392         if (flash->bank_curr == bank_sel) {
393                 debug("SF: not require to enable bank%d\n", bank_sel);
394                 return 0;
395         }
397         cmd = flash->bank_write_cmd;
398         ret = spi_flash_write_common(flash, &cmd, 1, &bank_sel, 1);
399         if (ret < 0) {
400                 debug("SF: fail to write bank register\n");
401                 return ret;
402         }
403         flash->bank_curr = bank_sel;
405         return 0;
408 int spi_flash_bank_config(struct spi_flash *flash, u8 idcode0)
410         u8 cmd;
411         u8 curr_bank = 0;
413         /* discover bank cmds */
414         switch (idcode0) {
415         case SPI_FLASH_SPANSION_IDCODE0:
416                 flash->bank_read_cmd = CMD_BANKADDR_BRRD;
417                 flash->bank_write_cmd = CMD_BANKADDR_BRWR;
418                 break;
419         case SPI_FLASH_STMICRO_IDCODE0:
420         case SPI_FLASH_WINBOND_IDCODE0:
421                 flash->bank_read_cmd = CMD_EXTNADDR_RDEAR;
422                 flash->bank_write_cmd = CMD_EXTNADDR_WREAR;
423                 break;
424         default:
425                 printf("SF: Unsupported bank commands %02x\n", idcode0);
426                 return -1;
427         }
429         /* read the bank reg - on which bank the flash is in currently */
430         cmd = flash->bank_read_cmd;
431         if (flash->size > SPI_FLASH_16MB_BOUN) {
432                 if (spi_flash_read_common(flash, &cmd, 1, &curr_bank, 1)) {
433                         debug("SF: fail to read bank addr register\n");
434                         return -1;
435                 }
436                 flash->bank_curr = curr_bank;
437         } else {
438                 flash->bank_curr = curr_bank;
439         }
441         return 0;
443 #endif
445 int spi_flash_en_quad_mode(struct spi_flash *flash)
447         u8 stat, con, cd;
448         u16 cr;
449         int ret;
450         cd = CMD_WRITE_STATUS;
452         ret = spi_flash_cmd_write_enable(flash);
453         if (ret < 0) {
454                 debug("SF: enabling write failed\n");
455                 goto out;
456         }
457         ret = spi_flash_cmd(flash->spi, CMD_READ_STATUS, &stat, 1);
458         ret = spi_flash_cmd(flash->spi, CMD_READ_CONFIG, &con, 1);
459         if (ret < 0) {
460                 debug("%s: SF: read CR failed\n", __func__);
461                 goto out;
462         }
463         /* Byte 1 - status reg, Byte 2 - config reg */
464         cr = ((con | (0x1 << 1)) << 8) | (stat << 0);
466         ret = spi_flash_cmd_write(flash->spi, &cd, 1, &cr, 2);
467         if (ret) {
468                 debug("SF: fail to write conf register\n");
469                 goto out;
470         }
472         ret = spi_flash_cmd_wait_ready(flash, SPI_FLASH_PROG_TIMEOUT);
473         if (ret < 0) {
474                 debug("SF: write conf register timed out\n");
475                 goto out;
476         }
478         ret = spi_flash_cmd(flash->spi, CMD_READ_STATUS, &stat, 1);
479         ret = spi_flash_cmd(flash->spi, CMD_READ_CONFIG, &con, 1);
480         if (ret < 0) {
481                 debug("%s: SF: read CR failed\n", __func__);
482                 goto out;
483         }
484         debug("%s: *** CR = %x\n", __func__, con);
486         ret = spi_flash_cmd_write_disable(flash);
487         if (ret < 0) {
488                 debug("SF: disabling write failed\n");
489                 goto out;
490         }
491 out:
492         return ret;
495 #ifdef CONFIG_OF_CONTROL
496 int spi_flash_decode_fdt(const void *blob, struct spi_flash *flash)
498         fdt_addr_t addr;
499         fdt_size_t size;
500         int node;
502         /* If there is no node, do nothing */
503         node = fdtdec_next_compatible(blob, 0, COMPAT_GENERIC_SPI_FLASH);
504         if (node < 0)
505                 return 0;
507         addr = fdtdec_get_addr_size(blob, node, "memory-map", &size);
508         if (addr == FDT_ADDR_T_NONE) {
509                 debug("%s: Cannot decode address\n", __func__);
510                 return 0;
511         }
513         if (flash->size != size) {
514                 debug("%s: Memory map must cover entire device\n", __func__);
515                 return -1;
516         }
517         flash->memory_map = (void *)addr;
519         return 0;
521 #endif /* CONFIG_OF_CONTROL */
523 /*
524  * The following table holds all device probe functions
525  *
526  * shift:  number of continuation bytes before the ID
527  * idcode: the expected IDCODE or 0xff for non JEDEC devices
528  * probe:  the function to call
529  *
530  * Non JEDEC devices should be ordered in the table such that
531  * the probe functions with best detection algorithms come first.
532  *
533  * Several matching entries are permitted, they will be tried
534  * in sequence until a probe function returns non NULL.
535  *
536  * IDCODE_CONT_LEN may be redefined if a device needs to declare a
537  * larger "shift" value.  IDCODE_PART_LEN generally shouldn't be
538  * changed.  This is the max number of bytes probe functions may
539  * examine when looking up part-specific identification info.
540  *
541  * Probe functions will be given the idcode buffer starting at their
542  * manu id byte (the "idcode" in the table below).  In other words,
543  * all of the continuation bytes will be skipped (the "shift" below).
544  */
545 #define IDCODE_CONT_LEN 0
546 #define IDCODE_PART_LEN 5
547 static const struct {
548         const u8 shift;
549         const u8 idcode;
550         struct spi_flash *(*probe) (struct spi_slave *spi, u8 *idcode);
551 } flashes[] = {
552         /* Keep it sorted by define name */
553 #ifdef CONFIG_SPI_FLASH_ATMEL
554         { 0, 0x1f, spi_flash_probe_atmel, },
555 #endif
556 #ifdef CONFIG_SPI_FLASH_EON
557         { 0, 0x1c, spi_flash_probe_eon, },
558 #endif
559 #ifdef CONFIG_SPI_FLASH_MACRONIX
560         { 0, 0xc2, spi_flash_probe_macronix, },
561 #endif
562 #ifdef CONFIG_SPI_FLASH_SPANSION
563         { 0, 0x01, spi_flash_probe_spansion, },
564 #endif
565 #ifdef CONFIG_SPI_FLASH_SST
566         { 0, 0xbf, spi_flash_probe_sst, },
567 #endif
568 #ifdef CONFIG_SPI_FLASH_STMICRO
569         { 0, 0x20, spi_flash_probe_stmicro, },
570 #endif
571 #ifdef CONFIG_SPI_FLASH_WINBOND
572         { 0, 0xef, spi_flash_probe_winbond, },
573 #endif
574 #ifdef CONFIG_SPI_FRAM_RAMTRON
575         { 6, 0xc2, spi_fram_probe_ramtron, },
576 # undef IDCODE_CONT_LEN
577 # define IDCODE_CONT_LEN 6
578 #endif
579         /* Keep it sorted by best detection */
580 #ifdef CONFIG_SPI_FLASH_STMICRO
581         { 0, 0xff, spi_flash_probe_stmicro, },
582 #endif
583 #ifdef CONFIG_SPI_FRAM_RAMTRON_NON_JEDEC
584         { 0, 0xff, spi_fram_probe_ramtron, },
585 #endif
586 };
587 #define IDCODE_LEN (IDCODE_CONT_LEN + IDCODE_PART_LEN)
589 struct spi_flash *spi_flash_probe(unsigned int bus, unsigned int cs,
590                 unsigned int max_hz, unsigned int spi_mode)
592         struct spi_slave *spi;
593         struct spi_flash *flash = NULL;
594         int ret, i, shift;
595         u8 idcode[IDCODE_LEN], *idp;
597         spi = spi_setup_slave(bus, cs, max_hz, spi_mode);
598         if (!spi) {
599                 printf("SF: Failed to set up slave\n");
600                 return NULL;
601         }
603         ret = spi_claim_bus(spi);
604         if (ret) {
605                 debug("SF: Failed to claim SPI bus: %d\n", ret);
606                 goto err_claim_bus;
607         }
609         /* Read the ID codes */
610         ret = spi_flash_cmd(spi, CMD_READ_ID, idcode, sizeof(idcode));
611         if (ret)
612                 goto err_read_id;
614 #ifdef DEBUG
615         printf("SF: Got idcodes\n");
616         print_buffer(0, idcode, 1, sizeof(idcode), 0);
617 #endif
619         /* count the number of continuation bytes */
620         for (shift = 0, idp = idcode;
621              shift < IDCODE_CONT_LEN && *idp == 0x7f;
622              ++shift, ++idp)
623                 continue;
625         /* search the table for matches in shift and id */
626         for (i = 0; i < ARRAY_SIZE(flashes); ++i)
627                 if (flashes[i].shift == shift && flashes[i].idcode == *idp) {
628                         /* we have a match, call probe */
629                         flash = flashes[i].probe(spi, idp);
630                         if (flash)
631                                 break;
632                 }
634         if (!flash) {
635                 printf("SF: Unsupported manufacturer %02x\n", *idp);
636                 goto err_manufacturer_probe;
637         }
639 #ifdef CONFIG_SPI_FLASH_BAR
640         /* Configure the BAR - disover bank cmds and read current bank  */
641         ret = spi_flash_bank_config(flash, *idp);
642         if (ret < 0)
643                 goto err_manufacturer_probe;
644 #endif
646 #ifdef CONFIG_SF_QUAD_RD
647         spi_flash_en_quad_mode(flash);
648 #endif
650 #ifdef CONFIG_OF_CONTROL
651         if (spi_flash_decode_fdt(gd->fdt_blob, flash)) {
652                 debug("SF: FDT decode error\n");
653                 goto err_manufacturer_probe;
654         }
655 #endif
656         printf("SF: Detected %s with page size ", flash->name);
657         print_size(flash->sector_size, ", total ");
658         print_size(flash->size, "");
659         if (flash->memory_map)
660                 printf(", mapped at %p", flash->memory_map);
661         puts("\n");
662 #ifndef CONFIG_SPI_FLASH_BAR
663         if (flash->size > SPI_FLASH_16MB_BOUN) {
664                 puts("SF: Warning - Only lower 16MiB accessible,");
665                 puts(" Full access #define CONFIG_SPI_FLASH_BAR\n");
666         }
667 #endif
669         spi_release_bus(spi);
671         return flash;
673 err_manufacturer_probe:
674 err_read_id:
675         spi_release_bus(spi);
676 err_claim_bus:
677         spi_free_slave(spi);
678         return NULL;
681 void *spi_flash_do_alloc(int offset, int size, struct spi_slave *spi,
682                          const char *name)
684         struct spi_flash *flash;
685         void *ptr;
687         ptr = malloc(size);
688         if (!ptr) {
689                 debug("SF: Failed to allocate memory\n");
690                 return NULL;
691         }
692         memset(ptr, '\0', size);
693         flash = (struct spi_flash *)(ptr + offset);
695         /* Set up some basic fields - caller will sort out sizes */
696         flash->spi = spi;
697         flash->name = name;
698         flash->poll_cmd = CMD_READ_STATUS;
700 #ifdef CONFIG_SF_QUAD_RD
701         flash->read = spi_flash_cmd_read_quad;
702 #else
703         flash->read = spi_flash_cmd_read_fast;
704 #endif
705         flash->write = spi_flash_cmd_write_multi;
706         flash->erase = spi_flash_cmd_erase;
708         return flash;
711 void spi_flash_free(struct spi_flash *flash)
713         spi_free_slave(flash->spi);
714         free(flash);