linux/kernel.h: sync min, max, min3, max3 macros with Linux

[platform/kernel/u-boot.git] / drivers / mtd / spi / sf_ops.c

diff --git a/drivers/mtd/spi/sf_ops.c b/drivers/mtd/spi/sf_ops.c
index bc4a822..759231f 100644 (file)
--- a/drivers/mtd/spi/sf_ops.c
+++ b/drivers/mtd/spi/sf_ops.c
@@ -9,6 +9,7 @@
  */
 
 #include <common.h>
+#include <errno.h>
 #include <malloc.h>
 #include <spi.h>
 #include <spi_flash.h>
@@ -119,7 +120,7 @@ static int spi_flash_bank(struct spi_flash *flash, u32 offset)
        u8 bank_sel;
        int ret;
 
-       bank_sel = offset / SPI_FLASH_16MB_BOUN;
+       bank_sel = offset / (SPI_FLASH_16MB_BOUN << flash->shift);
 
        ret = spi_flash_cmd_bankaddr_write(flash, bank_sel);
        if (ret) {
@@ -127,7 +128,29 @@ static int spi_flash_bank(struct spi_flash *flash, u32 offset)
                return ret;
        }
 
-       return 0;
+       return bank_sel;
+}
+#endif
+
+#ifdef CONFIG_SF_DUAL_FLASH
+static void spi_flash_dual_flash(struct spi_flash *flash, u32 *addr)
+{
+       switch (flash->dual_flash) {
+       case SF_DUAL_STACKED_FLASH:
+               if (*addr >= (flash->size >> 1)) {
+                       *addr -= flash->size >> 1;
+                       flash->spi->flags |= SPI_XFER_U_PAGE;
+               } else {
+                       flash->spi->flags &= ~SPI_XFER_U_PAGE;
+               }
+               break;
+       case SF_DUAL_PARALLEL_FLASH:
+               *addr >>= flash->shift;
+               break;
+       default:
+               debug("SF: Unsupported dual_flash=%d\n", flash->dual_flash);
+               break;
+       }
 }
 #endif
 
@@ -135,6 +158,7 @@ int spi_flash_cmd_wait_ready(struct spi_flash *flash, unsigned long timeout)
 {
        struct spi_slave *spi = flash->spi;
        unsigned long timebase;
+       unsigned long flags = SPI_XFER_BEGIN;
        int ret;
        u8 status;
        u8 check_status = 0x0;
@@ -146,7 +170,11 @@ int spi_flash_cmd_wait_ready(struct spi_flash *flash, unsigned long timeout)
                check_status = poll_bit;
        }
 
