lightnvm: move block fold outside of get_bb_tbl()

The get block table command returns a list of blocks and planes
with their associated state. Users, such as gennvm and sysblk,
manages all planes as a single virtual block.

It was therefore  natural to fold the bad block list before it is
returned. However, to allow users, which manages on a per-plane
block level, to also use the interface, the get_bb_tbl interface is
changed to not fold by default and instead let the caller fold if
necessary.

Reviewed by: Johannes Thumshirn <jthumshirn@suse.de>
Signed-off-by: Matias Bjørling <m@bjorling.me>
Signed-off-by: Jens Axboe <axboe@fb.com>

3 files changed, 63 insertions, 15 deletions

diff --git a/drivers/lightnvm/core.c b/drivers/lightnvm/core.c
index 652b8c7673ee..4cadbe0cd537 100644
--- a/drivers/lightnvm/core.c
+++ b/drivers/lightnvm/core.c
@@ -420,6 +420,41 @@ int nvm_submit_ppa(struct nvm_dev *dev, struct ppa_addr *ppa, int nr_ppas,
 }
 EXPORT_SYMBOL(nvm_submit_ppa);
 
+/*
+ * folds a bad block list from its plane representation to its virtual
+ * block representation. The fold is done in place and reduced size is
+ * returned.
+ *
+ * If any of the planes status are bad or grown bad block, the virtual block
+ * is marked bad. If not bad, the first plane state acts as the block state.
+ */
+int nvm_bb_tbl_fold(struct nvm_dev *dev, u8 *blks, int nr_blks)
+{
+        int blk, offset, pl, blktype;
+
+        if (nr_blks != dev->blks_per_lun * dev->plane_mode)
+                return -EINVAL;
+
+        for (blk = 0; blk < dev->blks_per_lun; blk++) {
+                offset = blk * dev->plane_mode;
+                blktype = blks[offset];
+
+                /* Bad blocks on any planes take precedence over other types */
+                for (pl = 0; pl < dev->plane_mode; pl++) {
+                        if (blks[offset + pl] &
+                                        (NVM_BLK_T_BAD|NVM_BLK_T_GRWN_BAD)) {
+                                blktype = blks[offset + pl];
+                                break;
+                        }
+                }
+
+                blks[blk] = blktype;
+        }
+
+        return dev->blks_per_lun;
+}
+EXPORT_SYMBOL(nvm_bb_tbl_fold);
+
 static int nvm_init_slc_tbl(struct nvm_dev *dev, struct nvm_id_group *grp)
 {
         int i;
diff --git a/drivers/lightnvm/gennvm.c b/drivers/lightnvm/gennvm.c
index 72e124a3927d..6096077c5dde 100644
--- a/drivers/lightnvm/gennvm.c
+++ b/drivers/lightnvm/gennvm.c
@@ -129,18 +129,21 @@ static int gennvm_luns_init(struct nvm_dev *dev, struct gen_nvm *gn)
         return 0;
 }
 
