]> git.sur5r.net Git - u-boot/commitdiff
Drop CONFIG_HAS_DATAFLASH
authorTuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
Tue, 10 Oct 2017 18:59:42 +0000 (21:59 +0300)
committerTom Rini <trini@konsulko.com>
Mon, 16 Oct 2017 13:42:51 +0000 (09:42 -0400)
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>
31 files changed:
README
arch/arm/mach-at91/arm926ejs/at91sam9260_devices.c
arch/arm/mach-at91/arm926ejs/at91sam9261_devices.c
arch/arm/mach-at91/arm926ejs/at91sam9263_devices.c
arch/arm/mach-at91/arm926ejs/at91sam9m10g45_devices.c
arch/arm/mach-at91/arm926ejs/at91sam9rl_devices.c
board/atmel/at91sam9260ek/Makefile
board/atmel/at91sam9260ek/partition.c [deleted file]
board/atmel/at91sam9261ek/Makefile
board/atmel/at91sam9261ek/partition.c [deleted file]
board/atmel/at91sam9263ek/Makefile
board/atmel/at91sam9263ek/partition.c [deleted file]
board/atmel/at91sam9rlek/Makefile
board/atmel/at91sam9rlek/partition.c [deleted file]
board/esd/meesc/Makefile
board/esd/meesc/partition.c [deleted file]
board/mini-box/picosam9g45/picosam9g45.c
board/ronetix/pm9261/Makefile
board/ronetix/pm9261/partition.c [deleted file]
board/ronetix/pm9263/Makefile
board/ronetix/pm9263/partition.c [deleted file]
board/siemens/corvus/board.c
cmd/flash.c
cmd/mem.c
common/board_r.c
common/image.c
drivers/mtd/Makefile
drivers/mtd/at45.c [deleted file]
drivers/mtd/dataflash.c [deleted file]
include/dataflash.h [deleted file]
scripts/config_whitelist.txt

diff --git a/README b/README
index ca07f7a3f9109e9139fd6ec4a2513bc6befe262c..242287ca9b930c6a33a8bd9b523b8b48d22da856 100644 (file)
--- a/README
+++ b/README
@@ -2312,13 +2312,6 @@ The following options need to be configured:
                this is instead controlled by the value of
                /config/load-environment.
 
-- DataFlash Support:
-               CONFIG_HAS_DATAFLASH
-
-               Defining this option enables DataFlash features and
-               allows to read/write in Dataflash via the standard
-               commands cp, md...
-
 - Serial Flash support
                Usage requires an initial 'sf probe' to define the serial
                flash parameters, followed by read/write/erase/update
index 912a966bae5c91f959b77c0bb20298249357251e..bb3e36552a9edb55d679631dd418d4b3e7f0563a 100644 (file)
@@ -58,7 +58,7 @@ void at91_seriald_hw_init(void)
        at91_periph_clk_enable(ATMEL_ID_SYS);
 }
 
-#if defined(CONFIG_HAS_DATAFLASH) || defined(CONFIG_ATMEL_SPI)
+#ifdef CONFIG_ATMEL_SPI
 void at91_spi0_hw_init(unsigned long cs_mask)
 {
        at91_set_a_periph(AT91_PIO_PORTA, 0, PUP);      /* SPI0_MISO */
index 4bd4e75e0bbdd3dbd6fefd97c14dcaf6872f9361..58050a2a246139dc9d28e0c75d499cc4cedc6018 100644 (file)
@@ -55,7 +55,7 @@ void at91_seriald_hw_init(void)
        at91_periph_clk_enable(ATMEL_ID_SYS);
 }
 
-#if defined(CONFIG_HAS_DATAFLASH) || defined(CONFIG_ATMEL_SPI)
+#ifdef CONFIG_ATMEL_SPI
 void at91_spi0_hw_init(unsigned long cs_mask)
 {
        at91_set_a_periph(AT91_PIO_PORTA, 0, PUP);      /* SPI0_MISO */
index f3f480010a4a1faea67ee067507e94617afd6608..674eb66e8e5e912bd84e2f9cc7bad683c7cbf024 100644 (file)
@@ -59,7 +59,7 @@ void at91_seriald_hw_init(void)
        at91_periph_clk_enable(ATMEL_ID_SYS);
 }
 
-#if defined(CONFIG_HAS_DATAFLASH) || defined(CONFIG_ATMEL_SPI)
+#ifdef CONFIG_ATMEL_SPI
 void at91_spi0_hw_init(unsigned long cs_mask)
 {
        at91_set_b_periph(AT91_PIO_PORTA, 0, PUP);      /* SPI0_MISO */
index eddfdb0853662b3392432ccf0ce68cc4f074f08c..b9efa273a0648a22e252828f3fe13eec2a199344 100644 (file)
@@ -56,7 +56,7 @@ void at91_seriald_hw_init(void)
        at91_periph_clk_enable(ATMEL_ID_SYS);
 }
 
-#if defined(CONFIG_HAS_DATAFLASH) || defined(CONFIG_ATMEL_SPI)
+#ifdef CONFIG_ATMEL_SPI
 void at91_spi0_hw_init(unsigned long cs_mask)
 {
        at91_set_a_periph(AT91_PIO_PORTB, 0, PUP);      /* SPI0_MISO */
index dbf9386faae38016f3c891622b1d5961a69411a4..cd38c6597a4d301b572c1698aaf20e5c9bee173f 100644 (file)
@@ -55,7 +55,7 @@ void at91_seriald_hw_init(void)
        at91_periph_clk_enable(ATMEL_ID_SYS);
 }
 