-       ret = spi_xfer(spi, 8, &cmd, NULL, SPI_XFER_BEGIN);
+#ifdef CONFIG_SF_DUAL_FLASH
+       if (spi->flags & SPI_XFER_U_PAGE)
+               flags |= SPI_XFER_U_PAGE;
+#endif
+       ret = spi_xfer(spi, 8, &cmd, NULL, flags);
        if (ret) {
                debug("SF: fail to read %s status register\n",
                      cmd == CMD_READ_STATUS ? "read" : "flag");
@@ -219,7 +247,7 @@ int spi_flash_write_common(struct spi_flash *flash, const u8 *cmd,
 
 int spi_flash_cmd_erase_ops(struct spi_flash *flash, u32 offset, size_t len)
 {
-       u32 erase_size;
+       u32 erase_size, erase_addr;
        u8 cmd[SPI_FLASH_CMD_LEN];
        int ret = -1;
 
@@ -231,15 +259,21 @@ int spi_flash_cmd_erase_ops(struct spi_flash *flash, u32 offset, size_t len)
 
        cmd[0] = flash->erase_cmd;
        while (len) {
+               erase_addr = offset;
+
+#ifdef CONFIG_SF_DUAL_FLASH
+               if (flash->dual_flash > SF_SINGLE_FLASH)
+                       spi_flash_dual_flash(flash, &erase_addr);
+#endif
 #ifdef CONFIG_SPI_FLASH_BAR
-               ret = spi_flash_bank(flash, offset);
+               ret = spi_flash_bank(flash, erase_addr);
                if (ret < 0)
                        return ret;
 #endif
-               spi_flash_addr(offset, cmd);
+               spi_flash_addr(erase_addr, cmd);
 
                debug("SF: erase %2x %2x %2x %2x (%x)\n", cmd[0], cmd[1],
-                     cmd[2], cmd[3], offset);
+                     cmd[2], cmd[3], erase_addr);
 
                ret = spi_flash_write_common(flash, cmd, sizeof(cmd), NULL, 0);
                if (ret < 0) {
@@ -258,6 +292,7 @@ int spi_flash_cmd_write_ops(struct spi_flash *flash, u32 offset,
                size_t len, const void *buf)
 {
        unsigned long byte_addr, page_size;
+       u32 write_addr;
        size_t chunk_len, actual;
        u8 cmd[SPI_FLASH_CMD_LEN];
        int ret = -1;
@@ -266,18 +301,25 @@ int spi_flash_cmd_write_ops(struct spi_flash *flash, u32 offset,
 
        cmd[0] = flash->write_cmd;
        for (actual = 0; actual < len; actual += chunk_len) {
+               write_addr = offset;
+
+#ifdef CONFIG_SF_DUAL_FLASH
+               if (flash->dual_flash > SF_SINGLE_FLASH)
+                       spi_flash_dual_flash(flash, &write_addr);
+#endif
 #ifdef CONFIG_SPI_FLASH_BAR
-               ret = spi_flash_bank(flash, offset);
+               ret = spi_flash_bank(flash, write_addr);
                if (ret < 0)
                        return ret;
 #endif
                byte_addr = offset % page_size;
-               chunk_len = min(len - actual, page_size - byte_addr);
+               chunk_len = min(len - actual, (size_t)(page_size - byte_addr));
 
                if (flash->spi->max_write_size)
-                       chunk_len = min(chunk_len, flash->spi->max_write_size);
+                       chunk_len = min(chunk_len,
+                                       (size_t)flash->spi->max_write_size);
 
-               spi_flash_addr(offset, cmd);
+               spi_flash_addr(write_addr, cmd);
 
                debug("SF: 0x%p => cmd = { 0x%02x 0x%02x%02x%02x } chunk_len = %zu\n",
                      buf + actual, cmd[0], cmd[1], cmd[2], cmd[3], chunk_len);
@@ -321,8 +363,9 @@ int spi_flash_read_common(struct spi_flash *flash, const u8 *cmd,
 int spi_flash_cmd_read_ops(struct spi_flash *flash, u32 offset,
                size_t len, void *data)
 {
-       u8 *cmd, cmdsz, bank_sel = 0;
-       u32 remain_len, read_len;
+       u8 *cmd, cmdsz;
+       u32 remain_len, read_len, read_addr;
+       int bank_sel = 0;
        int ret = -1;
 
        /* Handle memory-mapped SPI */
@@ -340,27 +383,33 @@ int spi_flash_cmd_read_ops(struct spi_flash *flash, u32 offset,
        }
 
        cmdsz = SPI_FLASH_CMD_LEN + flash->dummy_byte;
-       cmd = malloc(cmdsz);
-       memset(cmd, 0, cmdsz);
+       cmd = calloc(1, cmdsz);
+       if (!cmd) {
+               debug("SF: Failed to allocate cmd\n");
+               return -ENOMEM;
+       }
 
        cmd[0] = flash->read_cmd;
        while (len) {
-#ifdef CONFIG_SPI_FLASH_BAR
-               bank_sel = offset / SPI_FLASH_16MB_BOUN;
+               read_addr = offset;
 
-               ret = spi_flash_cmd_bankaddr_write(flash, bank_sel);
-               if (ret) {
-                       debug("SF: fail to set bank%d\n", bank_sel);
+#ifdef CONFIG_SF_DUAL_FLASH
+               if (flash->dual_flash > SF_SINGLE_FLASH)
+                       spi_flash_dual_flash(flash, &read_addr);
+#endif
+#ifdef CONFIG_SPI_FLASH_BAR
+               bank_sel = spi_flash_bank(flash, read_addr);
+               if (bank_sel < 0)
                        return ret;
-               }
 #endif
-               remain_len = (SPI_FLASH_16MB_BOUN * (bank_sel + 1)) - offset;
+               remain_len = ((SPI_FLASH_16MB_BOUN << flash->shift) *
+                               (bank_sel + 1)) - offset;
                if (len < remain_len)
                        read_len = len;
                else
                        read_len = remain_len;
 
-               spi_flash_addr(offset, cmd);
+               spi_flash_addr(read_addr, cmd);
 
                ret = spi_flash_read_common(flash, cmd, cmdsz, data, read_len);
                if (ret < 0) {
@@ -373,6 +422,7 @@ int spi_flash_cmd_read_ops(struct spi_flash *flash, u32 offset,
                data += read_len;
        }
 
+       free(cmd);
        return ret;
 }