-static int gennvm_block_bb(struct ppa_addr ppa, int nr_blocks, u8 *blks,
-                                                                void *private)
+static int gennvm_block_bb(struct nvm_dev *dev, struct ppa_addr ppa,
+                                        u8 *blks, int nr_blks, void *private)
 {
         struct gen_nvm *gn = private;
-        struct nvm_dev *dev = gn->dev;
         struct gen_lun *lun;
         struct nvm_block *blk;
         int i;
 
+        nr_blks = nvm_bb_tbl_fold(dev, blks, nr_blks);
+        if (nr_blks < 0)
+                return nr_blks;
+
         lun = &gn->luns[(dev->luns_per_chnl * ppa.g.ch) + ppa.g.lun];
 
-        for (i = 0; i < nr_blocks; i++) {
+        for (i = 0; i < nr_blks; i++) {
                 if (blks[i] == 0)
                         continue;
 
@@ -250,8 +253,7 @@ static int gennvm_blocks_init(struct nvm_dev *dev, struct gen_nvm *gn)
                         ppa = generic_to_dev_addr(dev, ppa);
 
                         ret = dev->ops->get_bb_tbl(dev, ppa,
-                                                dev->blks_per_lun,
-                                                gennvm_block_bb, gn);
+                                                        gennvm_block_bb, gn);
                         if (ret)
                                 pr_err("gennvm: could not read BB table\n");
                 }
diff --git a/drivers/lightnvm/sysblk.c b/drivers/lightnvm/sysblk.c
index b6971f8ae3c0..7fce58833a07 100644
--- a/drivers/lightnvm/sysblk.c
+++ b/drivers/lightnvm/sysblk.c
@@ -93,12 +93,16 @@ void nvm_setup_sysblk_scan(struct nvm_dev *dev, struct sysblk_scan *s,
         s->nr_rows = nvm_setup_sysblks(dev, sysblk_ppas);
 }
 
-static int sysblk_get_host_blks(struct ppa_addr ppa, int nr_blks, u8 *blks,
-                                                                void *private)
+static int sysblk_get_host_blks(struct nvm_dev *dev, struct ppa_addr ppa,
+                                        u8 *blks, int nr_blks, void *private)
 {
         struct sysblk_scan *s = private;
         int i, nr_sysblk = 0;
 
+        nr_blks = nvm_bb_tbl_fold(dev, blks, nr_blks);
+        if (nr_blks < 0)
+                return nr_blks;
+
         for (i = 0; i < nr_blks; i++) {
                 if (blks[i] != NVM_BLK_T_HOST)
                         continue;
@@ -130,7 +134,7 @@ static int nvm_get_all_sysblks(struct nvm_dev *dev, struct sysblk_scan *s,
                 dppa = generic_to_dev_addr(dev, ppas[i]);
                 s->row = i;
 
-                ret = dev->ops->get_bb_tbl(dev, dppa, dev->blks_per_lun, fn, s);
+                ret = dev->ops->get_bb_tbl(dev, dppa, fn, s);
                 if (ret) {
                         pr_err("nvm: failed bb tbl for ppa (%u %u)\n",
                                                         ppas[i].g.ch,
@@ -235,13 +239,17 @@ static int nvm_set_bb_tbl(struct nvm_dev *dev, struct sysblk_scan *s, int type)
         return 0;
 }
 
-static int sysblk_get_free_blks(struct ppa_addr ppa, int nr_blks, u8 *blks,
-                                                                void *private)
+static int sysblk_get_free_blks(struct nvm_dev *dev, struct ppa_addr ppa,
+                                        u8 *blks, int nr_blks, void *private)
 {
         struct sysblk_scan *s = private;
         struct ppa_addr *sppa;
         int i, blkid = 0;
 
+        nr_blks = nvm_bb_tbl_fold(dev, blks, nr_blks);
+        if (nr_blks < 0)
+                return nr_blks;
+
         for (i = 0; i < nr_blks; i++) {
                 if (blks[i] == NVM_BLK_T_HOST)
                         return -EEXIST;
@@ -578,13 +586,16 @@ static unsigned int factory_blk_offset(struct nvm_dev *dev, int ch, int lun)
                                                                 BITS_PER_LONG;
 }
 
-static int nvm_factory_blks(struct ppa_addr ppa, int nr_blks, u8 *blks,
-                                                                void *private)
+static int nvm_factory_blks(struct nvm_dev *dev, struct ppa_addr ppa,
+                                        u8 *blks, int nr_blks, void *private)
 {
         struct factory_blks *f = private;
-        struct nvm_dev *dev = f->dev;
         int i, lunoff;
 
+        nr_blks = nvm_bb_tbl_fold(dev, blks, nr_blks);
+        if (nr_blks < 0)
+                return nr_blks;
+
         lunoff = factory_blk_offset(dev, ppa.g.ch, ppa.g.lun);
 
         /* non-set bits correspond to the block must be erased */
@@ -661,7 +672,7 @@ static int nvm_fact_get_bb_tbl(struct nvm_dev *dev, struct ppa_addr ppa,
 
         dev_ppa = generic_to_dev_addr(dev, ppa);
 
-        ret = dev->ops->get_bb_tbl(dev, dev_ppa, dev->blks_per_lun, fn, priv);
+        ret = dev->ops->get_bb_tbl(dev, dev_ppa, fn, priv);
         if (ret)
                 pr_err("nvm: failed bb tbl for ch%u lun%u\n",
                                                         ppa.g.ch, ppa.g.blk);