text: // SPDX-License-Identifier: GPL-2.0
  /*
   * Copyright (c) 2017 Free Electrons
   *
   * Authors:
   *	Boris Brezillon <boris.brezillon@free-electrons.com>
   *	Peter Pan <peterpandong@micron.com>
   */
  
  #define pr_fmt(fmt)	"nand-bbt: " fmt
  
  #include <linux/mtd/newnand.h>
  #include <linux/slab.h>
  
  /**
   * nanddev_bbt_init() - Initialize the BBT (Bad Block Table)
   * @nand: NAND device
   *
   * Initialize the in-memory BBT.
   *
   * Return: 0 in case of success, a negative error code otherwise.
   */
  int nanddev_bbt_init(struct nand_device *nand)
  {
  	unsigned int bits_per_block = fls(NAND_BBT_BLOCK_NUM_STATUS);
  	unsigned int nblocks = nanddev_neraseblocks(nand);
  	unsigned int nwords = DIV_ROUND_UP(nblocks * bits_per_block,
  					   BITS_PER_LONG);
  
  	nand->bbt.cache = kzalloc(nwords, GFP_KERNEL);
  	if (!nand->bbt.cache)
  		return -ENOMEM;
  
  	return 0;
  }
  EXPORT_SYMBOL_GPL(nanddev_bbt_init);
  
  /**
   * nanddev_bbt_cleanup() - Cleanup the BBT (Bad Block Table)
   * @nand: NAND device
   *
   * Undoes what has been done in nanddev_bbt_init()
   */
  void nanddev_bbt_cleanup(struct nand_device *nand)
  {
  	kfree(nand->bbt.cache);
  }
  EXPORT_SYMBOL_GPL(nanddev_bbt_cleanup);
  
  /**
   * nanddev_bbt_update() - Update a BBT
   * @nand: nand device
   *
   * Update the BBT. Currently a NOP function since on-flash bbt is not yet
   * supported.
   *
   * Return: 0 in case of success, a negative error code otherwise.
   */
  int nanddev_bbt_update(struct nand_device *nand)
  {
  	return 0;
  }
  EXPORT_SYMBOL_GPL(nanddev_bbt_update);
  
  /**
   * nanddev_bbt_get_block_status() - Return the status of an eraseblock
   * @nand: nand device
   * @entry: the BBT entry
   *
   * Return: a positive number nand_bbt_block_status status or -%ERANGE if @entry
   *	   is bigger than the BBT size.
   */
  int nanddev_bbt_get_block_status(const struct nand_device *nand,
  				 unsigned int entry)
  {
  	unsigned int bits_per_block = fls(NAND_BBT_BLOCK_NUM_STATUS);
  	unsigned long *pos = nand->bbt.cache +
  			     ((entry * bits_per_block) / BITS_PER_LONG);
  	unsigned int offs = (entry * bits_per_block) % BITS_PER_LONG;
  	unsigned long status;
  
  	if (entry >= nanddev_neraseblocks(nand))
  		return -ERANGE;
  
  	status = pos[0] >> offs;
  	if (bits_per_block + offs > BITS_PER_LONG)
  		status |= pos[1] << (BITS_PER_LONG - offs);
  
  	return status & GENMASK(bits_per_block - 1, 0);
  }
  EXPORT_SYMBOL_GPL(nanddev_bbt_get_block_status);
  
  /**
   * nanddev_bbt_set_block_status() - Update the status of an eraseblock in the
   *				    in-memory BBT
   * @nand: nand device
   * @entry: the BBT entry to update
   * @status: the new status
   *
   * Update an entry of the in-memory BBT. If you want to push the updated BBT
   * the NAND you should call nanddev_bbt_update().
   *
   * Return: 0 in case of success or -%ERANGE if @entry is bigger than the BBT
   *	   size.
   */
  int nanddev_bbt_set_block_status(struct nand_device *nand, unsigned int entry,
  				 enum nand_bbt_block_status status)
  {
  	unsigned int bits_per_block = fls(NAND_BBT_BLOCK_NUM_STATUS);
  	unsigned long *pos = nand->bbt.cache +
  			     ((entry * bits_per_block) / BITS_PER_LONG);
  	unsigned int offs = (entry * bits_per_block) % BITS_PER_LONG;
  	unsigned long val = status & GENMASK(bits_per_block - 1, 0);
  
  	if (entry >= nanddev_neraseblocks(nand))
  		return -ERANGE;
  
  	pos[0] &= ~GENMASK(offs + bits_per_block - 1, offs);
  	pos[0] |= val << offs;
  
  	if (bits_per_block + offs > BITS_PER_LONG) {
  		unsigned int rbits = bits_per_block + offs - BITS_PER_LONG;
  
  		pos[1] &= ~GENMASK(rbits - 1, 0);
  		pos[1] |= val >> rbits;
  	}
  
  	return 0;
  }
  EXPORT_SYMBOL_GPL(nanddev_bbt_set_block_status);
  