Eric Lee / smarc-uboot

Download as
Browse Code ยป

Commit c68c03f52badc90951dbf8a054c0e500e04bf365

Authored by Tuomas Tynkkynen
Committed by Tom Rini
1 parent 95688de311
Exists in smarc_8mq_lf_v2020.04 and in 20 other branches 8qm-imx_v2020.04_5.4.70_2.3.0, emb_lf-6.6.52-2.2.0, emb_lf_v2022.04, emb_lf_v2023.04, emb_lf_v2024.04, pitx_8mp_lf_v2020.04, smarc-8m-android-10.0.0_2.6.0, smarc-8m-android-11.0.0_2.0.0, smarc-8mp-android-11.0.0_2.0.0, smarc-imx6_v2018.03_4.14.98_2.0.0_ga, smarc-imx7_v2018.03_4.14.98_2.0.0_ga, smarc-imx_v2018.03_4.14.78_1.0.0_ga, smarc_8m-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8m-imx_v2019.04_4.19.35_1.1.0, smarc_8m_00d0-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8mm-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8mm-imx_v2019.04_4.19.35_1.1.0, smarc_8mm-imx_v2020.04_5.4.24_2.1.0, smarc_8mp_lf_v2020.04, smarc_8mq-imx_v2020.04_5.4.24_2.1.0

Drop CONFIG_HAS_DATAFLASH 

Last user of this option went away in commit:

fdc7718999 ("board: usb_a9263: Update to support DT and DM")

Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>

Showing 31 changed files with 16 additions and 1626 deletions Side-by-side Diff

... ... @@ -2312,13 +2312,6 @@
2312 2312 this is instead controlled by the value of
2313 2313 /config/load-environment.
2314 2314  
2315   -- DataFlash Support:
2316   - CONFIG_HAS_DATAFLASH
2317   -
2318   - Defining this option enables DataFlash features and
2319   - allows to read/write in Dataflash via the standard
2320   - commands cp, md...
2321   -
2322 2315 - Serial Flash support
2323 2316 Usage requires an initial 'sf probe' to define the serial
2324 2317 flash parameters, followed by read/write/erase/update
arch/arm/mach-at91/arm926ejs/at91sam9260_devices.c
Diff comments   View file @ c68c03f
... ... @@ -58,7 +58,7 @@
58 58 at91_periph_clk_enable(ATMEL_ID_SYS);
59 59 }
60 60  
61   -#if defined(CONFIG_HAS_DATAFLASH) || defined(CONFIG_ATMEL_SPI)
  61 +#ifdef CONFIG_ATMEL_SPI
62 62 void at91_spi0_hw_init(unsigned long cs_mask)
63 63 {
64 64 at91_set_a_periph(AT91_PIO_PORTA, 0, PUP); /* SPI0_MISO */
arch/arm/mach-at91/arm926ejs/at91sam9261_devices.c
Diff comments   View file @ c68c03f
... ... @@ -55,7 +55,7 @@
55 55 at91_periph_clk_enable(ATMEL_ID_SYS);
56 56 }
57 57  
58   -#if defined(CONFIG_HAS_DATAFLASH) || defined(CONFIG_ATMEL_SPI)
  58 +#ifdef CONFIG_ATMEL_SPI
59 59 void at91_spi0_hw_init(unsigned long cs_mask)
60 60 {
61 61 at91_set_a_periph(AT91_PIO_PORTA, 0, PUP); /* SPI0_MISO */
arch/arm/mach-at91/arm926ejs/at91sam9263_devices.c
Diff comments   View file @ c68c03f
... ... @@ -59,7 +59,7 @@
59 59 at91_periph_clk_enable(ATMEL_ID_SYS);
60 60 }
61 61  
62   -#if defined(CONFIG_HAS_DATAFLASH) || defined(CONFIG_ATMEL_SPI)
  62 +#ifdef CONFIG_ATMEL_SPI
63 63 void at91_spi0_hw_init(unsigned long cs_mask)
64 64 {
65 65 at91_set_b_periph(AT91_PIO_PORTA, 0, PUP); /* SPI0_MISO */
arch/arm/mach-at91/arm926ejs/at91sam9m10g45_devices.c
Diff comments   View file @ c68c03f
... ... @@ -56,7 +56,7 @@
56 56 at91_periph_clk_enable(ATMEL_ID_SYS);
57 57 }
58 58  
59   -#if defined(CONFIG_HAS_DATAFLASH) || defined(CONFIG_ATMEL_SPI)
  59 +#ifdef CONFIG_ATMEL_SPI
60 60 void at91_spi0_hw_init(unsigned long cs_mask)
61 61 {
62 62 at91_set_a_periph(AT91_PIO_PORTB, 0, PUP); /* SPI0_MISO */
arch/arm/mach-at91/arm926ejs/at91sam9rl_devices.c
Diff comments   View file @ c68c03f
... ... @@ -55,7 +55,7 @@
55 55 at91_periph_clk_enable(ATMEL_ID_SYS);
56 56 }
57 57  
58   -#if defined(CONFIG_HAS_DATAFLASH) || defined(CONFIG_ATMEL_SPI)
  58 +#ifdef CONFIG_ATMEL_SPI