-#if defined(CONFIG_HAS_DATAFLASH) || defined(CONFIG_ATMEL_SPI)
+#ifdef CONFIG_ATMEL_SPI
 void at91_spi0_hw_init(unsigned long cs_mask)
 {
        at91_set_a_periph(AT91_PIO_PORTA, 25, PUP);     /* SPI0_MISO */
index 07c6184352245af0be70d7ee521045c5b3ff23a5..ad95928701f4567b07314b3be6c1ece165558c9e 100644 (file)
@@ -11,4 +11,3 @@
 
 obj-y  += at91sam9260ek.o
 obj-$(CONFIG_AT91_LED) += led.o
-obj-$(CONFIG_HAS_DATAFLASH) += partition.o
diff --git a/board/atmel/at91sam9260ek/partition.c b/board/atmel/at91sam9260ek/partition.c
deleted file mode 100644 (file)
index e41eefe..0000000
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * (C) Copyright 2008
- * Ulf Samuelsson <ulf@atmel.com>
- *
- * SPDX-License-Identifier:    GPL-2.0+
- */
-#include <common.h>
-#include <config.h>
-#include <asm/hardware.h>
-#include <dataflash.h>
-
-AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS];
-
-struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = {
-       {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0},       /* Logical adress, CS */
-       {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS1, 1}
-};
-
-/*define the area offsets*/
-dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
-       {0x00000000, 0x000041FF, FLAG_PROTECT_SET,   0, "Bootstrap"},
-       {0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"},
-       {0x00008400, 0x00083FFF, FLAG_PROTECT_SET,   0, "U-Boot"},
-       {0x00084000, 0x00293FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"},
-       {0x00294000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"},
-};
index d7ba1533d8e12f61fdbc2774837a3d91e7be292d..1e807ecc14d633481340c947a854564a0eaceec7 100644 (file)
@@ -11,4 +11,3 @@
 
 obj-y += at91sam9261ek.o
 obj-$(CONFIG_AT91_LED) += led.o
-obj-$(CONFIG_HAS_DATAFLASH) += partition.o
diff --git a/board/atmel/at91sam9261ek/partition.c b/board/atmel/at91sam9261ek/partition.c
deleted file mode 100644 (file)
index ed97609..0000000
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * (C) Copyright 2008
- * Ulf Samuelsson <ulf@atmel.com>
- *
- * SPDX-License-Identifier:    GPL-2.0+
- */
-#include <common.h>
-#include <config.h>
-#include <asm/hardware.h>
-#include <dataflash.h>
-
-AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS];
-
-struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = {
-       {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0},       /* Logical adress, CS */
-       {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS3, 3}
-};
-
-/*define the area offsets*/
-dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
-       {0x00000000, 0x000041FF, FLAG_PROTECT_SET,   0, "Bootstrap"},
-       {0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"},
-       {0x00008400, 0x00083FFF, FLAG_PROTECT_SET,   0, "U-Boot"},
-       {0x00084000, 0x00293FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"},
-       {0x00294000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"},
-};
index f3cd9d556e3922abb178284c7da8c855fc345a0e..b7a30ee6ef7b028fd75ee0aef150860490b72c81 100644 (file)
@@ -11,4 +11,3 @@
 
 obj-y += at91sam9263ek.o
 obj-$(CONFIG_AT91_LED) += led.o
-obj-$(CONFIG_HAS_DATAFLASH) += partition.o
diff --git a/board/atmel/at91sam9263ek/partition.c b/board/atmel/at91sam9263ek/partition.c
deleted file mode 100644 (file)
index 8617f48..0000000
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * (C) Copyright 2008
- * Ulf Samuelsson <ulf@atmel.com>
- *
- * SPDX-License-Identifier:    GPL-2.0+
- */
-#include <common.h>
-#include <config.h>
-#include <asm/hardware.h>
-#include <dataflash.h>
-
-AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS];
-
-struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = {
-       {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0},       /* Logical adress, CS */
-};
-
-/*define the area offsets*/
-dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
-       {0x00000000, 0x000041FF, FLAG_PROTECT_SET,   0, "Bootstrap"},
-       {0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"},
-       {0x00008400, 0x00083FFF, FLAG_PROTECT_SET,   0, "U-Boot"},
-       {0x00084000, 0x00293FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"},
-       {0x00294000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"},
-};
index 7acfee53503c46e0c710f5b2990a5c78d7e7a4e8..89f6c0833c6bcbdfe3775eaa8d302db03a17a29e 100644 (file)
@@ -11,4 +11,3 @@
 
 obj-y += at91sam9rlek.o
 obj-$(CONFIG_AT91_LED) += led.o
-obj-$(CONFIG_HAS_DATAFLASH) += partition.o
diff --git a/board/atmel/at91sam9rlek/partition.c b/board/atmel/at91sam9rlek/partition.c
deleted file mode 100644 (file)
index 8617f48..0000000
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * (C) Copyright 2008
- * Ulf Samuelsson <ulf@atmel.com>
- *
- * SPDX-License-Identifier:    GPL-2.0+
- */
-#include <common.h>
-#include <config.h>
-#include <asm/hardware.h>
-#include <dataflash.h>
-
-AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS];
-
-struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = {
-       {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0},       /* Logical adress, CS */
-};
-
-/*define the area offsets*/
-dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
-       {0x00000000, 0x000041FF, FLAG_PROTECT_SET,   0, "Bootstrap"},
-       {0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"},
-       {0x00008400, 0x00083FFF, FLAG_PROTECT_SET,   0, "U-Boot"},
-       {0x00084000, 0x00293FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"},
-       {0x00294000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"},
-};
index 5d1673820dfec30ba0c5aa3cc13b56084487d944..f3bf05d47b1459056cd1877f60888cc35a493d12 100644 (file)
@@ -10,4 +10,3 @@
 #
 
 obj-y  += meesc.o
-obj-$(CONFIG_HAS_DATAFLASH) += partition.o
diff --git a/board/esd/meesc/partition.c b/board/esd/meesc/partition.c
deleted file mode 100644 (file)
index b6afafc..0000000
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * (C) Copyright 2008
- * Ulf Samuelsson <ulf@atmel.com>
- *
- * SPDX-License-Identifier:    GPL-2.0+
- */
-#include <common.h>
-#include <config.h>
-#include <asm/hardware.h>
-#include <dataflash.h>
-
-AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS];
-
-struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = {
-       {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0},       /* Logical adress, CS */
-};
-
-/* define the area offsets */
-dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
-       {0x00000000, 0x000041FF, FLAG_PROTECT_SET,   0, "Bootstrap"},
-       {0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"},
-       {0x00008400, 0x00041FFF, FLAG_PROTECT_SET,   0, "U-Boot"},
-};
index 09ec24766333293bac0ea6f7c54414ee8f099b2a..f3263eba6e6310b5ce6a8fcc0b34c00287099eab 100644 (file)
@@ -261,9 +261,6 @@ int board_init(void)
 #ifdef CONFIG_CMD_USB
        picosam9g45_usb_hw_init();
 #endif
-#ifdef CONFIG_HAS_DATAFLASH
-       at91_spi0_hw_init(1 << 0);
-#endif
 #ifdef CONFIG_ATMEL_SPI
        at91_spi0_hw_init(1 << 4);
 #endif
index 90835d372f3b41838c67005cdf43554490873ea6..a133b07d0bf019b3cea2bc3c1fb04189025b6bf1 100644 (file)
@@ -12,4 +12,3 @@
 
 obj-y += pm9261.o
 obj-$(CONFIG_RED_LED) += led.o
-obj-$(CONFIG_HAS_DATAFLASH) += partition.o
diff --git a/board/ronetix/pm9261/partition.c b/board/ronetix/pm9261/partition.c
deleted file mode 100644 (file)
index 23ab8cf..0000000
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * (C) Copyright 2008
- * Ulf Samuelsson <ulf@atmel.com>
- * Ilko Iliev <www.ronetix.at>
- *
- * SPDX-License-Identifier:    GPL-2.0+
- */
-#include <common.h>
-#include <config.h>
-#include <asm/hardware.h>
-#include <dataflash.h>
-
-AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS];
-
-struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = {
-       {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0},       /* Logical adress, CS */
-};
-
-/*define the area offsets*/
-#ifdef CONFIG_SYS_USE_DATAFLASH
-dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
-       {0x00000000, 0x000041FF, FLAG_PROTECT_SET,   0, "Bootstrap"},
-       {0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"},
-       {0x00008400, 0x00041FFF, FLAG_PROTECT_SET,   0, "U-Boot"},
-       {0x00042000, 0x00251FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"},
-       {0x00252000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"},
-};
-#else
-dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
-       {0x00000000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, ""},
-};
-
-#endif
index 53e621dc8032afa46c58e1a16edd2ea6458d2090..72aa107b6e058f5e9badfef66bc24968dd55e0a3 100644 (file)
@@ -12,4 +12,3 @@
 
 obj-y += pm9263.o
 obj-$(CONFIG_AT91_LED) += led.o
-obj-$(CONFIG_HAS_DATAFLASH) += partition.o
diff --git a/board/ronetix/pm9263/partition.c b/board/ronetix/pm9263/partition.c
deleted file mode 100644 (file)
index 9cc4214..0000000
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * (C) Copyright 2008
- * Ulf Samuelsson <ulf@atmel.com>
- * Ilko Iliev <www.ronetix.at>
- *
- * SPDX-License-Identifier:    GPL-2.0+
- */
-#include <common.h>
-#include <config.h>
-#include <asm/hardware.h>
-#include <dataflash.h>
-
-AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS];
-
-struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = {
-       {CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0},       /* Logical adress, CS */
-};
-
-/*define the area offsets*/
-#ifdef CONFIG_SYS_USE_DATAFLASH
-dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
-       {0x00000000, 0x000041FF, FLAG_PROTECT_SET,   0, "Bootstrap"},
-       {0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"},
-       {0x00008400, 0x00041FFF, FLAG_PROTECT_SET,   0, "U-Boot"},
-       {0x00042000, 0x00251FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"},
-       {0x00252000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"},
-};
-#else
-dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
-       {0x00000000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR,   0, ""},
-};
-
-#endif
index d4416e64683c939dc1eebbd98c8a051eb1b5e208..7240c9762e22e3b9d544ccffb4a5c3901bfe6e4b 100644 (file)
@@ -250,9 +250,6 @@ int board_init(void)
 #ifdef CONFIG_ATMEL_SPI
        at91_spi0_hw_init(1 << 4);
 #endif
-#ifdef CONFIG_HAS_DATAFLASH
-       at91_spi0_hw_init(1 << 0);
-#endif
 #ifdef CONFIG_MACB
        corvus_macb_hw_init();
 #endif
index b150940bf3a99396fdfdf691465a1d2b6cc27a98..a2803e8ee47d9bbdeee75a6b623f9b6d5a8cb00a 100644 (file)
 #include <common.h>
 #include <command.h>
 
-#ifdef CONFIG_HAS_DATAFLASH
-#include <dataflash.h>
-#endif
-
 #if defined(CONFIG_CMD_MTDPARTS)
 #include <jffs2/jffs2.h>
 
@@ -279,10 +275,6 @@ static int do_flinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
        ulong bank;
 #endif
 
-#ifdef CONFIG_HAS_DATAFLASH
-       dataflash_print_info();
-#endif
-
 #ifdef CONFIG_MTD_NOR_FLASH
        if (argc == 1) {        /* print info for all FLASH banks */
                for (bank=0; bank <CONFIG_SYS_MAX_FLASH_BANKS; ++bank) {
@@ -451,10 +443,7 @@ static int do_protect(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
        u8 dev_type, dev_num, pnum;
 #endif
 #endif /* CONFIG_MTD_NOR_FLASH */
-#ifdef CONFIG_HAS_DATAFLASH
-       int status;
-#endif
-#if defined(CONFIG_MTD_NOR_FLASH) || defined(CONFIG_HAS_DATAFLASH)
+#if defined(CONFIG_MTD_NOR_FLASH)
        int p;
        ulong addr_first, addr_last;
 #endif
@@ -462,7 +451,7 @@ static int do_protect(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
        if (argc < 3)
                return CMD_RET_USAGE;
 
-#if defined(CONFIG_MTD_NOR_FLASH) || defined(CONFIG_HAS_DATAFLASH)
+#if defined(CONFIG_MTD_NOR_FLASH)
        if (strcmp(argv[1], "off") == 0)
                p = 0;
        else if (strcmp(argv[1], "on") == 0)
@@ -471,24 +460,6 @@ static int do_protect(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                return CMD_RET_USAGE;
 #endif
 
-#ifdef CONFIG_HAS_DATAFLASH
-       if ((strcmp(argv[2], "all") != 0) && (strcmp(argv[2], "bank") != 0)) {
-               addr_first = simple_strtoul(argv[2], NULL, 16);
-               addr_last  = simple_strtoul(argv[3], NULL, 16);
-
-               if (addr_dataflash(addr_first) && addr_dataflash(addr_last)) {
-                       status = dataflash_real_protect(p,addr_first,addr_last);
-                       if (status < 0){
-                               puts ("Bad DataFlash sector specification\n");
-                               return 1;
-                       }
-                       printf("%sProtect %d DataFlash Sectors\n",
-                               p ? "" : "Un-", status);
-                       return 0;
-               }
-       }
-#endif
-
 #ifdef CONFIG_MTD_NOR_FLASH
        if (strcmp(argv[2], "all") == 0) {
                for (bank=1; bank<=CONFIG_SYS_MAX_FLASH_BANKS; ++bank) {
index 27075e54a91255b1661fc478da6a707513942392..6775ab77336c401b2605a4f5c1abce3747342318 100644 (file)
--- a/cmd/mem.c
+++ b/cmd/mem.c
@@ -17,9 +17,6 @@
 #include <cli.h>
 #include <command.h>
 #include <console.h>
-#ifdef CONFIG_HAS_DATAFLASH
-#include <dataflash.h>
-#endif
 #include <hash.h>
 #include <inttypes.h>
 #include <mapmem.h>
@@ -52,10 +49,8 @@ static       ulong   base_address = 0;
 #define DISP_LINE_LEN  16
 static int do_mem_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
-       ulong   addr, length;
-#if defined(CONFIG_HAS_DATAFLASH)
-       ulong   nbytes, linebytes;
-#endif
+       ulong   addr, length, bytes;
+       const void *buf;
        int     size;
        int rc = 0;
 
@@ -88,40 +83,13 @@ static int do_mem_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                        length = simple_strtoul(argv[2], NULL, 16);
        }
 
-#if defined(CONFIG_HAS_DATAFLASH)
-       /* Print the lines.
-        *
-        * We buffer all read data, so we can make sure data is read only
-        * once, and all accesses are with the specified bus width.
-        */
-       nbytes = length * size;
-       do {
-               char    linebuf[DISP_LINE_LEN];
-               void* p;
-               linebytes = (nbytes>DISP_LINE_LEN)?DISP_LINE_LEN:nbytes;
-
-               rc = read_dataflash(addr, (linebytes/size)*size, linebuf);
-               p = (rc == DATAFLASH_OK) ? linebuf : (void*)addr;
-               print_buffer(addr, p, size, linebytes/size, DISP_LINE_LEN/size);
-
-               nbytes -= linebytes;
-               addr += linebytes;
-               if (ctrlc()) {
-                       rc = 1;
-                       break;
-               }
-       } while (nbytes > 0);
-#else
-       {
-               ulong bytes = size * length;
-               const void *buf = map_sysmem(addr, bytes);
+       bytes = size * length;
+       buf = map_sysmem(addr, bytes);
 
-               /* Print the lines. */
-               print_buffer(addr, buf, size, length, DISP_LINE_LEN / size);
-               addr += bytes;
-               unmap_sysmem(buf);
-       }
-#endif
+       /* Print the lines. */
+       print_buffer(addr, buf, size, length, DISP_LINE_LEN / size);
+       addr += bytes;
+       unmap_sysmem(buf);
 
        dp_last_addr = addr;
        dp_last_length = length;
@@ -286,13 +254,6 @@ static int do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 
        count = simple_strtoul(argv[3], NULL, 16);
 
-#ifdef CONFIG_HAS_DATAFLASH
-       if (addr_dataflash(addr1) | addr_dataflash(addr2)){
-               puts ("Comparison with DataFlash space not supported.\n\r");
-               return 0;
-       }
-#endif
-
        bytes = size * count;
        base = buf1 = map_sysmem(addr1, bytes);
        buf2 = map_sysmem(addr2, bytes);
@@ -370,11 +331,7 @@ static int do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 
 #ifdef CONFIG_MTD_NOR_FLASH
        /* check if we are copying to Flash */
-       if ( (addr2info(dest) != NULL)
-#ifdef CONFIG_HAS_DATAFLASH
-          && (!addr_dataflash(dest))
-#endif
-          ) {
+       if (addr2info(dest) != NULL) {
                int rc;
 
                puts ("Copy to Flash... ");
@@ -389,44 +346,6 @@ static int do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
        }
 #endif
 
-#ifdef CONFIG_HAS_DATAFLASH
-       /* Check if we are copying from RAM or Flash to DataFlash */
-       if (addr_dataflash(dest) && !addr_dataflash(addr)){
-               int rc;
-
-               puts ("Copy to DataFlash... ");
-
-               rc = write_dataflash (dest, addr, count*size);
-
-               if (rc != 1) {
-                       dataflash_perror (rc);
-                       return (1);
-               }
-               puts ("done\n");
-               return 0;
-       }
-
-       /* Check if we are copying from DataFlash to RAM */
-       if (addr_dataflash(addr) && !addr_dataflash(dest)
-#ifdef CONFIG_MTD_NOR_FLASH
-                                && (addr2info(dest) == NULL)
-#endif
-          ){
-               int rc;
-               rc = read_dataflash(addr, count * size, (char *) dest);
-               if (rc != 1) {
-                       dataflash_perror (rc);
-                       return (1);
-               }
-               return 0;
-       }
-
-       if (addr_dataflash(addr) && addr_dataflash(dest)){
-               puts ("Unsupported combination of source/destination.\n\r");
-               return 1;
-       }
-#endif
-
        memcpy((void *)dest, (void *)addr, count * size);
 
        return 0;
@@ -1072,13 +991,6 @@ mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[])
                addr += base_address;
        }
 
-#ifdef CONFIG_HAS_DATAFLASH
-       if (addr_dataflash(addr)){
-               puts ("Can't modify DataFlash in place. Use cp instead.\n\r");
-               return 0;
-       }
-#endif
-
        /* Print the address, followed by value.  Then accept input for
         * the next value.  A non-converted value exits.
         */
index 94697e7bc104185b586e24c91bfecdd2b0d883a9..a3b9bfb8ee4a4fe12d58818eb49c4a457f463920 100644 (file)
@@ -18,9 +18,6 @@
 #endif
 #include <command.h>
 #include <console.h>
-#ifdef CONFIG_HAS_DATAFLASH
-#include <dataflash.h>
-#endif
 #include <dm.h>
 #include <environment.h>
 #include <fdtdec.h>
@@ -447,15 +444,6 @@ static int initr_mmc(void)
 }
 #endif
 
-#ifdef CONFIG_HAS_DATAFLASH
-static int initr_dataflash(void)
-{
-       AT91F_DataflashInit();
-       dataflash_print_info();
-       return 0;
-}
-#endif
-
 /*
  * Tell if it's OK to load the environment early in boot.
  *
@@ -802,9 +790,6 @@ static init_fnc_t init_sequence_r[] = {
 #endif
 #ifdef CONFIG_MMC
        initr_mmc,
-#endif
-#ifdef CONFIG_HAS_DATAFLASH
-       initr_dataflash,
 #endif
        initr_env,
 #ifdef CONFIG_SYS_BOOTPARAMS_LEN
index 332b5f2843872918d2e76072c01aa05b873c2a69..01f48bf772f3ccb959dcfae4d09f29c24075e760 100644 (file)
 #include <status_led.h>
 #endif
 
-#ifdef CONFIG_HAS_DATAFLASH
-#include <dataflash.h>
-#endif
-
 #ifdef CONFIG_LOGBUFFER
 #include <logbuff.h>
 #endif
@@ -903,64 +899,6 @@ ulong genimg_get_image(ulong img_addr)
 {
        ulong ram_addr = img_addr;
 
-#ifdef CONFIG_HAS_DATAFLASH
-       ulong h_size, d_size;
-
-       if (addr_dataflash(img_addr)) {
-               void *buf;
-
-               /* ger RAM address */
-               ram_addr = CONFIG_SYS_LOAD_ADDR;
-
-               /* get header size */
-               h_size = image_get_header_size();
-#if IMAGE_ENABLE_FIT
-               if (sizeof(struct fdt_header) > h_size)
-                       h_size = sizeof(struct fdt_header);
-#endif
-
-               /* read in header */
-               debug("   Reading image header from dataflash address "
-                       "%08lx to RAM address %08lx\n", img_addr, ram_addr);
-
-               buf = map_sysmem(ram_addr, 0);
-               read_dataflash(img_addr, h_size, buf);
-
-               /* get data size */
-               switch (genimg_get_format(buf)) {
-#if defined(CONFIG_IMAGE_FORMAT_LEGACY)
-               case IMAGE_FORMAT_LEGACY:
-                       d_size = image_get_data_size(buf);
-                       debug("   Legacy format image found at 0x%08lx, "
-                                       "size 0x%08lx\n",
-                                       ram_addr, d_size);
-                       break;
-#endif
-#if IMAGE_ENABLE_FIT
-               case IMAGE_FORMAT_FIT:
-                       d_size = fit_get_size(buf) - h_size;
-                       debug("   FIT/FDT format image found at 0x%08lx, "
-                                       "size 0x%08lx\n",
-                                       ram_addr, d_size);
-                       break;
-#endif
-               default:
-                       printf("   No valid image found at 0x%08lx\n",
-                               img_addr);
-                       return ram_addr;
-               }
-
-               /* read in image data */
-               debug("   Reading image remaining data from dataflash address "
-                       "%08lx to RAM address %08lx\n", img_addr + h_size,
-                       ram_addr + h_size);
-
-               read_dataflash(img_addr + h_size, d_size,
-                               (char *)(buf + h_size));
-
-       }
-#endif /* CONFIG_HAS_DATAFLASH */
-
        return ram_addr;
 }
 
index bd680a784f53d2348d89a1ef582c8554c4dc6de1..20c0d0af44a2c4db74064ca2a2dc1063c179d64c 100644 (file)
@@ -12,10 +12,8 @@ obj-$(CONFIG_MTD) += mtd-uclass.o
 obj-$(CONFIG_MTD_PARTITIONS) += mtdpart.o
 obj-$(CONFIG_MTD_CONCAT) += mtdconcat.o
 obj-$(CONFIG_ALTERA_QSPI) += altera_qspi.o
-obj-$(CONFIG_HAS_DATAFLASH) += at45.o
 obj-$(CONFIG_FLASH_CFI_DRIVER) += cfi_flash.o
 obj-$(CONFIG_FLASH_CFI_MTD) += cfi_mtd.o
-obj-$(CONFIG_HAS_DATAFLASH) += dataflash.o
 obj-$(CONFIG_FTSMC020) += ftsmc020.o
 obj-$(CONFIG_FLASH_CFI_LEGACY) += jedec_flash.o
 obj-$(CONFIG_MW_EEPROM) += mw_eeprom.o
diff --git a/drivers/mtd/at45.c b/drivers/mtd/at45.c
deleted file mode 100644 (file)
index 2f49be3..0000000
+++ /dev/null
@@ -1,545 +0,0 @@
-/* Driver for ATMEL DataFlash support
- * Author : Hamid Ikdoumi (Atmel)
- *
- * SPDX-License-Identifier:    GPL-2.0+
- */
-
-#include <config.h>
-#include <common.h>
-#include <dataflash.h>
-
-/*
- * spi.c API
- */
-extern unsigned int AT91F_SpiWrite(AT91PS_DataflashDesc pDesc);
-extern void AT91F_SpiEnable(int cs);
-
-#define AT91C_TIMEOUT_WRDY                     200000
-
-/*----------------------------------------------------------------------*/
-/* \fn    AT91F_DataFlashSendCommand                                   */
-/* \brief Generic function to send a command to the dataflash          */
-/*----------------------------------------------------------------------*/
-AT91S_DataFlashStatus AT91F_DataFlashSendCommand(AT91PS_DataFlash pDataFlash,
-                                                unsigned char OpCode,
-                                                unsigned int CmdSize,
-                                                unsigned int DataflashAddress)
-{
-       unsigned int adr;
-
-       if ((pDataFlash->pDataFlashDesc->state) != IDLE)
-               return DATAFLASH_BUSY;
-
-       /* process the address to obtain page address and byte address */
-       adr = ((DataflashAddress / (pDataFlash->pDevice->pages_size)) <<
-               pDataFlash->pDevice->page_offset) +
-                       (DataflashAddress % (pDataFlash->pDevice->pages_size));
-
-       /* fill the command buffer */
-       pDataFlash->pDataFlashDesc->command[0] = OpCode;
-       if (pDataFlash->pDevice->pages_number >= 16384) {
-               pDataFlash->pDataFlashDesc->command[1] =
-                       (unsigned char)((adr & 0x0F000000) >> 24);
-               pDataFlash->pDataFlashDesc->command[2] =
-                       (unsigned char)((adr & 0x00FF0000) >> 16);
-               pDataFlash->pDataFlashDesc->command[3] =
-                       (unsigned char)((adr & 0x0000FF00) >> 8);
-               pDataFlash->pDataFlashDesc->command[4] =
-                       (unsigned char)(adr & 0x000000FF);
-       } else {
-               pDataFlash->pDataFlashDesc->command[1] =
-                       (unsigned char)((adr & 0x00FF0000) >> 16);
-               pDataFlash->pDataFlashDesc->command[2] =
-                       (unsigned char)((adr & 0x0000FF00) >> 8);
-               pDataFlash->pDataFlashDesc->command[3] =
-                       (unsigned char)(adr & 0x000000FF);
-               pDataFlash->pDataFlashDesc->command[4] = 0;
-       }
-       pDataFlash->pDataFlashDesc->command[5] = 0;
-       pDataFlash->pDataFlashDesc->command[6] = 0;
-       pDataFlash->pDataFlashDesc->command[7] = 0;
-
-       /* Initialize the SpiData structure for the spi write fuction */
-       pDataFlash->pDataFlashDesc->tx_cmd_pt =
-               pDataFlash->pDataFlashDesc->command;
-       pDataFlash->pDataFlashDesc->tx_cmd_size = CmdSize;
-       pDataFlash->pDataFlashDesc->rx_cmd_pt =
-               pDataFlash->pDataFlashDesc->command;
-       pDataFlash->pDataFlashDesc->rx_cmd_size = CmdSize;
-
-       /* send the command and read the data */
-       return AT91F_SpiWrite(pDataFlash->pDataFlashDesc);
-}
-
-/*----------------------------------------------------------------------*/
-/* \fn    AT91F_DataFlashGetStatus                                     */
-/* \brief Read the status register of the dataflash                    */
-/*----------------------------------------------------------------------*/
-AT91S_DataFlashStatus AT91F_DataFlashGetStatus(AT91PS_DataflashDesc pDesc)
-{
-       AT91S_DataFlashStatus status;
-
-       /* if a transfert is in progress ==> return 0 */
-       if ((pDesc->state) != IDLE)
-               return DATAFLASH_BUSY;
-
-       /* first send the read status command (D7H) */
-       pDesc->command[0] = DB_STATUS;
-       pDesc->command[1] = 0;
-
-       pDesc->DataFlash_state = GET_STATUS;
-       pDesc->tx_data_size = 0;        /* Transmit the command */
-       /* and receive response */
-       pDesc->tx_cmd_pt = pDesc->command;
-       pDesc->rx_cmd_pt = pDesc->command;
-       pDesc->rx_cmd_size = 2;
-       pDesc->tx_cmd_size = 2;
-       status = AT91F_SpiWrite(pDesc);
-
-       pDesc->DataFlash_state = *((unsigned char *)(pDesc->rx_cmd_pt) + 1);
-
-       return status;
-}
-
-/*----------------------------------------------------------------------*/
-/* \fn    AT91F_DataFlashWaitReady                                     */
-/* \brief wait for dataflash ready (bit7 of the status register == 1)  */
-/*----------------------------------------------------------------------*/
-AT91S_DataFlashStatus AT91F_DataFlashWaitReady(AT91PS_DataflashDesc
-                                               pDataFlashDesc,
-                                               unsigned int timeout)
-{
-       pDataFlashDesc->DataFlash_state = IDLE;
-
-       do {
-               AT91F_DataFlashGetStatus(pDataFlashDesc);
-               timeout--;
-       } while (((pDataFlashDesc->DataFlash_state & 0x80) != 0x80) &&
-                (timeout > 0));
-
-       if ((pDataFlashDesc->DataFlash_state & 0x80) != 0x80)
-               return DATAFLASH_ERROR;
-
-       return DATAFLASH_OK;
-}
-
-/*--------------------------------------------------------------------------*/
-/* Function Name       : AT91F_DataFlashContinuousRead                     */
-/* Object              : Continuous stream Read                            */
-/* Input Parameters    : DataFlash Service                                 */
-/*                                             : <src> = dataflash address */
-/*                     : <*dataBuffer> = data buffer pointer               */
-/*                     : <sizeToRead> = data buffer size                   */
-/* Return value                : State of the dataflash                            */
-/*--------------------------------------------------------------------------*/
-AT91S_DataFlashStatus AT91F_DataFlashContinuousRead(
-                               AT91PS_DataFlash pDataFlash,
-                               int src,
-                               unsigned char *dataBuffer,
-                               int sizeToRead)
-{
-       AT91S_DataFlashStatus status;
-       /* Test the size to read in the device */
-       if ((src + sizeToRead) >
-                       (pDataFlash->pDevice->pages_size *
-                               (pDataFlash->pDevice->pages_number)))
-               return DATAFLASH_MEMORY_OVERFLOW;
-
-       pDataFlash->pDataFlashDesc->rx_data_pt = dataBuffer;
-       pDataFlash->pDataFlashDesc->rx_data_size = sizeToRead;
-       pDataFlash->pDataFlashDesc->tx_data_pt = dataBuffer;
-       pDataFlash->pDataFlashDesc->tx_data_size = sizeToRead;
-
-       status = AT91F_DataFlashSendCommand(
-                       pDataFlash, DB_CONTINUOUS_ARRAY_READ, 8, src);
-       /* Send the command to the dataflash */
-       return (status);
-}
-
-/*---------------------------------------------------------------------------*/
-/* Function Name       : AT91F_DataFlashPagePgmBuf                          */
-/* Object              : Main memory page program thru buffer 1 or buffer 2  */
-/* Input Parameters    : DataFlash Service                                  */
-/*                                             : <*src> = Source buffer     */
-/*                     : <dest> = dataflash destination address                     */
-/*                     : <SizeToWrite> = data buffer size                   */
-/* Return value                : State of the dataflash                             */
-/*---------------------------------------------------------------------------*/
-AT91S_DataFlashStatus AT91F_DataFlashPagePgmBuf(AT91PS_DataFlash pDataFlash,
-                                               unsigned char *src,
-                                               unsigned int dest,
-                                               unsigned int SizeToWrite)
-{
-       int cmdsize;
-       pDataFlash->pDataFlashDesc->tx_data_pt = src;
-       pDataFlash->pDataFlashDesc->tx_data_size = SizeToWrite;
-       pDataFlash->pDataFlashDesc->rx_data_pt = src;
-       pDataFlash->pDataFlashDesc->rx_data_size = SizeToWrite;
-
-       cmdsize = 4;
-       /* Send the command to the dataflash */
-       if (pDataFlash->pDevice->pages_number >= 16384)
-               cmdsize = 5;
-       return (AT91F_DataFlashSendCommand(
-                       pDataFlash, DB_PAGE_PGM_BUF1, cmdsize, dest));
-}
-
-/*---------------------------------------------------------------------------*/
-/* Function Name       : AT91F_MainMemoryToBufferTransfert                  */
-/* Object              : Read a page in the SRAM Buffer 1 or 2              */
-/* Input Parameters    : DataFlash Service                                  */
-/*                     : Page concerned                                             */
-/*                     :                                                    */
-/* Return value                : State of the dataflash                             */
-/*---------------------------------------------------------------------------*/
-AT91S_DataFlashStatus AT91F_MainMemoryToBufferTransfert(
-                                       AT91PS_DataFlash
-                                       pDataFlash,
-                                       unsigned char
-                                       BufferCommand,
-                                       unsigned int page)
-{
-       int cmdsize;
-       /* Test if the buffer command is legal */
-       if ((BufferCommand != DB_PAGE_2_BUF1_TRF) &&
-                       (BufferCommand != DB_PAGE_2_BUF2_TRF)) {
-               return DATAFLASH_BAD_COMMAND;
-       }
-
-       /* no data to transmit or receive */
-       pDataFlash->pDataFlashDesc->tx_data_size = 0;
-       cmdsize = 4;
-       if (pDataFlash->pDevice->pages_number >= 16384)
-               cmdsize = 5;
-       return (AT91F_DataFlashSendCommand(
-                       pDataFlash, BufferCommand, cmdsize,
-                       page * pDataFlash->pDevice->pages_size));
-}
-
-/*-------------------------------------------------------------------------- */
-/* Function Name       : AT91F_DataFlashWriteBuffer                         */
-/* Object              : Write data to the internal sram buffer 1 or 2      */
-/* Input Parameters    : DataFlash Service                                  */
-/*                     : <BufferCommand> = command to write buffer1 or 2    */
-/*                     : <*dataBuffer> = data buffer to write               */
-/*                     : <bufferAddress> = address in the internal buffer    */
-/*                     : <SizeToWrite> = data buffer size                   */
-/* Return value                : State of the dataflash                             */
-/*---------------------------------------------------------------------------*/
-AT91S_DataFlashStatus AT91F_DataFlashWriteBuffer(
-                                       AT91PS_DataFlash pDataFlash,
-                                       unsigned char BufferCommand,
-                                       unsigned char *dataBuffer,
-                                       unsigned int bufferAddress,
-                                       int SizeToWrite)
-{
-       int cmdsize;
-       /* Test if the buffer command is legal */
-       if ((BufferCommand != DB_BUF1_WRITE) &&
-                       (BufferCommand != DB_BUF2_WRITE)) {
-               return DATAFLASH_BAD_COMMAND;
-       }
-
-       /* buffer address must be lower than page size */
-       if (bufferAddress > pDataFlash->pDevice->pages_size)
-               return DATAFLASH_BAD_ADDRESS;
-
-       if ((pDataFlash->pDataFlashDesc->state) != IDLE)
-               return DATAFLASH_BUSY;
-
-       /* Send first Write Command */
-       pDataFlash->pDataFlashDesc->command[0] = BufferCommand;
-       pDataFlash->pDataFlashDesc->command[1] = 0;
-       if (pDataFlash->pDevice->pages_number >= 16384) {
-               pDataFlash->pDataFlashDesc->command[2] = 0;
-               pDataFlash->pDataFlashDesc->command[3] =
-                       (unsigned char)(((unsigned int)(bufferAddress &
-                                                       pDataFlash->pDevice->
-                                                       byte_mask)) >> 8);
-               pDataFlash->pDataFlashDesc->command[4] =
-                       (unsigned char)((unsigned int)bufferAddress & 0x00FF);
-               cmdsize = 5;
-       } else {
-               pDataFlash->pDataFlashDesc->command[2] =
-                       (unsigned char)(((unsigned int)(bufferAddress &
-                                                       pDataFlash->pDevice->
-                                                       byte_mask)) >> 8);
-               pDataFlash->pDataFlashDesc->command[3] =
-                       (unsigned char)((unsigned int)bufferAddress & 0x00FF);
-               pDataFlash->pDataFlashDesc->command[4] = 0;
-               cmdsize = 4;
-       }
-
-       pDataFlash->pDataFlashDesc->tx_cmd_pt =
-               pDataFlash->pDataFlashDesc->command;
-       pDataFlash->pDataFlashDesc->tx_cmd_size = cmdsize;
-       pDataFlash->pDataFlashDesc->rx_cmd_pt =
-               pDataFlash->pDataFlashDesc->command;
-       pDataFlash->pDataFlashDesc->rx_cmd_size = cmdsize;
-
-       pDataFlash->pDataFlashDesc->rx_data_pt = dataBuffer;
-       pDataFlash->pDataFlashDesc->tx_data_pt = dataBuffer;
-       pDataFlash->pDataFlashDesc->rx_data_size = SizeToWrite;
-       pDataFlash->pDataFlashDesc->tx_data_size = SizeToWrite;
-
-       return AT91F_SpiWrite(pDataFlash->pDataFlashDesc);
-}
-
-/*---------------------------------------------------------------------------*/
-/* Function Name       : AT91F_PageErase                                     */
-/* Object              : Erase a page                                       */
-/* Input Parameters    : DataFlash Service                                  */
-/*                     : Page concerned                                             */
-/*                     :                                                    */
-/* Return value                : State of the dataflash                             */
-/*---------------------------------------------------------------------------*/
-AT91S_DataFlashStatus AT91F_PageErase(
-                                       AT91PS_DataFlash pDataFlash,
-                                       unsigned int page)
-{
-       int cmdsize;
-       /* Test if the buffer command is legal */
-       /* no data to transmit or receive */
-       pDataFlash->pDataFlashDesc->tx_data_size = 0;
-
-       cmdsize = 4;
-       if (pDataFlash->pDevice->pages_number >= 16384)
-               cmdsize = 5;
-       return (AT91F_DataFlashSendCommand(pDataFlash,
-                               DB_PAGE_ERASE, cmdsize,
-                               page * pDataFlash->pDevice->pages_size));
-}
-
-/*---------------------------------------------------------------------------*/
-/* Function Name       : AT91F_BlockErase                                    */
-/* Object              : Erase a Block                                      */
-/* Input Parameters    : DataFlash Service                                  */
-/*                     : Page concerned                                             */
-/*                     :                                                    */
-/* Return value                : State of the dataflash                             */
-/*---------------------------------------------------------------------------*/
-AT91S_DataFlashStatus AT91F_BlockErase(
-                               AT91PS_DataFlash pDataFlash,
-                               unsigned int block)
-{
-       int cmdsize;
-       /* Test if the buffer command is legal */
-       /* no data to transmit or receive */
-       pDataFlash->pDataFlashDesc->tx_data_size = 0;
-       cmdsize = 4;
-       if (pDataFlash->pDevice->pages_number >= 16384)
-               cmdsize = 5;
-       return (AT91F_DataFlashSendCommand(pDataFlash, DB_BLOCK_ERASE, cmdsize,
-                                       block * 8 *
-                                       pDataFlash->pDevice->pages_size));
-}
-
-/*---------------------------------------------------------------------------*/
-/* Function Name       : AT91F_WriteBufferToMain                            */
-/* Object              : Write buffer to the main memory                    */
-/* Input Parameters    : DataFlash Service                                  */
-/*             : <BufferCommand> = command to send to buffer1 or buffer2    */
-/*                     : <dest> = main memory address                       */
-/* Return value                : State of the dataflash                             */
-/*---------------------------------------------------------------------------*/
-AT91S_DataFlashStatus AT91F_WriteBufferToMain(AT91PS_DataFlash pDataFlash,
-                                       unsigned char BufferCommand,
-                                       unsigned int dest)
-{
-       int cmdsize;
-       /* Test if the buffer command is correct */
-       if ((BufferCommand != DB_BUF1_PAGE_PGM) &&
-                       (BufferCommand != DB_BUF1_PAGE_ERASE_PGM) &&
-                       (BufferCommand != DB_BUF2_PAGE_PGM) &&
-                       (BufferCommand != DB_BUF2_PAGE_ERASE_PGM))
-               return DATAFLASH_BAD_COMMAND;
-
-       /* no data to transmit or receive */
-       pDataFlash->pDataFlashDesc->tx_data_size = 0;
-
-       cmdsize = 4;
-       if (pDataFlash->pDevice->pages_number >= 16384)
-               cmdsize = 5;
-       /* Send the command to the dataflash */
-       return (AT91F_DataFlashSendCommand(pDataFlash, BufferCommand,
-                                               cmdsize, dest));
-}
-
-/*---------------------------------------------------------------------------*/
-/* Function Name       : AT91F_PartialPageWrite                                     */
-/* Object              : Erase partielly a page                                     */
-/* Input Parameters    : <page> = page number                               */
-/*                     : <AdrInpage> = adr to begin the fading              */
-/*                     : <length> = Number of bytes to erase                */
-/*---------------------------------------------------------------------------*/
-AT91S_DataFlashStatus AT91F_PartialPageWrite(AT91PS_DataFlash pDataFlash,
-                                       unsigned char *src,
-                                       unsigned int dest,
-                                       unsigned int size)
-{
-       unsigned int page;
-       unsigned int AdrInPage;
-
-       page = dest / (pDataFlash->pDevice->pages_size);
-       AdrInPage = dest % (pDataFlash->pDevice->pages_size);
-
-       /* Read the contents of the page in the Sram Buffer */
-       AT91F_MainMemoryToBufferTransfert(pDataFlash, DB_PAGE_2_BUF1_TRF, page);
-       AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
-                                AT91C_TIMEOUT_WRDY);
-       /*Update the SRAM buffer */
-       AT91F_DataFlashWriteBuffer(pDataFlash, DB_BUF1_WRITE, src,
-                                       AdrInPage, size);
-
-       AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
-                                       AT91C_TIMEOUT_WRDY);
-
-       /* Erase page if a 128 Mbits device */
-       if (pDataFlash->pDevice->pages_number >= 16384) {
-               AT91F_PageErase(pDataFlash, page);
-               /* Rewrite the modified Sram Buffer in the main memory */
-               AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
-                                        AT91C_TIMEOUT_WRDY);
-       }
-
-       /* Rewrite the modified Sram Buffer in the main memory */
-       return (AT91F_WriteBufferToMain(pDataFlash, DB_BUF1_PAGE_ERASE_PGM,
-                                       (page *
-                                        pDataFlash->pDevice->pages_size)));
-}
-
-/*---------------------------------------------------------------------------*/
-/* Function Name       : AT91F_DataFlashWrite                               */
-/* Object              :                                                    */
-/* Input Parameters    : <*src> = Source buffer                                     */
-/*                     : <dest> = dataflash adress                          */
-/*                     : <size> = data buffer size                          */
-/*---------------------------------------------------------------------------*/
-AT91S_DataFlashStatus AT91F_DataFlashWrite(AT91PS_DataFlash pDataFlash,
-                                               unsigned char *src,
-                                               int dest, int size)
-{
-       unsigned int length;
-       unsigned int page;
-       unsigned int status;
-
-       AT91F_SpiEnable(pDataFlash->pDevice->cs);
-
-       if ((dest + size) > (pDataFlash->pDevice->pages_size *
-                       (pDataFlash->pDevice->pages_number)))
-               return DATAFLASH_MEMORY_OVERFLOW;
-
-       /* If destination does not fit a page start address */
-       if ((dest % ((unsigned int)(pDataFlash->pDevice->pages_size))) != 0) {
-               length =
-                       pDataFlash->pDevice->pages_size -
-                       (dest % ((unsigned int)(pDataFlash->pDevice->pages_size)));
-
-               if (size < length)
-                       length = size;
-
-               if (!AT91F_PartialPageWrite(pDataFlash, src, dest, length))
-                       return DATAFLASH_ERROR;
-
-               AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
-                                        AT91C_TIMEOUT_WRDY);
-
-               /* Update size, source and destination pointers */
-               size -= length;
-               dest += length;
-               src += length;
-       }
-
-       while ((size - pDataFlash->pDevice->pages_size) >= 0) {
-               /* program dataflash page */
-               page = (unsigned int)dest / (pDataFlash->pDevice->pages_size);
-
-               status = AT91F_DataFlashWriteBuffer(pDataFlash,
-                                       DB_BUF1_WRITE, src, 0,
-                                       pDataFlash->pDevice->
-                                       pages_size);
-               AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
-                                        AT91C_TIMEOUT_WRDY);
-
-               status = AT91F_PageErase(pDataFlash, page);
-               AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
-                                        AT91C_TIMEOUT_WRDY);
-               if (!status)
-                       return DATAFLASH_ERROR;
-
-               status = AT91F_WriteBufferToMain(pDataFlash,
-                                        DB_BUF1_PAGE_PGM, dest);
-               if (!status)
-                       return DATAFLASH_ERROR;
-
-               AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
-                                        AT91C_TIMEOUT_WRDY);
-
-               /* Update size, source and destination pointers */
-               size -= pDataFlash->pDevice->pages_size;
-               dest += pDataFlash->pDevice->pages_size;
-               src += pDataFlash->pDevice->pages_size;
-       }
-
-       /* If still some bytes to read */
-       if (size > 0) {
-               /* program dataflash page */
-               if (!AT91F_PartialPageWrite(pDataFlash, src, dest, size))
-                       return DATAFLASH_ERROR;
-
-               AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
-                                        AT91C_TIMEOUT_WRDY);
-       }
-       return DATAFLASH_OK;
-}
-
-/*---------------------------------------------------------------------------*/
-/* Function Name       : AT91F_DataFlashRead                                */
-/* Object              : Read a block in dataflash                          */
-/* Input Parameters    :                                                    */
-/* Return value                :                                                    */
-/*---------------------------------------------------------------------------*/
-int AT91F_DataFlashRead(AT91PS_DataFlash pDataFlash,
-                       unsigned long addr, unsigned long size, char *buffer)
-{
-       unsigned long SizeToRead;
-
-       AT91F_SpiEnable(pDataFlash->pDevice->cs);
-
-       if (AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
-                                       AT91C_TIMEOUT_WRDY) != DATAFLASH_OK)
-               return -1;
-
-       while (size) {
-               SizeToRead = (size < 0x8000) ? size : 0x8000;
-
-               if (AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
-                                       AT91C_TIMEOUT_WRDY) !=
-                                               DATAFLASH_OK)
-                       return -1;
-
-               if (AT91F_DataFlashContinuousRead(pDataFlash, addr,
-                                               (uchar *) buffer,
-                                               SizeToRead) != DATAFLASH_OK)
-                       return -1;
-
-               size -= SizeToRead;
-               addr += SizeToRead;
-               buffer += SizeToRead;
-       }
-
-       return DATAFLASH_OK;
-}
-
-/*---------------------------------------------------------------------------*/
-/* Function Name       : AT91F_DataflashProbe                               */
-/* Object              :                                                    */
-/* Input Parameters    :                                                    */
-/* Return value               : Dataflash status register                           */
-/*---------------------------------------------------------------------------*/
-int AT91F_DataflashProbe(int cs, AT91PS_DataflashDesc pDesc)
-{
-       AT91F_SpiEnable(cs);
-       AT91F_DataFlashGetStatus(pDesc);
-       return ((pDesc->command[1] == 0xFF) ? 0 : pDesc->command[1] & 0x3C);
-}
diff --git a/drivers/mtd/dataflash.c b/drivers/mtd/dataflash.c
deleted file mode 100644 (file)
index e961f51..0000000
+++ /dev/null
@@ -1,448 +0,0 @@
-/*
- * LowLevel function for ATMEL DataFlash support
- * Author : Hamid Ikdoumi (Atmel)
- *
- * SPDX-License-Identifier:    GPL-2.0+
- */
-#include <common.h>
-#include <config.h>
-#include <asm/hardware.h>
-#include <dataflash.h>
-
-static AT91S_DataFlash DataFlashInst;
-
-extern void AT91F_SpiInit (void);
-extern int AT91F_DataflashProbe (int i, AT91PS_DataflashDesc pDesc);
-extern int AT91F_DataFlashRead (AT91PS_DataFlash pDataFlash,
-                               unsigned long addr,
-                               unsigned long size, char *buffer);
-extern int AT91F_DataFlashWrite( AT91PS_DataFlash pDataFlash,
-                               unsigned char *src,
-                               int dest,
-                               int size );
-
-int AT91F_DataflashInit (void)
-{
-       int i, j;
-       int dfcode;
-       int part;
-       int found[CONFIG_SYS_MAX_DATAFLASH_BANKS];
-       unsigned char protected;
-
-       AT91F_SpiInit ();
-
-       for (i = 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++) {
-               found[i] = 0;
-               dataflash_info[i].Desc.state = IDLE;
-               dataflash_info[i].id = 0;
-               dataflash_info[i].Device.pages_number = 0;
-               dfcode = AT91F_DataflashProbe (cs[i].cs,
-                               &dataflash_info[i].Desc);
-
-               switch (dfcode) {
-               case AT45DB021:
-                       dataflash_info[i].Device.pages_number = 1024;
-                       dataflash_info[i].Device.pages_size = 264;
-                       dataflash_info[i].Device.page_offset = 9;
-                       dataflash_info[i].Device.byte_mask = 0x300;
-                       dataflash_info[i].Device.cs = cs[i].cs;
-                       dataflash_info[i].Desc.DataFlash_state = IDLE;
-                       dataflash_info[i].logical_address = cs[i].addr;
-                       dataflash_info[i].id = dfcode;
-                       found[i] += dfcode;
-                       break;
-
-               case AT45DB081:
-                       dataflash_info[i].Device.pages_number = 4096;
-                       dataflash_info[i].Device.pages_size = 264;
-                       dataflash_info[i].Device.page_offset = 9;
-                       dataflash_info[i].Device.byte_mask = 0x300;
-                       dataflash_info[i].Device.cs = cs[i].cs;
-                       dataflash_info[i].Desc.DataFlash_state = IDLE;
-                       dataflash_info[i].logical_address = cs[i].addr;
-                       dataflash_info[i].id = dfcode;
-                       found[i] += dfcode;
-                       break;
-
-               case AT45DB161:
-                       dataflash_info[i].Device.pages_number = 4096;
-                       dataflash_info[i].Device.pages_size = 528;
-                       dataflash_info[i].Device.page_offset = 10;
-                       dataflash_info[i].Device.byte_mask = 0x300;
-                       dataflash_info[i].Device.cs = cs[i].cs;
-                       dataflash_info[i].Desc.DataFlash_state = IDLE;
-                       dataflash_info[i].logical_address = cs[i].addr;
-                       dataflash_info[i].id = dfcode;
-                       found[i] += dfcode;
-                       break;
-
-               case AT45DB321:
-                       dataflash_info[i].Device.pages_number = 8192;
-                       dataflash_info[i].Device.pages_size = 528;
-                       dataflash_info[i].Device.page_offset = 10;
-                       dataflash_info[i].Device.byte_mask = 0x300;
-                       dataflash_info[i].Device.cs = cs[i].cs;
-                       dataflash_info[i].Desc.DataFlash_state = IDLE;
-                       dataflash_info[i].logical_address = cs[i].addr;
-                       dataflash_info[i].id = dfcode;
-                       found[i] += dfcode;
-                       break;
-
-               case AT45DB642:
-                       dataflash_info[i].Device.pages_number = 8192;
-                       dataflash_info[i].Device.pages_size = 1056;
-                       dataflash_info[i].Device.page_offset = 11;
-                       dataflash_info[i].Device.byte_mask = 0x700;
-                       dataflash_info[i].Device.cs = cs[i].cs;
-                       dataflash_info[i].Desc.DataFlash_state = IDLE;
-                       dataflash_info[i].logical_address = cs[i].addr;
-                       dataflash_info[i].id = dfcode;
-                       found[i] += dfcode;
-                       break;
-
-               case AT45DB128:
-                       dataflash_info[i].Device.pages_number = 16384;
-                       dataflash_info[i].Device.pages_size = 1056;
-                       dataflash_info[i].Device.page_offset = 11;
-                       dataflash_info[i].Device.byte_mask = 0x700;
-                       dataflash_info[i].Device.cs = cs[i].cs;
-                       dataflash_info[i].Desc.DataFlash_state = IDLE;
-                       dataflash_info[i].logical_address = cs[i].addr;
-                       dataflash_info[i].id = dfcode;
-                       found[i] += dfcode;
-                       break;
-
-               default:
-                       dfcode = 0;
-                       break;
-               }
-               /* set the last area end to the dataflash size*/
-               dataflash_info[i].end_address =
-                               (dataflash_info[i].Device.pages_number *
-                               dataflash_info[i].Device.pages_size) - 1;
-
-               part = 0;
-               /* set the area addresses */
-               for(j = 0; j < NB_DATAFLASH_AREA; j++) {
-                       if(found[i]!=0) {
-                               dataflash_info[i].Device.area_list[j].start =
-                                       area_list[part].start +
-                                       dataflash_info[i].logical_address;
-                               if(area_list[part].end == 0xffffffff) {
-                                       dataflash_info[i].Device.area_list[j].end =
-                                               dataflash_info[i].end_address +
-                                               dataflash_info[i].logical_address;
-                               } else {
-                                       dataflash_info[i].Device.area_list[j].end =
-                                               area_list[part].end +
-                                               dataflash_info[i].logical_address;
-                               }
-                               protected = area_list[part].protected;
-                               /* Set the environment according to the label...*/
-                               if(protected == FLAG_PROTECT_INVALID) {
-                                       dataflash_info[i].Device.area_list[j].protected =
-                                               FLAG_PROTECT_INVALID;
-                               } else {
-                                       dataflash_info[i].Device.area_list[j].protected =
-                                               protected;
-                               }
-                               strcpy((char*)(dataflash_info[i].Device.area_list[j].label),
-                                               (const char *)area_list[part].label);
-                       }
-                       part++;
-               }
-       }
-       return found[0];
-}
-
-void AT91F_Dataflashenv_set(void)
-{
-       int i, j;
-       int part;
-       unsigned char env;
-       unsigned char s[32];    /* Will fit a long int in hex */
-       unsigned long start;
-
-       for (i = 0, part= 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++) {
-               for(j = 0; j < NB_DATAFLASH_AREA; j++) {
-                       env = area_list[part].setenv;
-                       /* Set the environment according to the label...*/
-                       if((env & FLAG_SETENV) == FLAG_SETENV) {
-                               start = dataflash_info[i].Device.area_list[j].start;
-                               sprintf((char *)s, "%lX", start);
-                               env_set((char *)area_list[part].label,
-                                       (char *)s);
-                       }
-                       part++;
-               }
-       }
-}
-
-void dataflash_print_info (void)
-{
-       int i, j;
-
-       for (i = 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++) {
-               if (dataflash_info[i].id != 0) {
-                       printf("DataFlash:");
-                       switch (dataflash_info[i].id) {
-                       case AT45DB021:
-                               printf("AT45DB021\n");
-                               break;
-                       case AT45DB161:
-                               printf("AT45DB161\n");
-                               break;
-
-                       case AT45DB321:
-                               printf("AT45DB321\n");
-                               break;
-
-                       case AT45DB642:
-                               printf("AT45DB642\n");
-                               break;
-                       case AT45DB128:
-                               printf("AT45DB128\n");
-                               break;
-                       }
-
-                       printf("Nb pages: %6d\n"
-                               "Page Size: %6d\n"
-                               "Size=%8d bytes\n"
-                               "Logical address: 0x%08X\n",
-                               (unsigned int) dataflash_info[i].Device.pages_number,
-                               (unsigned int) dataflash_info[i].Device.pages_size,
-                               (unsigned int) dataflash_info[i].Device.pages_number *
-                               dataflash_info[i].Device.pages_size,
-                               (unsigned int) dataflash_info[i].logical_address);
-                       for (j = 0; j < NB_DATAFLASH_AREA; j++) {
-                               switch(dataflash_info[i].Device.area_list[j].protected) {
-                               case    FLAG_PROTECT_SET:
-                               case    FLAG_PROTECT_CLEAR:
-                                       printf("Area %i:\t%08lX to %08lX %s", j,
-                                               dataflash_info[i].Device.area_list[j].start,
-                                               dataflash_info[i].Device.area_list[j].end,
-                                               (dataflash_info[i].Device.area_list[j].protected==FLAG_PROTECT_SET) ? "(RO)" : "    ");
-                                               printf(" %s\n", dataflash_info[i].Device.area_list[j].label);
-                                       break;
-                               case    FLAG_PROTECT_INVALID:
-                                       break;
-                               }
-                       }
-               }
-       }
-}
-
-/*---------------------------------------------------------------------------*/
-/* Function Name       : AT91F_DataflashSelect                              */
-/* Object              : Select the correct device                          */
-/*---------------------------------------------------------------------------*/
-AT91PS_DataFlash AT91F_DataflashSelect (AT91PS_DataFlash pFlash,
-                               unsigned long *addr)
-{
-       char addr_valid = 0;
-       int i;
-
-       for (i = 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++)
-               if ( dataflash_info[i].id
-                       && ((((int) *addr) & 0xFF000000) ==
-                       dataflash_info[i].logical_address)) {
-                       addr_valid = 1;
-                       break;
-               }
-       if (!addr_valid) {
-               pFlash = (AT91PS_DataFlash) 0;
-               return pFlash;
-       }
-       pFlash->pDataFlashDesc = &(dataflash_info[i].Desc);
-       pFlash->pDevice = &(dataflash_info[i].Device);
-       *addr -= dataflash_info[i].logical_address;
-       return (pFlash);
-}
-
-/*---------------------------------------------------------------------------*/
-/* Function Name       : addr_dataflash                                             */
-/* Object              : Test if address is valid                           */
-/*---------------------------------------------------------------------------*/
-int addr_dataflash (unsigned long addr)
-{
-       int addr_valid = 0;
-       int i;
-
-       for (i = 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++) {
-               if ((((int) addr) & 0xFF000000) ==
-                       dataflash_info[i].logical_address) {
-                       addr_valid = 1;
-                       break;
-               }
-       }
-
-       return addr_valid;
-}
-
-/*---------------------------------------------------------------------------*/
-/* Function Name       : size_dataflash                                             */
-/* Object              : Test if address is valid regarding the size        */
-/*---------------------------------------------------------------------------*/
-int size_dataflash (AT91PS_DataFlash pdataFlash, unsigned long addr,
-                       unsigned long size)
-{
-       /* is outside the dataflash */
-       if (((int)addr & 0x0FFFFFFF) > (pdataFlash->pDevice->pages_size *
-               pdataFlash->pDevice->pages_number)) return 0;
-       /* is too large for the dataflash */
-       if (size > ((pdataFlash->pDevice->pages_size *
-               pdataFlash->pDevice->pages_number) -
-               ((int)addr & 0x0FFFFFFF))) return 0;
-
-       return 1;
-}
-
-/*---------------------------------------------------------------------------*/
-/* Function Name       : prot_dataflash                                             */
-/* Object              : Test if destination area is protected              */
-/*---------------------------------------------------------------------------*/
-int prot_dataflash (AT91PS_DataFlash pdataFlash, unsigned long addr)
-{
-       int area;
-
-       /* find area */
-       for (area = 0; area < NB_DATAFLASH_AREA; area++) {
-               if ((addr >= pdataFlash->pDevice->area_list[area].start) &&
-                       (addr < pdataFlash->pDevice->area_list[area].end))
-                       break;
-       }
-       if (area == NB_DATAFLASH_AREA)
-               return -1;
-
-       /*test protection value*/
-       if (pdataFlash->pDevice->area_list[area].protected == FLAG_PROTECT_SET)
-               return 0;
-       if (pdataFlash->pDevice->area_list[area].protected == FLAG_PROTECT_INVALID)
-               return 0;
-
-       return 1;
-}
-
-/*--------------------------------------------------------------------------*/
-/* Function Name       : dataflash_real_protect                                    */
-/* Object              : protect/unprotect area                                    */
-/*--------------------------------------------------------------------------*/
-int dataflash_real_protect (int flag, unsigned long start_addr,
-                               unsigned long end_addr)
-{
-       int i,j, area1, area2, addr_valid = 0;
-
-       /* find dataflash */
-       for (i = 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++) {
-               if ((((int) start_addr) & 0xF0000000) ==
-                       dataflash_info[i].logical_address) {
-                               addr_valid = 1;
-                               break;
-               }
-       }
-       if (!addr_valid) {
-               return -1;
-       }
-       /* find start area */
-       for (area1 = 0; area1 < NB_DATAFLASH_AREA; area1++) {
-               if (start_addr == dataflash_info[i].Device.area_list[area1].start)
-                       break;
-       }
-       if (area1 == NB_DATAFLASH_AREA) return -1;
-       /* find end area */
-       for (area2 = 0; area2 < NB_DATAFLASH_AREA; area2++) {
-               if (end_addr == dataflash_info[i].Device.area_list[area2].end)
-                       break;
-       }
-       if (area2 == NB_DATAFLASH_AREA)
-               return -1;
-
-       /*set protection value*/
-       for(j = area1; j < area2 + 1 ; j++)
-               if(dataflash_info[i].Device.area_list[j].protected
-                               != FLAG_PROTECT_INVALID) {
-                       if (flag == 0) {
-                               dataflash_info[i].Device.area_list[j].protected
-                                       = FLAG_PROTECT_CLEAR;
-                       } else {
-                               dataflash_info[i].Device.area_list[j].protected
-                                       = FLAG_PROTECT_SET;
-                       }
-               }
-
-       return (area2 - area1 + 1);
-}
-
-/*---------------------------------------------------------------------------*/
-/* Function Name       : read_dataflash                                             */
-/* Object              : dataflash memory read                              */
-/*---------------------------------------------------------------------------*/
-int read_dataflash (unsigned long addr, unsigned long size, char *result)
-{
-       unsigned long AddrToRead = addr;
-       AT91PS_DataFlash pFlash = &DataFlashInst;
-
-       pFlash = AT91F_DataflashSelect (pFlash, &AddrToRead);
-
-       if (pFlash == 0)
-               return ERR_UNKNOWN_FLASH_TYPE;
-
-       if (size_dataflash(pFlash,addr,size) == 0)
-               return ERR_INVAL;
-
-       return (AT91F_DataFlashRead (pFlash, AddrToRead, size, result));
-}
-
-/*---------------------------------------------------------------------------*/
-/* Function Name       : write_dataflash                                    */
-/* Object              : write a block in dataflash                         */
-/*---------------------------------------------------------------------------*/
-int write_dataflash (unsigned long addr_dest, unsigned long addr_src,
-                       unsigned long size)
-{
-       unsigned long AddrToWrite = addr_dest;
-       AT91PS_DataFlash pFlash = &DataFlashInst;
-
-       pFlash = AT91F_DataflashSelect (pFlash, &AddrToWrite);
-
-       if (pFlash == 0)
-               return ERR_UNKNOWN_FLASH_TYPE;
-
-       if (size_dataflash(pFlash,addr_dest,size) == 0)
-               return ERR_INVAL;
-
-       if (prot_dataflash(pFlash,addr_dest) == 0)
-               return ERR_PROTECTED;
-
-       if (AddrToWrite == -1)
-               return -1;
-
-       return AT91F_DataFlashWrite (pFlash, (uchar *)addr_src,
-                                               AddrToWrite, size);
-}
-
-void dataflash_perror (int err)
-{
-       switch (err) {
-       case ERR_OK:
-               break;
-       case ERR_TIMOUT:
-               printf("Timeout writing to DataFlash\n");
-               break;
-       case ERR_PROTECTED:
-               printf("Can't write to protected/invalid DataFlash sectors\n");
-               break;
-       case ERR_INVAL:
-               printf("Outside available DataFlash\n");
-               break;
-       case ERR_UNKNOWN_FLASH_TYPE:
-               printf("Unknown Type of DataFlash\n");
-               break;
-       case ERR_PROG_ERROR:
-               printf("General DataFlash Programming Error\n");
-               break;
-       default:
-               printf("%s[%d] FIXME: rc=%d\n", __FILE__, __LINE__, err);
-               break;
-       }
-}
diff --git a/include/dataflash.h b/include/dataflash.h
deleted file mode 100644 (file)
index c9f2220..0000000
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
- * (C) Copyright 2003
- * Data Flash Atmel Description File
- * Author : Hamid Ikdoumi (Atmel)
- *
- * SPDX-License-Identifier:    GPL-2.0+
- */
-
-/* File Name           : dataflash.h                                   */
-/* Object              : Data Flash Atmel Description File             */
-/* Translator          :                                               */
-/*                                                                     */
-/* 1.0 03/04/01 HI     : Creation                                      */
-/* 1.2 20/10/02 FB     : Adapatation Service and Lib v3                */
-/*----------------------------------------------------------------------*/
-
-#ifndef _DataFlash_h
-#define _DataFlash_h
-
-
-#include "config.h"
-
-/*number of protected area*/
-#define NB_DATAFLASH_AREA              5
-
-#ifndef CONFIG_MTD_NOR_FLASH
-
-/*-----------------------------------------------------------------------
- * return codes from flash_write():
- */
-# define ERR_OK                                0
-# define ERR_TIMOUT                    1
-# define ERR_NOT_ERASED                        2
-# define ERR_PROTECTED                 4
-# define ERR_INVAL                     8
-# define ERR_ALIGN                     16
-# define ERR_UNKNOWN_FLASH_VENDOR      32
-# define ERR_UNKNOWN_FLASH_TYPE                64
-# define ERR_PROG_ERROR                        128
-
-/*-----------------------------------------------------------------------
- * Protection Flags for flash_protect():
- */
-# define FLAG_PROTECT_SET              0x01
-# define FLAG_PROTECT_CLEAR            0x02
-# define FLAG_PROTECT_INVALID          0x03
-
-/*-----------------------------------------------------------------------
- * Set Environment according to label:
- */
-# define       FLAG_SETENV             0x80
-#endif /* CONFIG_MTD_NOR_FLASH */
-
-/*define the area structure*/
-typedef struct {
-       unsigned long start;
-       unsigned long end;
-       unsigned char protected;
-       unsigned char setenv;
-       unsigned char label[20];
-} dataflash_protect_t;
-
-typedef unsigned int AT91S_DataFlashStatus;
-
-/*----------------------------------------------------------------------*/
-/* DataFlash Structures                                                        */
-/*----------------------------------------------------------------------*/
-
-/*---------------------------------------------*/
-/* DataFlash Descriptor Structure Definition   */
-/*---------------------------------------------*/
-typedef struct _AT91S_DataflashDesc {
-       unsigned char *tx_cmd_pt;
-       unsigned int tx_cmd_size;
-       unsigned char *rx_cmd_pt;
-       unsigned int rx_cmd_size;
-       unsigned char *tx_data_pt;
-       unsigned int tx_data_size;
-       unsigned char *rx_data_pt;
-       unsigned int rx_data_size;
-       volatile unsigned char state;
-       volatile unsigned char DataFlash_state;
-       unsigned char command[8];
-} AT91S_DataflashDesc, *AT91PS_DataflashDesc;
-
-/*---------------------------------------------*/
-/* DataFlash device definition structure       */
-/*---------------------------------------------*/
-typedef struct _AT91S_Dataflash {
-       int pages_number;                       /* dataflash page number */
-       int pages_size;                         /* dataflash page size */
-       int page_offset;                        /* page offset in command */
-       int byte_mask;                          /* byte mask in command */
-       int cs;
-       dataflash_protect_t area_list[NB_DATAFLASH_AREA]; /* area protection status */
-} AT91S_DataflashFeatures, *AT91PS_DataflashFeatures;
-
-/*---------------------------------------------*/
-/* DataFlash Structure Definition             */
-/*---------------------------------------------*/
-typedef struct _AT91S_DataFlash {
-       AT91PS_DataflashDesc pDataFlashDesc;    /* dataflash descriptor */
-       AT91PS_DataflashFeatures pDevice;       /* Pointer on a dataflash features array */
-} AT91S_DataFlash, *AT91PS_DataFlash;
-
-
-typedef struct _AT91S_DATAFLASH_INFO {
-
-       AT91S_DataflashDesc Desc;
-       AT91S_DataflashFeatures Device; /* Pointer on a dataflash features array */
-       unsigned long logical_address;
-       unsigned long end_address;
-       unsigned int id;                        /* device id */
-} AT91S_DATAFLASH_INFO, *AT91PS_DATAFLASH_INFO;
-
-struct dataflash_addr {
-       unsigned long addr;
-       int cs;
-};
-/*-------------------------------------------------------------------------------------------------*/
-#define AT45DB161      0x2c
-#define AT45DB021      0x14
-#define AT45DB081      0x24
-#define AT45DB321      0x34
-#define AT45DB642      0x3c
-#define AT45DB128      0x10
-#define        PAGES_PER_BLOCK 8
-
-#define AT91C_DATAFLASH_TIMEOUT                10000   /* For AT91F_DataFlashWaitReady */
-
-/* DataFlash return value */
-#define DATAFLASH_BUSY                 0x00
-#define DATAFLASH_OK                   0x01
-#define DATAFLASH_ERROR                        0x02
-#define DATAFLASH_MEMORY_OVERFLOW      0x03
-#define DATAFLASH_BAD_COMMAND          0x04
-#define DATAFLASH_BAD_ADDRESS          0x05
-
-
-/* Driver State */
-#define IDLE           0x0
-#define BUSY           0x1
-#define ERROR          0x2
-
-/* DataFlash Driver State */
-#define GET_STATUS     0x0F
-
-/*-------------------------------------------------------------------------------------------------*/
-/* Command Definition                                                                             */
-/*-------------------------------------------------------------------------------------------------*/
-
-/* READ COMMANDS */
-#define DB_CONTINUOUS_ARRAY_READ       0xE8    /* Continuous array read */
-#define DB_BURST_ARRAY_READ            0xE8    /* Burst array read */
-#define DB_PAGE_READ                   0xD2    /* Main memory page read */
-#define DB_BUF1_READ                   0xD4    /* Buffer 1 read */
-#define DB_BUF2_READ                   0xD6    /* Buffer 2 read */
-#define DB_STATUS                      0xD7    /* Status Register */
-
-/* PROGRAM and ERASE COMMANDS */
-#define DB_BUF1_WRITE                  0x84    /* Buffer 1 write */
-#define DB_BUF2_WRITE                  0x87    /* Buffer 2 write */
-#define DB_BUF1_PAGE_ERASE_PGM         0x83    /* Buffer 1 to main memory page program with built-In erase */
-#define DB_BUF1_PAGE_ERASE_FASTPGM     0x93    /* Buffer 1 to main memory page program with built-In erase, Fast program */
-#define DB_BUF2_PAGE_ERASE_PGM         0x86    /* Buffer 2 to main memory page program with built-In erase */
-#define DB_BUF2_PAGE_ERASE_FASTPGM     0x96    /* Buffer 1 to main memory page program with built-In erase, Fast program */
-#define DB_BUF1_PAGE_PGM               0x88    /* Buffer 1 to main memory page program without built-In erase */
-#define DB_BUF1_PAGE_FASTPGM           0x98    /* Buffer 1 to main memory page program without built-In erase, Fast program */
-#define DB_BUF2_PAGE_PGM               0x89    /* Buffer 2 to main memory page program without built-In erase */
-#define DB_BUF2_PAGE_FASTPGM           0x99    /* Buffer 1 to main memory page program without built-In erase, Fast program */
-#define DB_PAGE_ERASE                  0x81    /* Page Erase */
-#define DB_BLOCK_ERASE                 0x50    /* Block Erase */
-#define DB_PAGE_PGM_BUF1               0x82    /* Main memory page through buffer 1 */
-#define DB_PAGE_FASTPGM_BUF1           0x92    /* Main memory page through buffer 1, Fast program */
-#define DB_PAGE_PGM_BUF2               0x85    /* Main memory page through buffer 2 */
-#define DB_PAGE_FastPGM_BUF2           0x95    /* Main memory page through buffer 2, Fast program */
-
-/* ADDITIONAL COMMANDS */
-#define DB_PAGE_2_BUF1_TRF             0x53    /* Main memory page to buffer 1 transfert */
-#define DB_PAGE_2_BUF2_TRF             0x55    /* Main memory page to buffer 2 transfert */
-#define DB_PAGE_2_BUF1_CMP             0x60    /* Main memory page to buffer 1 compare */
-#define DB_PAGE_2_BUF2_CMP             0x61    /* Main memory page to buffer 2 compare */
-#define DB_AUTO_PAGE_PGM_BUF1          0x58    /* Auto page rewrite throught buffer 1 */
-#define DB_AUTO_PAGE_PGM_BUF2          0x59    /* Auto page rewrite throught buffer 2 */
-
-/*-------------------------------------------------------------------------------------------------*/
-
-extern int size_dataflash (AT91PS_DataFlash pdataFlash, unsigned long addr, unsigned long size);
-extern int prot_dataflash (AT91PS_DataFlash pdataFlash, unsigned long addr);
-extern int addr2ram(ulong addr);
-extern int dataflash_real_protect (int flag, unsigned long start_addr, unsigned long end_addr);
-extern int addr_dataflash (unsigned long addr);
-extern int read_dataflash (unsigned long addr, unsigned long size, char *result);
-extern int write_dataflash(unsigned long addr_dest, unsigned long addr_src,
-                       unsigned long size);
-extern int AT91F_DataflashInit(void);
-
-extern void dataflash_print_info (void);
-extern void dataflash_perror (int err);
-extern void AT91F_Dataflashenv_set(void);
-
-extern struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS];
-extern dataflash_protect_t area_list[NB_DATAFLASH_AREA];
-extern AT91S_DATAFLASH_INFO dataflash_info[];
-#endif
index 32afd3921e22c575620e33060ba2437d925e10ce..fc0b8ff2a804bbfc44166902cb229d05ced70d3b 100644 (file)
@@ -875,7 +875,6 @@ CONFIG_G_DNL_UMS_VENDOR_NUM
 CONFIG_H264_FREQ
 CONFIG_H8300
 CONFIG_HARD_SPI
