mtd: spi-nor: Add generic formula for SR block protection handling

The current mainline locking was restricted and could only be applied
to flashes that have 3 block protection bits and fixed locking ratio.

A new method of normalization was reached at the end of the discussion [1].

    (1) - if bp slot is insufficient.
    (2) - if bp slot is sufficient.

    if (bp_slots_needed > bp_slots)    // (1)
        min_prot_length = sector_size << (bp_slots_needed - bp_slots);
    else                               // (2)
        min_prot_length = sector_size;

This patch changes logic to handle block protection based on min_prot_length.
It is suitable for the overall flashes with exception of some corner cases
(see EON and catalyst) and easy to extend and apply for the case of 2bit or
4bit block protection.

[1] http://lists.infradead.org/pipermail/linux-mtd/2020-February/093934.html

Signed-off-by: Jungseung Lee <js07.lee@samsung.com>
Reviewed-by: Michael Walle <michael@walle.cc>
Tested-by: Michael Walle <michael@walle.cc>
Signed-off-by: Tudor Ambarus <tudor.ambarus@microchip.com>

diff --git a/drivers/mtd/spi-nor/core.c b/drivers/mtd/spi-nor/core.c
index bc57b1b..8146d82 100644 (file)
--- a/drivers/mtd/spi-nor/core.c
+++ b/drivers/mtd/spi-nor/core.c
@@ -1536,29 +1536,51 @@ erase_err:
        return ret;
 }
 
+static u64 spi_nor_get_min_prot_length_sr(struct spi_nor *nor)
+{
+       unsigned int bp_slots, bp_slots_needed;
+       u8 mask = SR_BP2 | SR_BP1 | SR_BP0;
+
+       /* Reserved one for "protect none" and one for "protect all". */
+       bp_slots = (mask >> SR_BP_SHIFT) + 1 - 2;
+       bp_slots_needed = ilog2(nor->info->n_sectors);
+
+       if (bp_slots_needed > bp_slots)
+               return nor->info->sector_size <<
+                       (bp_slots_needed - bp_slots);
+       else
+               return nor->info->sector_size;
+}
+
 static void spi_nor_get_locked_range_sr(struct spi_nor *nor, u8 sr, loff_t *ofs,
                                        uint64_t *len)
 {
        struct mtd_info *mtd = &nor->mtd;
+       u64 min_prot_len;
        u8 mask = SR_BP2 | SR_BP1 | SR_BP0;
        u8 tb_mask = SR_TB_BIT5;
-       int pow;
+       u8 bp = (sr & mask) >> SR_BP_SHIFT;
 
        if (nor->flags & SNOR_F_HAS_SR_TB_BIT6)
                tb_mask = SR_TB_BIT6;
 
-       if (!(sr & mask)) {
+       if (!bp) {
                /* No protection */
                *ofs = 0;
                *len = 0;
-       } else {
-               pow = ((sr & mask) ^ mask) >> SR_BP_SHIFT;
-               *len = mtd->size >> pow;
-               if (nor->flags & SNOR_F_HAS_SR_TB && sr & tb_mask)
-                       *ofs = 0;
-               else
-                       *ofs = mtd->size - *len;
+               return;
        }
+
+       min_prot_len = spi_nor_get_min_prot_length_sr(nor);
+       *len = min_prot_len << (bp - 1);
+
+       if (*len > mtd->size)
+               *len = mtd->size;
+
+       if (nor->flags & SNOR_F_HAS_SR_TB && sr & tb_mask)
+               *ofs = 0;
+       else
+               *ofs = mtd->size - *len;
 }
 
 /*
@@ -1631,6 +1653,7 @@ static int spi_nor_is_unlocked_sr(struct spi_nor *nor, loff_t ofs, uint64_t len,
 static int spi_nor_sr_lock(struct spi_nor *nor, loff_t ofs, uint64_t len)
 {
        struct mtd_info *mtd = &nor->mtd;
+       u64 min_prot_len;
        int ret, status_old, status_new;
        u8 mask = SR_BP2 | SR_BP1 | SR_BP0;
        u8 tb_mask = SR_TB_BIT5;
@@ -1673,20 +1696,12 @@ static int spi_nor_sr_lock(struct spi_nor *nor, loff_t ofs, uint64_t len)
        if (nor->flags & SNOR_F_HAS_SR_TB_BIT6)
                tb_mask = SR_TB_BIT6;
 
-       /*
-        * Need smallest pow such that:
-        *
-        *   1 / (2^pow) <= (len / size)
-        *
-        * so (assuming power-of-2 size) we do:
-        *
-        *   pow = ceil(log2(size / len)) = log2(size) - floor(log2(len))
-        */
        if (lock_len == mtd->size) {
                val = mask;
        } else {
-               pow = ilog2(mtd->size) - ilog2(lock_len);
-               val = mask - (pow << SR_BP_SHIFT);
+               min_prot_len = spi_nor_get_min_prot_length_sr(nor);
+               pow = ilog2(lock_len) - ilog2(min_prot_len) + 1;
+               val = pow << SR_BP_SHIFT;
 
                if (val & ~mask)
                        return -EINVAL;
@@ -1723,6 +1738,7 @@ static int spi_nor_sr_lock(struct spi_nor *nor, loff_t ofs, uint64_t len)
 static int spi_nor_sr_unlock(struct spi_nor *nor, loff_t ofs, uint64_t len)
 {
        struct mtd_info *mtd = &nor->mtd;
+       u64 min_prot_len;
        int ret, status_old, status_new;
        u8 mask = SR_BP2 | SR_BP1 | SR_BP0;
        u8 tb_mask = SR_TB_BIT5;
@@ -1764,20 +1780,14 @@ static int spi_nor_sr_unlock(struct spi_nor *nor, loff_t ofs, uint64_t len)
 
        if (nor->flags & SNOR_F_HAS_SR_TB_BIT6)
                tb_mask = SR_TB_BIT6;
-       /*
-        * Need largest pow such that:
-        *
-        *   1 / (2^pow) >= (len / size)
-        *
-        * so (assuming power-of-2 size) we do:
-        *
-        *   pow = floor(log2(size / len)) = log2(size) - ceil(log2(len))
-        */
-       pow = ilog2(mtd->size) - order_base_2(lock_len);
+
        if (lock_len == 0) {
                val = 0; /* fully unlocked */
        } else {
-               val = mask - (pow << SR_BP_SHIFT);
+               min_prot_len = spi_nor_get_min_prot_length_sr(nor);
+               pow = ilog2(lock_len) - ilog2(min_prot_len) + 1;
+               val = pow << SR_BP_SHIFT;
+
                /* Some power-of-two sizes are not supported */
                if (val & ~mask)
                        return -EINVAL;