59 59 void at91_spi0_hw_init(unsigned long cs_mask)
60 60 {
61 61 at91_set_a_periph(AT91_PIO_PORTA, 25, PUP); /* SPI0_MISO */
board/atmel/at91sam9260ek/Makefile
Diff comments   View file @ c68c03f
... ... @@ -11,5 +11,4 @@
11 11  
12 12 obj-y += at91sam9260ek.o
13 13 obj-$(CONFIG_AT91_LED) += led.o
14   -obj-$(CONFIG_HAS_DATAFLASH) += partition.o
board/atmel/at91sam9260ek/partition.c
View file @ c68c03f
1   -/*
2   - * (C) Copyright 2008
3   - * Ulf Samuelsson <ulf@atmel.com>
4   - *
5   - * SPDX-License-Identifier: GPL-2.0+
6   - */
7   -#include <common.h>
8   -#include <config.h>
9   -#include <asm/hardware.h>
10   -#include <dataflash.h>
11   -
12   -AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS];
13   -
14   -struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = {
15   - {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0}, /* Logical adress, CS */
16   - {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS1, 1}
17   -};
18   -
19   -/*define the area offsets*/
20   -dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
21   - {0x00000000, 0x000041FF, FLAG_PROTECT_SET, 0, "Bootstrap"},
22   - {0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"},
23   - {0x00008400, 0x00083FFF, FLAG_PROTECT_SET, 0, "U-Boot"},
24   - {0x00084000, 0x00293FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"},
25   - {0x00294000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"},
26   -};
board/atmel/at91sam9261ek/Makefile
Diff comments   View file @ c68c03f
... ... @@ -11,5 +11,4 @@
11 11  
12 12 obj-y += at91sam9261ek.o
13 13 obj-$(CONFIG_AT91_LED) += led.o
14   -obj-$(CONFIG_HAS_DATAFLASH) += partition.o
board/atmel/at91sam9261ek/partition.c
View file @ c68c03f
1   -/*
2   - * (C) Copyright 2008
3   - * Ulf Samuelsson <ulf@atmel.com>
4   - *
5   - * SPDX-License-Identifier: GPL-2.0+
6   - */
7   -#include <common.h>
8   -#include <config.h>
9   -#include <asm/hardware.h>
10   -#include <dataflash.h>
11   -
12   -AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS];
13   -
14   -struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = {
15   - {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0}, /* Logical adress, CS */
16   - {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS3, 3}
17   -};
18   -
19   -/*define the area offsets*/
20   -dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
21   - {0x00000000, 0x000041FF, FLAG_PROTECT_SET, 0, "Bootstrap"},
22   - {0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"},
23   - {0x00008400, 0x00083FFF, FLAG_PROTECT_SET, 0, "U-Boot"},
24   - {0x00084000, 0x00293FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"},
25   - {0x00294000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"},
26   -};
board/atmel/at91sam9263ek/Makefile
Diff comments   View file @ c68c03f
... ... @@ -11,5 +11,4 @@
11 11  
12 12 obj-y += at91sam9263ek.o
13 13 obj-$(CONFIG_AT91_LED) += led.o
14   -obj-$(CONFIG_HAS_DATAFLASH) += partition.o
board/atmel/at91sam9263ek/partition.c
View file @ c68c03f
1   -/*
2   - * (C) Copyright 2008
3   - * Ulf Samuelsson <ulf@atmel.com>
4   - *
5   - * SPDX-License-Identifier: GPL-2.0+
6   - */
7   -#include <common.h>
8   -#include <config.h>
9   -#include <asm/hardware.h>
10   -#include <dataflash.h>
11   -
12   -AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS];
13   -
14   -struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = {
15   - {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0}, /* Logical adress, CS */
16   -};
17   -
18   -/*define the area offsets*/
19   -dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
20   - {0x00000000, 0x000041FF, FLAG_PROTECT_SET, 0, "Bootstrap"},
21   - {0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"},
22   - {0x00008400, 0x00083FFF, FLAG_PROTECT_SET, 0, "U-Boot"},
23   - {0x00084000, 0x00293FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"},
24   - {0x00294000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"},
25   -};
board/atmel/at91sam9rlek/Makefile
Diff comments   View file @ c68c03f
... ... @@ -11,5 +11,4 @@
11 11  
12 12 obj-y += at91sam9rlek.o
13 13 obj-$(CONFIG_AT91_LED) += led.o
14   -obj-$(CONFIG_HAS_DATAFLASH) += partition.o
board/atmel/at91sam9rlek/partition.c
View file @ c68c03f
1   -/*
2   - * (C) Copyright 2008
3   - * Ulf Samuelsson <ulf@atmel.com>
4   - *
5   - * SPDX-License-Identifier: GPL-2.0+
6   - */
7   -#include <common.h>
8   -#include <config.h>
9   -#include <asm/hardware.h>
10   -#include <dataflash.h>
11   -
12   -AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS];
13   -
14   -struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = {
15   - {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0}, /* Logical adress, CS */
16   -};
17   -
18   -/*define the area offsets*/
19   -dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
20   - {0x00000000, 0x000041FF, FLAG_PROTECT_SET, 0, "Bootstrap"},
21   - {0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"},
22   - {0x00008400, 0x00083FFF, FLAG_PROTECT_SET, 0, "U-Boot"},
23   - {0x00084000, 0x00293FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"},
24   - {0x00294000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"},
25   -};
board/esd/meesc/Makefile
Diff comments   View file @ c68c03f
... ... @@ -10,5 +10,4 @@
10 10 #
11 11  
12 12 obj-y += meesc.o
13   -obj-$(CONFIG_HAS_DATAFLASH) += partition.o
board/esd/meesc/partition.c
View file @ c68c03f
1   -/*
2   - * (C) Copyright 2008
3   - * Ulf Samuelsson <ulf@atmel.com>
4   - *
5   - * SPDX-License-Identifier: GPL-2.0+
6   - */
7   -#include <common.h>
8   -#include <config.h>
9   -#include <asm/hardware.h>
10   -#include <dataflash.h>
11   -
12   -AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS];
13   -
14   -struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = {
15   - {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0}, /* Logical adress, CS */
16   -};
17   -
18   -/* define the area offsets */
19   -dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
20   - {0x00000000, 0x000041FF, FLAG_PROTECT_SET, 0, "Bootstrap"},
21   - {0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"},
22   - {0x00008400, 0x00041FFF, FLAG_PROTECT_SET, 0, "U-Boot"},
23   -};
board/mini-box/picosam9g45/picosam9g45.c
Diff comments   View file @ c68c03f
... ... @@ -261,9 +261,6 @@
261 261 #ifdef CONFIG_CMD_USB
262 262 picosam9g45_usb_hw_init();
263 263 #endif
264   -#ifdef CONFIG_HAS_DATAFLASH
265   - at91_spi0_hw_init(1 << 0);
266   -#endif
267 264 #ifdef CONFIG_ATMEL_SPI
268 265 at91_spi0_hw_init(1 << 4);
269 266 #endif
board/ronetix/pm9261/Makefile
Diff comments   View file @ c68c03f
... ... @@ -12,5 +12,4 @@
12 12  
13 13 obj-y += pm9261.o
14 14 obj-$(CONFIG_RED_LED) += led.o
15   -obj-$(CONFIG_HAS_DATAFLASH) += partition.o
board/ronetix/pm9261/partition.c
View file @ c68c03f
1   -/*
2   - * (C) Copyright 2008
3   - * Ulf Samuelsson <ulf@atmel.com>
4   - * Ilko Iliev <www.ronetix.at>
5   - *
6   - * SPDX-License-Identifier: GPL-2.0+
7   - */
8   -#include <common.h>
9   -#include <config.h>
10   -#include <asm/hardware.h>
11   -#include <dataflash.h>
12   -
13   -AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS];
14   -
15   -struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = {
16   - {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0}, /* Logical adress, CS */
17   -};
18   -
19   -/*define the area offsets*/
20   -#ifdef CONFIG_SYS_USE_DATAFLASH
21   -dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
22   - {0x00000000, 0x000041FF, FLAG_PROTECT_SET, 0, "Bootstrap"},
23   - {0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"},
24   - {0x00008400, 0x00041FFF, FLAG_PROTECT_SET, 0, "U-Boot"},
25   - {0x00042000, 0x00251FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"},
26   - {0x00252000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"},
27   -};
28   -#else
29   -dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
30   - {0x00000000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, ""},
31   -};
32   -
33   -#endif
board/ronetix/pm9263/Makefile
Diff comments   View file @ c68c03f
... ... @@ -12,5 +12,4 @@
12 12  
13 13 obj-y += pm9263.o
14 14 obj-$(CONFIG_AT91_LED) += led.o
15   -obj-$(CONFIG_HAS_DATAFLASH) += partition.o
board/ronetix/pm9263/partition.c
View file @ c68c03f
1   -/*
2   - * (C) Copyright 2008
3   - * Ulf Samuelsson <ulf@atmel.com>
4   - * Ilko Iliev <www.ronetix.at>
5   - *
6   - * SPDX-License-Identifier: GPL-2.0+
7   - */
8   -#include <common.h>
9   -#include <config.h>
10   -#include <asm/hardware.h>
11   -#include <dataflash.h>
12   -
13   -AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS];
14   -
15   -struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = {
16   - {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0}, /* Logical adress, CS */
17   -};
18   -
19   -/*define the area offsets*/
20   -#ifdef CONFIG_SYS_USE_DATAFLASH
21   -dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
22   - {0x00000000, 0x000041FF, FLAG_PROTECT_SET, 0, "Bootstrap"},
23   - {0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"},
24   - {0x00008400, 0x00041FFF, FLAG_PROTECT_SET, 0, "U-Boot"},
25   - {0x00042000, 0x00251FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"},
26   - {0x00252000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"},
27   -};
28   -#else
29   -dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
30   - {0x00000000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, ""},
31   -};
32   -
33   -#endif
board/siemens/corvus/board.c
Diff comments   View file @ c68c03f
... ... @@ -250,9 +250,6 @@
250 250 #ifdef CONFIG_ATMEL_SPI
251 251 at91_spi0_hw_init(1 << 4);
252 252 #endif
253   -#ifdef CONFIG_HAS_DATAFLASH
254   - at91_spi0_hw_init(1 << 0);
255   -#endif
256 253 #ifdef CONFIG_MACB
257 254 corvus_macb_hw_init();
258 255 #endif
... ... @@ -11,10 +11,6 @@
11 11 #include <common.h>
12 12 #include <command.h>
13 13  
14   -#ifdef CONFIG_HAS_DATAFLASH
15   -#include <dataflash.h>
16   -#endif
17   -
18 14 #if defined(CONFIG_CMD_MTDPARTS)
19 15 #include <jffs2/jffs2.h>
20 16  
... ... @@ -279,10 +275,6 @@
279 275 ulong bank;
280 276 #endif
281 277  
282   -#ifdef CONFIG_HAS_DATAFLASH
283   - dataflash_print_info();
284   -#endif
285   -
286 278 #ifdef CONFIG_MTD_NOR_FLASH
287 279 if (argc == 1) { /* print info for all FLASH banks */
288 280 for (bank=0; bank <CONFIG_SYS_MAX_FLASH_BANKS; ++bank) {
... ... @@ -451,10 +443,7 @@
451 443 u8 dev_type, dev_num, pnum;
452 444 #endif
453 445 #endif /* CONFIG_MTD_NOR_FLASH */
454   -#ifdef CONFIG_HAS_DATAFLASH
455   - int status;
456   -#endif
457   -#if defined(CONFIG_MTD_NOR_FLASH) || defined(CONFIG_HAS_DATAFLASH)
  446 +#if defined(CONFIG_MTD_NOR_FLASH)
458 447 int p;
459 448 ulong addr_first, addr_last;
460 449 #endif
461 450  
... ... @@ -462,31 +451,13 @@
462 451 if (argc < 3)
463 452 return CMD_RET_USAGE;
464 453  
465   -#if defined(CONFIG_MTD_NOR_FLASH) || defined(CONFIG_HAS_DATAFLASH)
  454 +#if defined(CONFIG_MTD_NOR_FLASH)
466 455 if (strcmp(argv[1], "off") == 0)
467 456 p = 0;
468 457 else if (strcmp(argv[1], "on") == 0)
469 458 p = 1;
470 459 else
471 460 return CMD_RET_USAGE;
472   -#endif
473   -
474   -#ifdef CONFIG_HAS_DATAFLASH
475   - if ((strcmp(argv[2], "all") != 0) && (strcmp(argv[2], "bank") != 0)) {
476   - addr_first = simple_strtoul(argv[2], NULL, 16);
477   - addr_last = simple_strtoul(argv[3], NULL, 16);
478   -
479   - if (addr_dataflash(addr_first) && addr_dataflash(addr_last)) {
480   - status = dataflash_real_protect(p,addr_first,addr_last);
481   - if (status < 0){
482   - puts ("Bad DataFlash sector specification\n");
483   - return 1;
484   - }
485   - printf("%sProtect %d DataFlash Sectors\n",
486   - p ? "" : "Un-", status);
487   - return 0;
488   - }
489   - }
490 461 #endif
491 462  
492 463 #ifdef CONFIG_MTD_NOR_FLASH
... ... @@ -17,9 +17,6 @@
17 17 #include <cli.h>
18 18 #include <command.h>
19 19 #include <console.h>
20   -#ifdef CONFIG_HAS_DATAFLASH
21   -#include <dataflash.h>
22   -#endif
23 20 #include <hash.h>
24 21 #include <inttypes.h>
25 22 #include <mapmem.h>
... ... @@ -52,10 +49,8 @@
52 49 #define DISP_LINE_LEN 16
53 50 static int do_mem_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
54 51 {
55   - ulong addr, length;
56   -#if defined(CONFIG_HAS_DATAFLASH)
57   - ulong nbytes, linebytes;
58   -#endif
  52 + ulong addr, length, bytes;
  53 + const void *buf;
59 54 int size;
60 55 int rc = 0;
61 56  
62 57  
63 58  
... ... @@ -88,41 +83,14 @@
88 83 length = simple_strtoul(argv[2], NULL, 16);
89 84 }
90 85  
91   -#if defined(CONFIG_HAS_DATAFLASH)
92   - /* Print the lines.
93   - *
94   - * We buffer all read data, so we can make sure data is read only
95   - * once, and all accesses are with the specified bus width.
96   - */
97   - nbytes = length * size;
98   - do {
99   - char linebuf[DISP_LINE_LEN];
100   - void* p;
101   - linebytes = (nbytes>DISP_LINE_LEN)?DISP_LINE_LEN:nbytes;
  86 + bytes = size * length;
  87 + buf = map_sysmem(addr, bytes);
102 88  
103   - rc = read_dataflash(addr, (linebytes/size)*size, linebuf);
104   - p = (rc == DATAFLASH_OK) ? linebuf : (void*)addr;
105   - print_buffer(addr, p, size, linebytes/size, DISP_LINE_LEN/size);
  89 + /* Print the lines. */
  90 + print_buffer(addr, buf, size, length, DISP_LINE_LEN / size);
  91 + addr += bytes;
  92 + unmap_sysmem(buf);
106 93  
107   - nbytes -= linebytes;
108   - addr += linebytes;
109   - if (ctrlc()) {
110   - rc = 1;
111   - break;
112   - }
113   - } while (nbytes > 0);
114   -#else
115   - {
116   - ulong bytes = size * length;
117   - const void *buf = map_sysmem(addr, bytes);
118   -
119   - /* Print the lines. */
120   - print_buffer(addr, buf, size, length, DISP_LINE_LEN / size);
121   - addr += bytes;
122   - unmap_sysmem(buf);
123   - }
124   -#endif
125   -
126 94 dp_last_addr = addr;
127 95 dp_last_length = length;
128 96 dp_last_size = size;
... ... @@ -286,13 +254,6 @@
286 254  
287 255 count = simple_strtoul(argv[3], NULL, 16);
288 256  
289   -#ifdef CONFIG_HAS_DATAFLASH
290   - if (addr_dataflash(addr1) | addr_dataflash(addr2)){
291   - puts ("Comparison with DataFlash space not supported.\n\r");
292   - return 0;
293   - }
294   -#endif
295   -
296 257 bytes = size * count;
297 258 base = buf1 = map_sysmem(addr1, bytes);
298 259 buf2 = map_sysmem(addr2, bytes);
... ... @@ -370,11 +331,7 @@
370 331  
371 332 #ifdef CONFIG_MTD_NOR_FLASH
372 333 /* check if we are copying to Flash */
373   - if ( (addr2info(dest) != NULL)
374   -#ifdef CONFIG_HAS_DATAFLASH
375   - && (!addr_dataflash(dest))
376   -#endif
377   - ) {
  334 + if (addr2info(dest) != NULL) {
378 335 int rc;
379 336  
380 337 puts ("Copy to Flash... ");
... ... @@ -389,44 +346,6 @@
389 346 }
390 347 #endif
391 348  
392   -#ifdef CONFIG_HAS_DATAFLASH
393   - /* Check if we are copying from RAM or Flash to DataFlash */
394   - if (addr_dataflash(dest) && !addr_dataflash(addr)){
395   - int rc;
396   -
397   - puts ("Copy to DataFlash... ");
398   -
399   - rc = write_dataflash (dest, addr, count*size);
400   -
401   - if (rc != 1) {
402   - dataflash_perror (rc);
403   - return (1);
404   - }
405   - puts ("done\n");
406   - return 0;
407   - }
408   -
409   - /* Check if we are copying from DataFlash to RAM */
410   - if (addr_dataflash(addr) && !addr_dataflash(dest)
411   -#ifdef CONFIG_MTD_NOR_FLASH
412   - && (addr2info(dest) == NULL)
413   -#endif
414   - ){
415   - int rc;
416   - rc = read_dataflash(addr, count * size, (char *) dest);
417   - if (rc != 1) {
418   - dataflash_perror (rc);
419   - return (1);
420   - }
421   - return 0;
422   - }
423   -
424   - if (addr_dataflash(addr) && addr_dataflash(dest)){
425   - puts ("Unsupported combination of source/destination.\n\r");
426   - return 1;
427   - }
428   -#endif
429   -
430 349 memcpy((void *)dest, (void *)addr, count * size);
431 350  
432 351 return 0;
... ... @@ -1071,13 +990,6 @@
1071 990 addr = simple_strtoul(argv[1], NULL, 16);
1072 991 addr += base_address;
1073 992 }
1074   -
1075   -#ifdef CONFIG_HAS_DATAFLASH
1076   - if (addr_dataflash(addr)){
1077   - puts ("Can't modify DataFlash in place. Use cp instead.\n\r");
1078   - return 0;
1079   - }
1080   -#endif
1081 993  
1082 994 /* Print the address, followed by value. Then accept input for
1083 995 * the next value. A non-converted value exits.
... ... @@ -18,9 +18,6 @@
18 18 #endif
19 19 #include <command.h>
20 20 #include <console.h>
21   -#ifdef CONFIG_HAS_DATAFLASH
22   -#include <dataflash.h>
23   -#endif
24 21 #include <dm.h>
25 22 #include <environment.h>
26 23 #include <fdtdec.h>
... ... @@ -447,15 +444,6 @@
447 444 }
448 445 #endif
449 446  
450   -#ifdef CONFIG_HAS_DATAFLASH
451   -static int initr_dataflash(void)
452   -{
453   - AT91F_DataflashInit();
454   - dataflash_print_info();
455   - return 0;
456   -}
457   -#endif
458   -
459 447 /*
460 448 * Tell if it's OK to load the environment early in boot.
461 449 *
... ... @@ -802,9 +790,6 @@
802 790 #endif
803 791 #ifdef CONFIG_MMC
804 792 initr_mmc,
805   -#endif
806   -#ifdef CONFIG_HAS_DATAFLASH
807   - initr_dataflash,
808 793 #endif
809 794 initr_env,
810 795 #ifdef CONFIG_SYS_BOOTPARAMS_LEN
... ... @@ -15,10 +15,6 @@
15 15 #include <status_led.h>
16 16 #endif
17 17  
18   -#ifdef CONFIG_HAS_DATAFLASH
19   -#include <dataflash.h>
20   -#endif
21   -
22 18 #ifdef CONFIG_LOGBUFFER
23 19 #include <logbuff.h>
24 20 #endif
... ... @@ -902,64 +898,6 @@
902 898 ulong genimg_get_image(ulong img_addr)
903 899 {
904 900 ulong ram_addr = img_addr;
905   -
906   -#ifdef CONFIG_HAS_DATAFLASH
907   - ulong h_size, d_size;
908   -
909   - if (addr_dataflash(img_addr)) {
910   - void *buf;
911   -
912   - /* ger RAM address */
913   - ram_addr = CONFIG_SYS_LOAD_ADDR;
914   -
915   - /* get header size */
916   - h_size = image_get_header_size();
917   -#if IMAGE_ENABLE_FIT
918   - if (sizeof(struct fdt_header) > h_size)
919   - h_size = sizeof(struct fdt_header);
920   -#endif
921   -
922   - /* read in header */
923   - debug(" Reading image header from dataflash address "
924   - "%08lx to RAM address %08lx\n", img_addr, ram_addr);
925   -
926   - buf = map_sysmem(ram_addr, 0);
927   - read_dataflash(img_addr, h_size, buf);
928   -
929   - /* get data size */
930   - switch (genimg_get_format(buf)) {
931   -#if defined(CONFIG_IMAGE_FORMAT_LEGACY)
932   - case IMAGE_FORMAT_LEGACY:
933   - d_size = image_get_data_size(buf);
934   - debug(" Legacy format image found at 0x%08lx, "
935   - "size 0x%08lx\n",
936   - ram_addr, d_size);
937   - break;
938   -#endif
939   -#if IMAGE_ENABLE_FIT
940   - case IMAGE_FORMAT_FIT:
941   - d_size = fit_get_size(buf) - h_size;
942   - debug(" FIT/FDT format image found at 0x%08lx, "
943   - "size 0x%08lx\n",
944   - ram_addr, d_size);
945   - break;
946   -#endif
947   - default:
948   - printf(" No valid image found at 0x%08lx\n",
949   - img_addr);
950   - return ram_addr;
951   - }
952   -
953   - /* read in image data */
954   - debug(" Reading image remaining data from dataflash address "
955   - "%08lx to RAM address %08lx\n", img_addr + h_size,
956   - ram_addr + h_size);
957   -
958   - read_dataflash(img_addr + h_size, d_size,
959   - (char *)(buf + h_size));
960   -
961   - }
962   -#endif /* CONFIG_HAS_DATAFLASH */
963 901  
964 902 return ram_addr;
965 903 }
drivers/mtd/Makefile
Diff comments   View file @ c68c03f
... ... @@ -12,10 +12,8 @@
12 12 obj-$(CONFIG_MTD_PARTITIONS) += mtdpart.o
13 13 obj-$(CONFIG_MTD_CONCAT) += mtdconcat.o
14 14 obj-$(CONFIG_ALTERA_QSPI) += altera_qspi.o
15   -obj-$(CONFIG_HAS_DATAFLASH) += at45.o
16 15 obj-$(CONFIG_FLASH_CFI_DRIVER) += cfi_flash.o
17 16 obj-$(CONFIG_FLASH_CFI_MTD) += cfi_mtd.o
18   -obj-$(CONFIG_HAS_DATAFLASH) += dataflash.o
19 17 obj-$(CONFIG_FTSMC020) += ftsmc020.o
20 18 obj-$(CONFIG_FLASH_CFI_LEGACY) += jedec_flash.o
21 19 obj-$(CONFIG_MW_EEPROM) += mw_eeprom.o
drivers/mtd/at45.c
View file @ c68c03f
1   -/* Driver for ATMEL DataFlash support
2   - * Author : Hamid Ikdoumi (Atmel)
3   - *
4   - * SPDX-License-Identifier: GPL-2.0+
5   - */
6   -
7   -#include <config.h>
8   -#include <common.h>
9   -#include <dataflash.h>
10   -
11   -/*
12   - * spi.c API
13   - */
14   -extern unsigned int AT91F_SpiWrite(AT91PS_DataflashDesc pDesc);
15   -extern void AT91F_SpiEnable(int cs);
16   -
17   -#define AT91C_TIMEOUT_WRDY 200000
18   -
19   -/*----------------------------------------------------------------------*/
20   -/* \fn AT91F_DataFlashSendCommand */
21   -/* \brief Generic function to send a command to the dataflash */
22   -/*----------------------------------------------------------------------*/
23   -AT91S_DataFlashStatus AT91F_DataFlashSendCommand(AT91PS_DataFlash pDataFlash,
24   - unsigned char OpCode,
25   - unsigned int CmdSize,
26   - unsigned int DataflashAddress)
27   -{
28   - unsigned int adr;
29   -
30   - if ((pDataFlash->pDataFlashDesc->state) != IDLE)
31   - return DATAFLASH_BUSY;
32   -
33   - /* process the address to obtain page address and byte address */
34   - adr = ((DataflashAddress / (pDataFlash->pDevice->pages_size)) <<
35   - pDataFlash->pDevice->page_offset) +
36   - (DataflashAddress % (pDataFlash->pDevice->pages_size));
37   -
38   - /* fill the command buffer */
39   - pDataFlash->pDataFlashDesc->command[0] = OpCode;
40   - if (pDataFlash->pDevice->pages_number >= 16384) {
41   - pDataFlash->pDataFlashDesc->command[1] =
42   - (unsigned char)((adr & 0x0F000000) >> 24);
43   - pDataFlash->pDataFlashDesc->command[2] =
44   - (unsigned char)((adr & 0x00FF0000) >> 16);
45   - pDataFlash->pDataFlashDesc->command[3] =
46   - (unsigned char)((adr & 0x0000FF00) >> 8);
47   - pDataFlash->pDataFlashDesc->command[4] =
48   - (unsigned char)(adr & 0x000000FF);
49   - } else {
50   - pDataFlash->pDataFlashDesc->command[1] =
51   - (unsigned char)((adr & 0x00FF0000) >> 16);
52   - pDataFlash->pDataFlashDesc->command[2] =
53   - (unsigned char)((adr & 0x0000FF00) >> 8);
54   - pDataFlash->pDataFlashDesc->command[3] =
55   - (unsigned char)(adr & 0x000000FF);
56   - pDataFlash->pDataFlashDesc->command[4] = 0;
57   - }
58   - pDataFlash->pDataFlashDesc->command[5] = 0;
59   - pDataFlash->pDataFlashDesc->command[6] = 0;
60   - pDataFlash->pDataFlashDesc->command[7] = 0;
61   -
62   - /* Initialize the SpiData structure for the spi write fuction */
63   - pDataFlash->pDataFlashDesc->tx_cmd_pt =
64   - pDataFlash->pDataFlashDesc->command;
65   - pDataFlash->pDataFlashDesc->tx_cmd_size = CmdSize;
66   - pDataFlash->pDataFlashDesc->rx_cmd_pt =
67   - pDataFlash->pDataFlashDesc->command;
68   - pDataFlash->pDataFlashDesc->rx_cmd_size = CmdSize;
69   -
70   - /* send the command and read the data */
71   - return AT91F_SpiWrite(pDataFlash->pDataFlashDesc);
72   -}
73   -
74   -/*----------------------------------------------------------------------*/
75   -/* \fn AT91F_DataFlashGetStatus */
76   -/* \brief Read the status register of the dataflash */
77   -/*----------------------------------------------------------------------*/
78   -AT91S_DataFlashStatus AT91F_DataFlashGetStatus(AT91PS_DataflashDesc pDesc)
79   -{
80   - AT91S_DataFlashStatus status;
81   -
82   - /* if a transfert is in progress ==> return 0 */
83   - if ((pDesc->state) != IDLE)
84   - return DATAFLASH_BUSY;
85   -
86   - /* first send the read status command (D7H) */
87   - pDesc->command[0] = DB_STATUS;
88   - pDesc->command[1] = 0;
89   -
90   - pDesc->DataFlash_state = GET_STATUS;
91   - pDesc->tx_data_size = 0; /* Transmit the command */
92   - /* and receive response */
93   - pDesc->tx_cmd_pt = pDesc->command;
94   - pDesc->rx_cmd_pt = pDesc->command;
95   - pDesc->rx_cmd_size = 2;
96   - pDesc->tx_cmd_size = 2;
97   - status = AT91F_SpiWrite(pDesc);
98   -
99   - pDesc->DataFlash_state = *((unsigned char *)(pDesc->rx_cmd_pt) + 1);
100   -
101   - return status;
102   -}
103   -
104   -/*----------------------------------------------------------------------*/
105   -/* \fn AT91F_DataFlashWaitReady */
106   -/* \brief wait for dataflash ready (bit7 of the status register == 1) */
107   -/*----------------------------------------------------------------------*/
108   -AT91S_DataFlashStatus AT91F_DataFlashWaitReady(AT91PS_DataflashDesc
109   - pDataFlashDesc,
110   - unsigned int timeout)
111   -{
112   - pDataFlashDesc->DataFlash_state = IDLE;
113   -
114   - do {
115   - AT91F_DataFlashGetStatus(pDataFlashDesc);
116   - timeout--;
117   - } while (((pDataFlashDesc->DataFlash_state & 0x80) != 0x80) &&
118   - (timeout > 0));
119   -
120   - if ((pDataFlashDesc->DataFlash_state & 0x80) != 0x80)
121   - return DATAFLASH_ERROR;
122   -
123   - return DATAFLASH_OK;
124   -}
125   -
126   -/*--------------------------------------------------------------------------*/
127   -/* Function Name : AT91F_DataFlashContinuousRead */
128   -/* Object : Continuous stream Read */
129   -/* Input Parameters : DataFlash Service */
130   -/* : <src> = dataflash address */
131   -/* : <*dataBuffer> = data buffer pointer */
132   -/* : <sizeToRead> = data buffer size */
133   -/* Return value : State of the dataflash */
134   -/*--------------------------------------------------------------------------*/
135   -AT91S_DataFlashStatus AT91F_DataFlashContinuousRead(
136   - AT91PS_DataFlash pDataFlash,
137   - int src,
138   - unsigned char *dataBuffer,
139   - int sizeToRead)
140   -{
141   - AT91S_DataFlashStatus status;
142   - /* Test the size to read in the device */
143   - if ((src + sizeToRead) >
144   - (pDataFlash->pDevice->pages_size *
145   - (pDataFlash->pDevice->pages_number)))
146   - return DATAFLASH_MEMORY_OVERFLOW;
147   -
148   - pDataFlash->pDataFlashDesc->rx_data_pt = dataBuffer;
149   - pDataFlash->pDataFlashDesc->rx_data_size = sizeToRead;
150   - pDataFlash->pDataFlashDesc->tx_data_pt = dataBuffer;
151   - pDataFlash->pDataFlashDesc->tx_data_size = sizeToRead;
152   -
153   - status = AT91F_DataFlashSendCommand(
154   - pDataFlash, DB_CONTINUOUS_ARRAY_READ, 8, src);
155   - /* Send the command to the dataflash */
156   - return (status);
157   -}
158   -
159   -/*---------------------------------------------------------------------------*/
160   -/* Function Name : AT91F_DataFlashPagePgmBuf */
161   -/* Object : Main memory page program thru buffer 1 or buffer 2 */
162   -/* Input Parameters : DataFlash Service */
163   -/* : <*src> = Source buffer */
164   -/* : <dest> = dataflash destination address */
165   -/* : <SizeToWrite> = data buffer size */
166   -/* Return value : State of the dataflash */
167   -/*---------------------------------------------------------------------------*/
168   -AT91S_DataFlashStatus AT91F_DataFlashPagePgmBuf(AT91PS_DataFlash pDataFlash,
169   - unsigned char *src,
170   - unsigned int dest,
171   - unsigned int SizeToWrite)
172   -{
173   - int cmdsize;
174   - pDataFlash->pDataFlashDesc->tx_data_pt = src;
175   - pDataFlash->pDataFlashDesc->tx_data_size = SizeToWrite;
176   - pDataFlash->pDataFlashDesc->rx_data_pt = src;
177   - pDataFlash->pDataFlashDesc->rx_data_size = SizeToWrite;
178   -
179   - cmdsize = 4;
180   - /* Send the command to the dataflash */
181   - if (pDataFlash->pDevice->pages_number >= 16384)
182   - cmdsize = 5;
183   - return (AT91F_DataFlashSendCommand(
184   - pDataFlash, DB_PAGE_PGM_BUF1, cmdsize, dest));
185   -}
186   -
187   -/*---------------------------------------------------------------------------*/
188   -/* Function Name : AT91F_MainMemoryToBufferTransfert */
189   -/* Object : Read a page in the SRAM Buffer 1 or 2 */
190   -/* Input Parameters : DataFlash Service */
191   -/* : Page concerned */
192   -/* : */
193   -/* Return value : State of the dataflash */
194   -/*---------------------------------------------------------------------------*/
195   -AT91S_DataFlashStatus AT91F_MainMemoryToBufferTransfert(
196   - AT91PS_DataFlash
197   - pDataFlash,
198   - unsigned char
199   - BufferCommand,
200   - unsigned int page)
201   -{
202   - int cmdsize;
203   - /* Test if the buffer command is legal */
204   - if ((BufferCommand != DB_PAGE_2_BUF1_TRF) &&
205   - (BufferCommand != DB_PAGE_2_BUF2_TRF)) {
206   - return DATAFLASH_BAD_COMMAND;
207   - }
208   -
209   - /* no data to transmit or receive */
210   - pDataFlash->pDataFlashDesc->tx_data_size = 0;
211   - cmdsize = 4;
212   - if (pDataFlash->pDevice->pages_number >= 16384)
213   - cmdsize = 5;
214   - return (AT91F_DataFlashSendCommand(
215   - pDataFlash, BufferCommand, cmdsize,
216   - page * pDataFlash->pDevice->pages_size));
217   -}
218   -
219   -/*-------------------------------------------------------------------------- */
220   -/* Function Name : AT91F_DataFlashWriteBuffer */
221   -/* Object : Write data to the internal sram buffer 1 or 2 */
222   -/* Input Parameters : DataFlash Service */
223   -/* : <BufferCommand> = command to write buffer1 or 2 */
224   -/* : <*dataBuffer> = data buffer to write */
225   -/* : <bufferAddress> = address in the internal buffer */
226   -/* : <SizeToWrite> = data buffer size */
227   -/* Return value : State of the dataflash */
228   -/*---------------------------------------------------------------------------*/
229   -AT91S_DataFlashStatus AT91F_DataFlashWriteBuffer(
230   - AT91PS_DataFlash pDataFlash,
231   - unsigned char BufferCommand,
232   - unsigned char *dataBuffer,
233   - unsigned int bufferAddress,
234   - int SizeToWrite)
235   -{
236   - int cmdsize;
237   - /* Test if the buffer command is legal */
238   - if ((BufferCommand != DB_BUF1_WRITE) &&
239   - (BufferCommand != DB_BUF2_WRITE)) {
240   - return DATAFLASH_BAD_COMMAND;
241   - }
242   -
243   - /* buffer address must be lower than page size */
244   - if (bufferAddress > pDataFlash->pDevice->pages_size)
245   - return DATAFLASH_BAD_ADDRESS;
246   -
247   - if ((pDataFlash->pDataFlashDesc->state) != IDLE)
248   - return DATAFLASH_BUSY;
249   -
250   - /* Send first Write Command */
251   - pDataFlash->pDataFlashDesc->command[0] = BufferCommand;
252   - pDataFlash->pDataFlashDesc->command[1] = 0;
253   - if (pDataFlash->pDevice->pages_number >= 16384) {
254   - pDataFlash->pDataFlashDesc->command[2] = 0;
255   - pDataFlash->pDataFlashDesc->command[3] =
256   - (unsigned char)(((unsigned int)(bufferAddress &
257   - pDataFlash->pDevice->
258   - byte_mask)) >> 8);
259   - pDataFlash->pDataFlashDesc->command[4] =
260   - (unsigned char)((unsigned int)bufferAddress & 0x00FF);
261   - cmdsize = 5;
262   - } else {
263   - pDataFlash->pDataFlashDesc->command[2] =
264   - (unsigned char)(((unsigned int)(bufferAddress &
265   - pDataFlash->pDevice->
266   - byte_mask)) >> 8);
267   - pDataFlash->pDataFlashDesc->command[3] =
268   - (unsigned char)((unsigned int)bufferAddress & 0x00FF);
269   - pDataFlash->pDataFlashDesc->command[4] = 0;
270   - cmdsize = 4;
271   - }
272   -
273   - pDataFlash->pDataFlashDesc->tx_cmd_pt =
274   - pDataFlash->pDataFlashDesc->command;
275   - pDataFlash->pDataFlashDesc->tx_cmd_size = cmdsize;
276   - pDataFlash->pDataFlashDesc->rx_cmd_pt =
277   - pDataFlash->pDataFlashDesc->command;
278   - pDataFlash->pDataFlashDesc->rx_cmd_size = cmdsize;
279   -
280   - pDataFlash->pDataFlashDesc->rx_data_pt = dataBuffer;
281   - pDataFlash->pDataFlashDesc->tx_data_pt = dataBuffer;
282   - pDataFlash->pDataFlashDesc->rx_data_size = SizeToWrite;
283   - pDataFlash->pDataFlashDesc->tx_data_size = SizeToWrite;
284   -
285   - return AT91F_SpiWrite(pDataFlash->pDataFlashDesc);
286   -}
287   -
288   -/*---------------------------------------------------------------------------*/
289   -/* Function Name : AT91F_PageErase */
290   -/* Object : Erase a page */
291   -/* Input Parameters : DataFlash Service */
292   -/* : Page concerned */
293   -/* : */
294   -/* Return value : State of the dataflash */
295   -/*---------------------------------------------------------------------------*/
296   -AT91S_DataFlashStatus AT91F_PageErase(
297   - AT91PS_DataFlash pDataFlash,
298   - unsigned int page)
299   -{
300   - int cmdsize;
301   - /* Test if the buffer command is legal */
302   - /* no data to transmit or receive */
303   - pDataFlash->pDataFlashDesc->tx_data_size = 0;
304   -
305   - cmdsize = 4;
306   - if (pDataFlash->pDevice->pages_number >= 16384)
307   - cmdsize = 5;
308   - return (AT91F_DataFlashSendCommand(pDataFlash,
309   - DB_PAGE_ERASE, cmdsize,
310   - page * pDataFlash->pDevice->pages_size));
311   -}
312   -
313   -/*---------------------------------------------------------------------------*/
314   -/* Function Name : AT91F_BlockErase */
315   -/* Object : Erase a Block */
316   -/* Input Parameters : DataFlash Service */
317   -/* : Page concerned */
318   -/* : */
319   -/* Return value : State of the dataflash */
320   -/*---------------------------------------------------------------------------*/
321   -AT91S_DataFlashStatus AT91F_BlockErase(
322   - AT91PS_DataFlash pDataFlash,
323   - unsigned int block)
324   -{
325   - int cmdsize;
326   - /* Test if the buffer command is legal */
327   - /* no data to transmit or receive */
328   - pDataFlash->pDataFlashDesc->tx_data_size = 0;
329   - cmdsize = 4;
330   - if (pDataFlash->pDevice->pages_number >= 16384)
331   - cmdsize = 5;
332   - return (AT91F_DataFlashSendCommand(pDataFlash, DB_BLOCK_ERASE, cmdsize,
333   - block * 8 *
334   - pDataFlash->pDevice->pages_size));
335   -}
336   -
337   -/*---------------------------------------------------------------------------*/
338   -/* Function Name : AT91F_WriteBufferToMain */
339   -/* Object : Write buffer to the main memory */
340   -/* Input Parameters : DataFlash Service */
341   -/* : <BufferCommand> = command to send to buffer1 or buffer2 */
342   -/* : <dest> = main memory address */
343   -/* Return value : State of the dataflash */
344   -/*---------------------------------------------------------------------------*/
345   -AT91S_DataFlashStatus AT91F_WriteBufferToMain(AT91PS_DataFlash pDataFlash,
346   - unsigned char BufferCommand,
347   - unsigned int dest)
348   -{
349   - int cmdsize;
350   - /* Test if the buffer command is correct */
351   - if ((BufferCommand != DB_BUF1_PAGE_PGM) &&
352   - (BufferCommand != DB_BUF1_PAGE_ERASE_PGM) &&
353   - (BufferCommand != DB_BUF2_PAGE_PGM) &&
354   - (BufferCommand != DB_BUF2_PAGE_ERASE_PGM))
355   - return DATAFLASH_BAD_COMMAND;
356   -
357   - /* no data to transmit or receive */
358   - pDataFlash->pDataFlashDesc->tx_data_size = 0;
359   -
360   - cmdsize = 4;
361   - if (pDataFlash->pDevice->pages_number >= 16384)
362   - cmdsize = 5;
363   - /* Send the command to the dataflash */
364   - return (AT91F_DataFlashSendCommand(pDataFlash, BufferCommand,
365   - cmdsize, dest));
366   -}
367   -
368   -/*---------------------------------------------------------------------------*/
369   -/* Function Name : AT91F_PartialPageWrite */
370   -/* Object : Erase partielly a page */
371   -/* Input Parameters : <page> = page number */
372   -/* : <AdrInpage> = adr to begin the fading */
373   -/* : <length> = Number of bytes to erase */
374   -/*---------------------------------------------------------------------------*/
375   -AT91S_DataFlashStatus AT91F_PartialPageWrite(AT91PS_DataFlash pDataFlash,
376   - unsigned char *src,
377   - unsigned int dest,
378   - unsigned int size)
379   -{
380   - unsigned int page;
381   - unsigned int AdrInPage;
382   -
383   - page = dest / (pDataFlash->pDevice->pages_size);
384   - AdrInPage = dest % (pDataFlash->pDevice->pages_size);
385   -
386   - /* Read the contents of the page in the Sram Buffer */
387   - AT91F_MainMemoryToBufferTransfert(pDataFlash, DB_PAGE_2_BUF1_TRF, page);
388   - AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
389   - AT91C_TIMEOUT_WRDY);
390   - /*Update the SRAM buffer */
391   - AT91F_DataFlashWriteBuffer(pDataFlash, DB_BUF1_WRITE, src,
392   - AdrInPage, size);
393   -
394   - AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
395   - AT91C_TIMEOUT_WRDY);
396   -
397   - /* Erase page if a 128 Mbits device */
398   - if (pDataFlash->pDevice->pages_number >= 16384) {
399   - AT91F_PageErase(pDataFlash, page);
400   - /* Rewrite the modified Sram Buffer in the main memory */
401   - AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
402   - AT91C_TIMEOUT_WRDY);
403   - }
404   -
405   - /* Rewrite the modified Sram Buffer in the main memory */
406   - return (AT91F_WriteBufferToMain(pDataFlash, DB_BUF1_PAGE_ERASE_PGM,
407   - (page *
408   - pDataFlash->pDevice->pages_size)));
409   -}
410   -
411   -/*---------------------------------------------------------------------------*/
412   -/* Function Name : AT91F_DataFlashWrite */
413   -/* Object : */
414   -/* Input Parameters : <*src> = Source buffer */
415   -/* : <dest> = dataflash adress */
416   -/* : <size> = data buffer size */
417   -/*---------------------------------------------------------------------------*/
418   -AT91S_DataFlashStatus AT91F_DataFlashWrite(AT91PS_DataFlash pDataFlash,
419   - unsigned char *src,
420   - int dest, int size)
421   -{
422   - unsigned int length;
423   - unsigned int page;
424   - unsigned int status;
425   -
426   - AT91F_SpiEnable(pDataFlash->pDevice->cs);
427   -
428   - if ((dest + size) > (pDataFlash->pDevice->pages_size *
429   - (pDataFlash->pDevice->pages_number)))
430   - return DATAFLASH_MEMORY_OVERFLOW;
431   -
432   - /* If destination does not fit a page start address */
433   - if ((dest % ((unsigned int)(pDataFlash->pDevice->pages_size))) != 0) {
434   - length =
435   - pDataFlash->pDevice->pages_size -
436   - (dest % ((unsigned int)(pDataFlash->pDevice->pages_size)));
437   -
438   - if (size < length)
439   - length = size;
440   -
441   - if (!AT91F_PartialPageWrite(pDataFlash, src, dest, length))
442   - return DATAFLASH_ERROR;
443   -
444   - AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
445   - AT91C_TIMEOUT_WRDY);
446   -
447   - /* Update size, source and destination pointers */
448   - size -= length;
449   - dest += length;
450   - src += length;
451   - }
452   -
453   - while ((size - pDataFlash->pDevice->pages_size) >= 0) {
454   - /* program dataflash page */
455   - page = (unsigned int)dest / (pDataFlash->pDevice->pages_size);
456   -
457   - status = AT91F_DataFlashWriteBuffer(pDataFlash,
458   - DB_BUF1_WRITE, src, 0,
459   - pDataFlash->pDevice->
460   - pages_size);
461   - AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
462   - AT91C_TIMEOUT_WRDY);
463   -
464   - status = AT91F_PageErase(pDataFlash, page);
465   - AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
466   - AT91C_TIMEOUT_WRDY);
467   - if (!status)
468   - return DATAFLASH_ERROR;
469   -
470   - status = AT91F_WriteBufferToMain(pDataFlash,
471   - DB_BUF1_PAGE_PGM, dest);
472   - if (!status)
473   - return DATAFLASH_ERROR;
474   -
475   - AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
476   - AT91C_TIMEOUT_WRDY);
477   -
478   - /* Update size, source and destination pointers */
479   - size -= pDataFlash->pDevice->pages_size;
480   - dest += pDataFlash->pDevice->pages_size;
481   - src += pDataFlash->pDevice->pages_size;
482   - }
483   -
484   - /* If still some bytes to read */
485   - if (size > 0) {
486   - /* program dataflash page */
487   - if (!AT91F_PartialPageWrite(pDataFlash, src, dest, size))
488   - return DATAFLASH_ERROR;
489   -
490   - AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
491   - AT91C_TIMEOUT_WRDY);
492   - }
493   - return DATAFLASH_OK;
494   -}
495   -
496   -/*---------------------------------------------------------------------------*/
497   -/* Function Name : AT91F_DataFlashRead */
498   -/* Object : Read a block in dataflash */
499   -/* Input Parameters : */
500   -/* Return value : */
501   -/*---------------------------------------------------------------------------*/
502   -int AT91F_DataFlashRead(AT91PS_DataFlash pDataFlash,
503   - unsigned long addr, unsigned long size, char *buffer)
504   -{
505   - unsigned long SizeToRead;
506   -
507   - AT91F_SpiEnable(pDataFlash->pDevice->cs);
508   -
509   - if (AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
510   - AT91C_TIMEOUT_WRDY) != DATAFLASH_OK)
511   - return -1;
512   -
513   - while (size) {
514   - SizeToRead = (size < 0x8000) ? size : 0x8000;
515   -
516   - if (AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
517   - AT91C_TIMEOUT_WRDY) !=
518   - DATAFLASH_OK)
519   - return -1;
520   -
521   - if (AT91F_DataFlashContinuousRead(pDataFlash, addr,
522   - (uchar *) buffer,
523   - SizeToRead) != DATAFLASH_OK)
524   - return -1;
525   -
526   - size -= SizeToRead;
527   - addr += SizeToRead;
528   - buffer += SizeToRead;
529   - }
530   -
531   - return DATAFLASH_OK;
532   -}
533   -
534   -/*---------------------------------------------------------------------------*/
535   -/* Function Name : AT91F_DataflashProbe */
536   -/* Object : */
537   -/* Input Parameters : */
538   -/* Return value : Dataflash status register */
539   -/*---------------------------------------------------------------------------*/
540   -int AT91F_DataflashProbe(int cs, AT91PS_DataflashDesc pDesc)
541   -{
542   - AT91F_SpiEnable(cs);
543   - AT91F_DataFlashGetStatus(pDesc);
544   - return ((pDesc->command[1] == 0xFF) ? 0 : pDesc->command[1] & 0x3C);
545   -}
drivers/mtd/dataflash.c
View file @ c68c03f
1   -/*
2   - * LowLevel function for ATMEL DataFlash support
3   - * Author : Hamid Ikdoumi (Atmel)
4   - *
5   - * SPDX-License-Identifier: GPL-2.0+
6   - */
7   -#include <common.h>
8   -#include <config.h>
9   -#include <asm/hardware.h>
10   -#include <dataflash.h>
11   -
12   -static AT91S_DataFlash DataFlashInst;
13   -
14   -extern void AT91F_SpiInit (void);
15   -extern int AT91F_DataflashProbe (int i, AT91PS_DataflashDesc pDesc);
16   -extern int AT91F_DataFlashRead (AT91PS_DataFlash pDataFlash,
17   - unsigned long addr,
18   - unsigned long size, char *buffer);
19   -extern int AT91F_DataFlashWrite( AT91PS_DataFlash pDataFlash,
20   - unsigned char *src,
21   - int dest,
22   - int size );
23   -
24   -int AT91F_DataflashInit (void)
25   -{
26   - int i, j;
27   - int dfcode;
28   - int part;
29   - int found[CONFIG_SYS_MAX_DATAFLASH_BANKS];
30   - unsigned char protected;
31   -
32   - AT91F_SpiInit ();
33   -
34   - for (i = 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++) {
35   - found[i] = 0;
36   - dataflash_info[i].Desc.state = IDLE;
37   - dataflash_info[i].id = 0;
38   - dataflash_info[i].Device.pages_number = 0;
39   - dfcode = AT91F_DataflashProbe (cs[i].cs,
40   - &dataflash_info[i].Desc);
41   -
42   - switch (dfcode) {
43   - case AT45DB021:
44   - dataflash_info[i].Device.pages_number = 1024;
45   - dataflash_info[i].Device.pages_size = 264;
46   - dataflash_info[i].Device.page_offset = 9;
47   - dataflash_info[i].Device.byte_mask = 0x300;
48   - dataflash_info[i].Device.cs = cs[i].cs;
49   - dataflash_info[i].Desc.DataFlash_state = IDLE;
50   - dataflash_info[i].logical_address = cs[i].addr;
51   - dataflash_info[i].id = dfcode;
52   - found[i] += dfcode;
53   - break;
54   -
55   - case AT45DB081:
56   - dataflash_info[i].Device.pages_number = 4096;
57   - dataflash_info[i].Device.pages_size = 264;
58   - dataflash_info[i].Device.page_offset = 9;
59   - dataflash_info[i].Device.byte_mask = 0x300;
60   - dataflash_info[i].Device.cs = cs[i].cs;
61   - dataflash_info[i].Desc.DataFlash_state = IDLE;
62   - dataflash_info[i].logical_address = cs[i].addr;
63   - dataflash_info[i].id = dfcode;
64   - found[i] += dfcode;
65   - break;
66   -
67   - case AT45DB161:
68   - dataflash_info[i].Device.pages_number = 4096;
69   - dataflash_info[i].Device.pages_size = 528;
70   - dataflash_info[i].Device.page_offset = 10;
71   - dataflash_info[i].Device.byte_mask = 0x300;
72   - dataflash_info[i].Device.cs = cs[i].cs;
73   - dataflash_info[i].Desc.DataFlash_state = IDLE;
74   - dataflash_info[i].logical_address = cs[i].addr;
75   - dataflash_info[i].id = dfcode;
76   - found[i] += dfcode;
77   - break;
78   -
79   - case AT45DB321:
80   - dataflash_info[i].Device.pages_number = 8192;
81   - dataflash_info[i].Device.pages_size = 528;
82   - dataflash_info[i].Device.page_offset = 10;
83   - dataflash_info[i].Device.byte_mask = 0x300;
84   - dataflash_info[i].Device.cs = cs[i].cs;
85   - dataflash_info[i].Desc.DataFlash_state = IDLE;
86   - dataflash_info[i].logical_address = cs[i].addr;
87   - dataflash_info[i].id = dfcode;
88   - found[i] += dfcode;
89   - break;
90   -
91   - case AT45DB642:
92   - dataflash_info[i].Device.pages_number = 8192;
93   - dataflash_info[i].Device.pages_size = 1056;
94   - dataflash_info[i].Device.page_offset = 11;
95   - dataflash_info[i].Device.byte_mask = 0x700;
96   - dataflash_info[i].Device.cs = cs[i].cs;
97   - dataflash_info[i].Desc.DataFlash_state = IDLE;
98   - dataflash_info[i].logical_address = cs[i].addr;
99   - dataflash_info[i].id = dfcode;
100   - found[i] += dfcode;
101   - break;
102   -
103   - case AT45DB128:
104   - dataflash_info[i].Device.pages_number = 16384;
105   - dataflash_info[i].Device.pages_size = 1056;
106   - dataflash_info[i].Device.page_offset = 11;
107   - dataflash_info[i].Device.byte_mask = 0x700;
108   - dataflash_info[i].Device.cs = cs[i].cs;
109   - dataflash_info[i].Desc.DataFlash_state = IDLE;
110   - dataflash_info[i].logical_address = cs[i].addr;
111   - dataflash_info[i].id = dfcode;
112   - found[i] += dfcode;
113   - break;
114   -
115   - default:
116   - dfcode = 0;
117   - break;
118   - }
119   - /* set the last area end to the dataflash size*/
120   - dataflash_info[i].end_address =
121   - (dataflash_info[i].Device.pages_number *
122   - dataflash_info[i].Device.pages_size) - 1;
123   -
124   - part = 0;
125   - /* set the area addresses */
126   - for(j = 0; j < NB_DATAFLASH_AREA; j++) {
127   - if(found[i]!=0) {
128   - dataflash_info[i].Device.area_list[j].start =
129   - area_list[part].start +
130   - dataflash_info[i].logical_address;
131   - if(area_list[part].end == 0xffffffff) {
132   - dataflash_info[i].Device.area_list[j].end =
133   - dataflash_info[i].end_address +
134   - dataflash_info[i].logical_address;
135   - } else {
136   - dataflash_info[i].Device.area_list[j].end =
137   - area_list[part].end +
138   - dataflash_info[i].logical_address;
139   - }
140   - protected = area_list[part].protected;
141   - /* Set the environment according to the label...*/
142   - if(protected == FLAG_PROTECT_INVALID) {
143   - dataflash_info[i].Device.area_list[j].protected =
144   - FLAG_PROTECT_INVALID;
145   - } else {
146   - dataflash_info[i].Device.area_list[j].protected =
147   - protected;
148   - }
149   - strcpy((char*)(dataflash_info[i].Device.area_list[j].label),
150   - (const char *)area_list[part].label);
151   - }
152   - part++;
153   - }
154   - }
155   - return found[0];
156   -}
157   -
158   -void AT91F_Dataflashenv_set(void)
159   -{
160   - int i, j;
161   - int part;
162   - unsigned char env;
163   - unsigned char s[32]; /* Will fit a long int in hex */
164   - unsigned long start;
165   -
166   - for (i = 0, part= 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++) {
167   - for(j = 0; j < NB_DATAFLASH_AREA; j++) {
168   - env = area_list[part].setenv;
169   - /* Set the environment according to the label...*/
170   - if((env & FLAG_SETENV) == FLAG_SETENV) {
171   - start = dataflash_info[i].Device.area_list[j].start;
172   - sprintf((char *)s, "%lX", start);
173   - env_set((char *)area_list[part].label,
174   - (char *)s);
175   - }
176   - part++;
177   - }
178   - }
179   -}
180   -
181   -void dataflash_print_info (void)
182   -{
183   - int i, j;
184   -
185   - for (i = 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++) {
186   - if (dataflash_info[i].id != 0) {
187   - printf("DataFlash:");
188   - switch (dataflash_info[i].id) {
189   - case AT45DB021:
190   - printf("AT45DB021\n");
191   - break;
192   - case AT45DB161:
193   - printf("AT45DB161\n");
194   - break;
195   -
196   - case AT45DB321:
197   - printf("AT45DB321\n");
198   - break;
199   -
200   - case AT45DB642:
201   - printf("AT45DB642\n");
202   - break;
203   - case AT45DB128:
204   - printf("AT45DB128\n");
205   - break;
206   - }
207   -
208   - printf("Nb pages: %6d\n"
209   - "Page Size: %6d\n"
210   - "Size=%8d bytes\n"
211   - "Logical address: 0x%08X\n",
212   - (unsigned int) dataflash_info[i].Device.pages_number,
213   - (unsigned int) dataflash_info[i].Device.pages_size,
214   - (unsigned int) dataflash_info[i].Device.pages_number *
215   - dataflash_info[i].Device.pages_size,
216   - (unsigned int) dataflash_info[i].logical_address);
217   - for (j = 0; j < NB_DATAFLASH_AREA; j++) {
218   - switch(dataflash_info[i].Device.area_list[j].protected) {
219   - case FLAG_PROTECT_SET:
220   - case FLAG_PROTECT_CLEAR:
221   - printf("Area %i:\t%08lX to %08lX %s", j,
222   - dataflash_info[i].Device.area_list[j].start,
223   - dataflash_info[i].Device.area_list[j].end,
224   - (dataflash_info[i].Device.area_list[j].protected==FLAG_PROTECT_SET) ? "(RO)" : " ");
225   - printf(" %s\n", dataflash_info[i].Device.area_list[j].label);
226   - break;
227   - case FLAG_PROTECT_INVALID:
228   - break;
229   - }
230   - }
231   - }
232   - }
233   -}
234   -
235   -/*---------------------------------------------------------------------------*/
236   -/* Function Name : AT91F_DataflashSelect */
237   -/* Object : Select the correct device */
238   -/*---------------------------------------------------------------------------*/
239   -AT91PS_DataFlash AT91F_DataflashSelect (AT91PS_DataFlash pFlash,
240   - unsigned long *addr)
241   -{
242   - char addr_valid = 0;
243   - int i;
244   -
245   - for (i = 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++)
246   - if ( dataflash_info[i].id
247   - && ((((int) *addr) & 0xFF000000) ==
248   - dataflash_info[i].logical_address)) {
249   - addr_valid = 1;
250   - break;
251   - }
252   - if (!addr_valid) {
253   - pFlash = (AT91PS_DataFlash) 0;
254   - return pFlash;
255   - }
256   - pFlash->pDataFlashDesc = &(dataflash_info[i].Desc);
257   - pFlash->pDevice = &(dataflash_info[i].Device);
258   - *addr -= dataflash_info[i].logical_address;
259   - return (pFlash);
260   -}
261   -
262   -/*---------------------------------------------------------------------------*/
263   -/* Function Name : addr_dataflash */
264   -/* Object : Test if address is valid */
265   -/*---------------------------------------------------------------------------*/
266   -int addr_dataflash (unsigned long addr)
267   -{
268   - int addr_valid = 0;
269   - int i;
270   -
271   - for (i = 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++) {
272   - if ((((int) addr) & 0xFF000000) ==
273   - dataflash_info[i].logical_address) {
274   - addr_valid = 1;
275   - break;
276   - }
277   - }
278   -
279   - return addr_valid;
280   -}
281   -
282   -/*---------------------------------------------------------------------------*/
283   -/* Function Name : size_dataflash */
284   -/* Object : Test if address is valid regarding the size */
285   -/*---------------------------------------------------------------------------*/
286   -int size_dataflash (AT91PS_DataFlash pdataFlash, unsigned long addr,
287   - unsigned long size)
288   -{
289   - /* is outside the dataflash */
290   - if (((int)addr & 0x0FFFFFFF) > (pdataFlash->pDevice->pages_size *
291   - pdataFlash->pDevice->pages_number)) return 0;
292   - /* is too large for the dataflash */
293   - if (size > ((pdataFlash->pDevice->pages_size *
294   - pdataFlash->pDevice->pages_number) -
295   - ((int)addr & 0x0FFFFFFF))) return 0;
296   -
297   - return 1;
298   -}
299   -
300   -/*---------------------------------------------------------------------------*/
301   -/* Function Name : prot_dataflash */
302   -/* Object : Test if destination area is protected */
303   -/*---------------------------------------------------------------------------*/
304   -int prot_dataflash (AT91PS_DataFlash pdataFlash, unsigned long addr)
305   -{
306   - int area;
307   -
308   - /* find area */
309   - for (area = 0; area < NB_DATAFLASH_AREA; area++) {
310   - if ((addr >= pdataFlash->pDevice->area_list[area].start) &&
311   - (addr < pdataFlash->pDevice->area_list[area].end))
312   - break;
313   - }
314   - if (area == NB_DATAFLASH_AREA)
315   - return -1;
316   -
317   - /*test protection value*/
318   - if (pdataFlash->pDevice->area_list[area].protected == FLAG_PROTECT_SET)
319   - return 0;
320   - if (pdataFlash->pDevice->area_list[area].protected == FLAG_PROTECT_INVALID)
321   - return 0;
322   -
323   - return 1;
324   -}
325   -
326   -/*--------------------------------------------------------------------------*/
327   -/* Function Name : dataflash_real_protect */
328   -/* Object : protect/unprotect area */
329   -/*--------------------------------------------------------------------------*/
330   -int dataflash_real_protect (int flag, unsigned long start_addr,
331   - unsigned long end_addr)
332   -{
333   - int i,j, area1, area2, addr_valid = 0;
334   -
335   - /* find dataflash */
336   - for (i = 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++) {
337   - if ((((int) start_addr) & 0xF0000000) ==
338   - dataflash_info[i].logical_address) {
339   - addr_valid = 1;
340   - break;
341   - }
342   - }
343   - if (!addr_valid) {
344   - return -1;
345   - }
346   - /* find start area */
347   - for (area1 = 0; area1 < NB_DATAFLASH_AREA; area1++) {
348   - if (start_addr == dataflash_info[i].Device.area_list[area1].start)
349   - break;
350   - }
351   - if (area1 == NB_DATAFLASH_AREA) return -1;
352   - /* find end area */
353   - for (area2 = 0; area2 < NB_DATAFLASH_AREA; area2++) {
354   - if (end_addr == dataflash_info[i].Device.area_list[area2].end)
355   - break;
356   - }
357   - if (area2 == NB_DATAFLASH_AREA)
358   - return -1;
359   -
360   - /*set protection value*/
361   - for(j = area1; j < area2 + 1 ; j++)
362   - if(dataflash_info[i].Device.area_list[j].protected
363   - != FLAG_PROTECT_INVALID) {
364   - if (flag == 0) {
365   - dataflash_info[i].Device.area_list[j].protected
366   - = FLAG_PROTECT_CLEAR;
367   - } else {
368   - dataflash_info[i].Device.area_list[j].protected
369   - = FLAG_PROTECT_SET;
370   - }
371   - }
372   -
373   - return (area2 - area1 + 1);
374   -}
375   -
376   -/*---------------------------------------------------------------------------*/
377   -/* Function Name : read_dataflash */
378   -/* Object : dataflash memory read */
379   -/*---------------------------------------------------------------------------*/
380   -int read_dataflash (unsigned long addr, unsigned long size, char *result)
381   -{
382   - unsigned long AddrToRead = addr;
383   - AT91PS_DataFlash pFlash = &DataFlashInst;
384   -
385   - pFlash = AT91F_DataflashSelect (pFlash, &AddrToRead);
386   -
387   - if (pFlash == 0)
388   - return ERR_UNKNOWN_FLASH_TYPE;
389   -
390   - if (size_dataflash(pFlash,addr,size) == 0)
391   - return ERR_INVAL;
392   -
393   - return (AT91F_DataFlashRead (pFlash, AddrToRead, size, result));
394   -}
395   -
396   -/*---------------------------------------------------------------------------*/
397   -/* Function Name : write_dataflash */
398   -/* Object : write a block in dataflash */
399   -/*---------------------------------------------------------------------------*/
400   -int write_dataflash (unsigned long addr_dest, unsigned long addr_src,
401   - unsigned long size)
402   -{
403   - unsigned long AddrToWrite = addr_dest;
404   - AT91PS_DataFlash pFlash = &DataFlashInst;
405   -
406   - pFlash = AT91F_DataflashSelect (pFlash, &AddrToWrite);
407   -
408   - if (pFlash == 0)
409   - return ERR_UNKNOWN_FLASH_TYPE;
410   -
411   - if (size_dataflash(pFlash,addr_dest,size) == 0)
412   - return ERR_INVAL;
413   -
414   - if (prot_dataflash(pFlash,addr_dest) == 0)
415   - return ERR_PROTECTED;
416   -
417   - if (AddrToWrite == -1)
418   - return -1;
419   -
420   - return AT91F_DataFlashWrite (pFlash, (uchar *)addr_src,
421   - AddrToWrite, size);
422   -}
423   -
424   -void dataflash_perror (int err)
425   -{
426   - switch (err) {
427   - case ERR_OK:
428   - break;
429   - case ERR_TIMOUT:
430   - printf("Timeout writing to DataFlash\n");
431   - break;
432   - case ERR_PROTECTED:
433   - printf("Can't write to protected/invalid DataFlash sectors\n");
434   - break;
435   - case ERR_INVAL:
436   - printf("Outside available DataFlash\n");
437   - break;
438   - case ERR_UNKNOWN_FLASH_TYPE:
439   - printf("Unknown Type of DataFlash\n");
440   - break;
441   - case ERR_PROG_ERROR:
442   - printf("General DataFlash Programming Error\n");
443   - break;
444   - default:
445   - printf("%s[%d] FIXME: rc=%d\n", __FILE__, __LINE__, err);
446   - break;
447   - }
448   -}
include/dataflash.h
View file @ c68c03f
1   -/*
2   - * (C) Copyright 2003
3   - * Data Flash Atmel Description File
4   - * Author : Hamid Ikdoumi (Atmel)
5   - *
6   - * SPDX-License-Identifier: GPL-2.0+
7   - */
8   -
9   -/* File Name : dataflash.h */
10   -/* Object : Data Flash Atmel Description File */
11   -/* Translator : */
12   -/* */
13   -/* 1.0 03/04/01 HI : Creation */
14   -/* 1.2 20/10/02 FB : Adapatation Service and Lib v3 */
15   -/*----------------------------------------------------------------------*/
16   -
17   -#ifndef _DataFlash_h
18   -#define _DataFlash_h
19   -
20   -
21   -#include "config.h"
22   -
23   -/*number of protected area*/
24   -#define NB_DATAFLASH_AREA 5
25   -
26   -#ifndef CONFIG_MTD_NOR_FLASH
27   -
28   -/*-----------------------------------------------------------------------
29   - * return codes from flash_write():
30   - */
31   -# define ERR_OK 0
32   -# define ERR_TIMOUT 1
33   -# define ERR_NOT_ERASED 2
34   -# define ERR_PROTECTED 4
35   -# define ERR_INVAL 8
36   -# define ERR_ALIGN 16
37   -# define ERR_UNKNOWN_FLASH_VENDOR 32
38   -# define ERR_UNKNOWN_FLASH_TYPE 64
39   -# define ERR_PROG_ERROR 128
40   -
41   -/*-----------------------------------------------------------------------
42   - * Protection Flags for flash_protect():
43   - */
44   -# define FLAG_PROTECT_SET 0x01
45   -# define FLAG_PROTECT_CLEAR 0x02
46   -# define FLAG_PROTECT_INVALID 0x03
47   -
48   -/*-----------------------------------------------------------------------
49   - * Set Environment according to label:
50   - */
51   -# define FLAG_SETENV 0x80
52   -#endif /* CONFIG_MTD_NOR_FLASH */
53   -
54   -/*define the area structure*/
55   -typedef struct {
56   - unsigned long start;
57   - unsigned long end;
58   - unsigned char protected;
59   - unsigned char setenv;
60   - unsigned char label[20];
61   -} dataflash_protect_t;
62   -
63   -typedef unsigned int AT91S_DataFlashStatus;
64   -
65   -/*----------------------------------------------------------------------*/
66   -/* DataFlash Structures */
67   -/*----------------------------------------------------------------------*/
68   -
69   -/*---------------------------------------------*/
70   -/* DataFlash Descriptor Structure Definition */
71   -/*---------------------------------------------*/
72   -typedef struct _AT91S_DataflashDesc {
73   - unsigned char *tx_cmd_pt;
74   - unsigned int tx_cmd_size;
75   - unsigned char *rx_cmd_pt;
76   - unsigned int rx_cmd_size;
77   - unsigned char *tx_data_pt;
78   - unsigned int tx_data_size;
79   - unsigned char *rx_data_pt;
80   - unsigned int rx_data_size;
81   - volatile unsigned char state;
82   - volatile unsigned char DataFlash_state;
83   - unsigned char command[8];
84   -} AT91S_DataflashDesc, *AT91PS_DataflashDesc;
85   -
86   -/*---------------------------------------------*/
87   -/* DataFlash device definition structure */
88   -/*---------------------------------------------*/
89   -typedef struct _AT91S_Dataflash {
90   - int pages_number; /* dataflash page number */
91   - int pages_size; /* dataflash page size */
92   - int page_offset; /* page offset in command */
93   - int byte_mask; /* byte mask in command */
94   - int cs;
95   - dataflash_protect_t area_list[NB_DATAFLASH_AREA]; /* area protection status */
96   -} AT91S_DataflashFeatures, *AT91PS_DataflashFeatures;
97   -
98   -/*---------------------------------------------*/
99   -/* DataFlash Structure Definition */
100   -/*---------------------------------------------*/
101   -typedef struct _AT91S_DataFlash {
102   - AT91PS_DataflashDesc pDataFlashDesc; /* dataflash descriptor */
103   - AT91PS_DataflashFeatures pDevice; /* Pointer on a dataflash features array */
104   -} AT91S_DataFlash, *AT91PS_DataFlash;
105   -
106   -
107   -typedef struct _AT91S_DATAFLASH_INFO {
108   -
109   - AT91S_DataflashDesc Desc;
110   - AT91S_DataflashFeatures Device; /* Pointer on a dataflash features array */
111   - unsigned long logical_address;
112   - unsigned long end_address;
113   - unsigned int id; /* device id */
114   -} AT91S_DATAFLASH_INFO, *AT91PS_DATAFLASH_INFO;
115   -
116   -struct dataflash_addr {
117   - unsigned long addr;
118   - int cs;
119   -};
120   -/*-------------------------------------------------------------------------------------------------*/
121   -#define AT45DB161 0x2c
122   -#define AT45DB021 0x14
123   -#define AT45DB081 0x24
124   -#define AT45DB321 0x34
125   -#define AT45DB642 0x3c
126   -#define AT45DB128 0x10
127   -#define PAGES_PER_BLOCK 8
128   -
129   -#define AT91C_DATAFLASH_TIMEOUT 10000 /* For AT91F_DataFlashWaitReady */
130   -
131   -/* DataFlash return value */
132   -#define DATAFLASH_BUSY 0x00
133   -#define DATAFLASH_OK 0x01
134   -#define DATAFLASH_ERROR 0x02
135   -#define DATAFLASH_MEMORY_OVERFLOW 0x03
136   -#define DATAFLASH_BAD_COMMAND 0x04
137   -#define DATAFLASH_BAD_ADDRESS 0x05
138   -
139   -
140   -/* Driver State */
141   -#define IDLE 0x0
142   -#define BUSY 0x1
143   -#define ERROR 0x2
144   -
145   -/* DataFlash Driver State */
146   -#define GET_STATUS 0x0F
147   -
148   -/*-------------------------------------------------------------------------------------------------*/
149   -/* Command Definition */
150   -/*-------------------------------------------------------------------------------------------------*/
151   -
152   -/* READ COMMANDS */
153   -#define DB_CONTINUOUS_ARRAY_READ 0xE8 /* Continuous array read */
154   -#define DB_BURST_ARRAY_READ 0xE8 /* Burst array read */
155   -#define DB_PAGE_READ 0xD2 /* Main memory page read */
156   -#define DB_BUF1_READ 0xD4 /* Buffer 1 read */
157   -#define DB_BUF2_READ 0xD6 /* Buffer 2 read */
158   -#define DB_STATUS 0xD7 /* Status Register */
159   -
160   -/* PROGRAM and ERASE COMMANDS */
161   -#define DB_BUF1_WRITE 0x84 /* Buffer 1 write */
162   -#define DB_BUF2_WRITE 0x87 /* Buffer 2 write */
163   -#define DB_BUF1_PAGE_ERASE_PGM 0x83 /* Buffer 1 to main memory page program with built-In erase */
164   -#define DB_BUF1_PAGE_ERASE_FASTPGM 0x93 /* Buffer 1 to main memory page program with built-In erase, Fast program */
165   -#define DB_BUF2_PAGE_ERASE_PGM 0x86 /* Buffer 2 to main memory page program with built-In erase */
166   -#define DB_BUF2_PAGE_ERASE_FASTPGM 0x96 /* Buffer 1 to main memory page program with built-In erase, Fast program */
167   -#define DB_BUF1_PAGE_PGM 0x88 /* Buffer 1 to main memory page program without built-In erase */
168   -#define DB_BUF1_PAGE_FASTPGM 0x98 /* Buffer 1 to main memory page program without built-In erase, Fast program */
169   -#define DB_BUF2_PAGE_PGM 0x89 /* Buffer 2 to main memory page program without built-In erase */
170   -#define DB_BUF2_PAGE_FASTPGM 0x99 /* Buffer 1 to main memory page program without built-In erase, Fast program */
171   -#define DB_PAGE_ERASE 0x81 /* Page Erase */
172   -#define DB_BLOCK_ERASE 0x50 /* Block Erase */
173   -#define DB_PAGE_PGM_BUF1 0x82 /* Main memory page through buffer 1 */
174   -#define DB_PAGE_FASTPGM_BUF1 0x92 /* Main memory page through buffer 1, Fast program */
175   -#define DB_PAGE_PGM_BUF2 0x85 /* Main memory page through buffer 2 */
176   -#define DB_PAGE_FastPGM_BUF2 0x95 /* Main memory page through buffer 2, Fast program */
177   -
178   -/* ADDITIONAL COMMANDS */
179   -#define DB_PAGE_2_BUF1_TRF 0x53 /* Main memory page to buffer 1 transfert */
180   -#define DB_PAGE_2_BUF2_TRF 0x55 /* Main memory page to buffer 2 transfert */
181   -#define DB_PAGE_2_BUF1_CMP 0x60 /* Main memory page to buffer 1 compare */
182   -#define DB_PAGE_2_BUF2_CMP 0x61 /* Main memory page to buffer 2 compare */
183   -#define DB_AUTO_PAGE_PGM_BUF1 0x58 /* Auto page rewrite throught buffer 1 */
184   -#define DB_AUTO_PAGE_PGM_BUF2 0x59 /* Auto page rewrite throught buffer 2 */
185   -
186   -/*-------------------------------------------------------------------------------------------------*/
187   -
188   -extern int size_dataflash (AT91PS_DataFlash pdataFlash, unsigned long addr, unsigned long size);
189   -extern int prot_dataflash (AT91PS_DataFlash pdataFlash, unsigned long addr);
190   -extern int addr2ram(ulong addr);
191   -extern int dataflash_real_protect (int flag, unsigned long start_addr, unsigned long end_addr);
192   -extern int addr_dataflash (unsigned long addr);
193   -extern int read_dataflash (unsigned long addr, unsigned long size, char *result);
194   -extern int write_dataflash(unsigned long addr_dest, unsigned long addr_src,
195   - unsigned long size);
196   -extern int AT91F_DataflashInit(void);
197   -
198   -extern void dataflash_print_info (void);
199   -extern void dataflash_perror (int err);
200   -extern void AT91F_Dataflashenv_set(void);
201   -
202   -extern struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS];
203   -extern dataflash_protect_t area_list[NB_DATAFLASH_AREA];
204   -extern AT91S_DATAFLASH_INFO dataflash_info[];
205   -#endif
scripts/config_whitelist.txt
Diff comments   View file @ c68c03f
... ... @@ -875,7 +875,6 @@
875 875 CONFIG_H264_FREQ
876 876 CONFIG_H8300
877 877 CONFIG_HARD_SPI
878   -CONFIG_HAS_DATAFLASH
879 878 CONFIG_HAS_ETH0
880 879 CONFIG_HAS_ETH1
881 880 CONFIG_HAS_ETH2
... ... @@ -2609,9 +2608,6 @@
2609 2608 CONFIG_SYS_DA850_PLL1_PLLM
2610 2609 CONFIG_SYS_DA850_PLL1_POSTDIV
2611 2610 CONFIG_SYS_DA850_SYSCFG_SUSPSRC
2612   -CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS1
2613   -CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS2
2614   -CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS3
2615 2611 CONFIG_SYS_DAVINCI_EMAC_PHY_COUNT
2616 2612 CONFIG_SYS_DAVINCI_I2C_SLAVE
2617 2613 CONFIG_SYS_DAVINCI_I2C_SLAVE1
... ... @@ -3721,7 +3717,6 @@
3721 3717 CONFIG_SYS_MATRIX_EBICSA_VAL
3722 3718 CONFIG_SYS_MATRIX_MCFG_REMAP
3723 3719 CONFIG_SYS_MAXARGS
3724   -CONFIG_SYS_MAX_DATAFLASH_BANKS
3725 3720 CONFIG_SYS_MAX_DDR_BAT_SIZE
3726 3721 CONFIG_SYS_MAX_FLASH_BANKS
3727 3722 CONFIG_SYS_MAX_FLASH_BANKS_DETECT