-CONFIG_HAS_DATAFLASH
 CONFIG_HAS_ETH0
 CONFIG_HAS_ETH1
 CONFIG_HAS_ETH2
@@ -2609,9 +2608,6 @@ CONFIG_SYS_DA850_PLL1_PLLDIV3
 CONFIG_SYS_DA850_PLL1_PLLM
 CONFIG_SYS_DA850_PLL1_POSTDIV
 CONFIG_SYS_DA850_SYSCFG_SUSPSRC
-CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS1
-CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS2
-CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS3
 CONFIG_SYS_DAVINCI_EMAC_PHY_COUNT
 CONFIG_SYS_DAVINCI_I2C_SLAVE
 CONFIG_SYS_DAVINCI_I2C_SLAVE1
@@ -3721,7 +3717,6 @@ CONFIG_SYS_MATRIX_EBI0CSA_VAL
 CONFIG_SYS_MATRIX_EBICSA_VAL
 CONFIG_SYS_MATRIX_MCFG_REMAP
 CONFIG_SYS_MAXARGS
-CONFIG_SYS_MAX_DATAFLASH_BANKS
 CONFIG_SYS_MAX_DDR_BAT_SIZE
 CONFIG_SYS_MAX_FLASH_BANKS
 CONFIG_SYS_MAX_FLASH_BANKS_DETECT