Commit 46b5889c authored by Miquel Raynal's avatar Miquel Raynal
Browse files

mtd: implement proper partition handling 



Instead of collecting partitions in a flat list, create a hierarchy
within the mtd_info structure: use a partitions list to keep track of
the partitions of an MTD device (which might be itself a partition of
another MTD device), a pointer to the parent device (NULL when the MTD
device is the root one, not a partition).

By also saving directly in mtd_info the offset of the partition, we
can get rid of the mtd_part structure.

While at it, be consistent in the naming of the mtd_info structures to
ease the understanding of the new hierarchy: these structures are
usually called 'mtd', unless there are multiple instances of the same
structure. In this case, there is usually a parent/child bound so we
will call them 'parent' and 'child'.

Signed-off-by: default avatarMiquel Raynal <miquel.raynal@bootlin.com>
Link: https://lore.kernel.org/linux-mtd/20200114090952.11232-1-miquel.raynal@bootlin.com
parent 98d54f81

drivers/mtd/mtdchar.c

+7 −5
Original line number Diff line number Diff line
@@ -349,6 +349,7 @@ static int mtdchar_writeoob(struct file *file, struct mtd_info *mtd, 
	uint64_t start, uint32_t length, void __user *ptr,

	uint32_t __user *retp)

{

	struct mtd_info *master  = mtd_get_master(mtd);

	struct mtd_file_info *mfi = file->private_data;

	struct mtd_oob_ops ops = {};

	uint32_t retlen;
@@ -360,7 +361,7 @@ static int mtdchar_writeoob(struct file *file, struct mtd_info *mtd, 
	if (length > 4096)

		return -EINVAL;



	if (!mtd->_write_oob)

	if (!master->_write_oob)

		return -EOPNOTSUPP;



	ops.ooblen = length;
@@ -586,6 +587,7 @@ static int mtdchar_blkpg_ioctl(struct mtd_info *mtd, 
static int mtdchar_write_ioctl(struct mtd_info *mtd,

		struct mtd_write_req __user *argp)

{

	struct mtd_info *master = mtd_get_master(mtd);

	struct mtd_write_req req;

	struct mtd_oob_ops ops = {};

	const void __user *usr_data, *usr_oob;
@@ -597,9 +599,8 @@ static int mtdchar_write_ioctl(struct mtd_info *mtd, 
	usr_data = (const void __user *)(uintptr_t)req.usr_data;

	usr_oob = (const void __user *)(uintptr_t)req.usr_oob;



	if (!mtd->_write_oob)

	if (!master->_write_oob)

		return -EOPNOTSUPP;



	ops.mode = req.mode;

	ops.len = (size_t)req.len;

	ops.ooblen = (size_t)req.ooblen;
@@ -635,6 +636,7 @@ static int mtdchar_ioctl(struct file *file, u_int cmd, u_long arg) 
{

	struct mtd_file_info *mfi = file->private_data;

	struct mtd_info *mtd = mfi->mtd;

	struct mtd_info *master = mtd_get_master(mtd);

	void __user *argp = (void __user *)arg;

	int ret = 0;

	struct mtd_info_user info;
@@ -824,7 +826,7 @@ static int mtdchar_ioctl(struct file *file, u_int cmd, u_long arg) 
	{

		struct nand_oobinfo oi;



		if (!mtd->ooblayout)

		if (!master->ooblayout)

			return -EOPNOTSUPP;



		ret = get_oobinfo(mtd, &oi);
@@ -918,7 +920,7 @@ static int mtdchar_ioctl(struct file *file, u_int cmd, u_long arg) 
	{

		struct nand_ecclayout_user *usrlay;



		if (!mtd->ooblayout)

		if (!master->ooblayout)

			return -EOPNOTSUPP;



		usrlay = kmalloc(sizeof(*usrlay), GFP_KERNEL);

drivers/mtd/mtdcore.c

+179 −71
Original line number Diff line number Diff line
@@ -456,13 +456,14 @@ static int mtd_reboot_notifier(struct notifier_block *n, unsigned long state, 
int mtd_wunit_to_pairing_info(struct mtd_info *mtd, int wunit,

			      struct mtd_pairing_info *info)

{

	int npairs = mtd_wunit_per_eb(mtd) / mtd_pairing_groups(mtd);

	struct mtd_info *master = mtd_get_master(mtd);

	int npairs = mtd_wunit_per_eb(master) / mtd_pairing_groups(master);



	if (wunit < 0 || wunit >= npairs)

		return -EINVAL;



	if (mtd->pairing && mtd->pairing->get_info)

		return mtd->pairing->get_info(mtd, wunit, info);

	if (master->pairing && master->pairing->get_info)

		return master->pairing->get_info(master, wunit, info);



	info->group = 0;

	info->pair = wunit;
@@ -498,15 +499,16 @@ EXPORT_SYMBOL_GPL(mtd_wunit_to_pairing_info); 
int mtd_pairing_info_to_wunit(struct mtd_info *mtd,

			      const struct mtd_pairing_info *info)

{

	int ngroups = mtd_pairing_groups(mtd);

	int npairs = mtd_wunit_per_eb(mtd) / ngroups;

	struct mtd_info *master = mtd_get_master(mtd);

	int ngroups = mtd_pairing_groups(master);

	int npairs = mtd_wunit_per_eb(master) / ngroups;



	if (!info || info->pair < 0 || info->pair >= npairs ||

	    info->group < 0 || info->group >= ngroups)

		return -EINVAL;



	if (mtd->pairing && mtd->pairing->get_wunit)

		return mtd->pairing->get_wunit(mtd, info);

	if (master->pairing && master->pairing->get_wunit)

		return mtd->pairing->get_wunit(master, info);



	return info->pair;

}
@@ -524,10 +526,12 @@ EXPORT_SYMBOL_GPL(mtd_pairing_info_to_wunit); 
 */

int mtd_pairing_groups(struct mtd_info *mtd)

{

	if (!mtd->pairing || !mtd->pairing->ngroups)

	struct mtd_info *master = mtd_get_master(mtd);



	if (!master->pairing || !master->pairing->ngroups)

		return 1;



	return mtd->pairing->ngroups;

	return master->pairing->ngroups;

}

EXPORT_SYMBOL_GPL(mtd_pairing_groups);
@@ -587,6 +591,7 @@ static int mtd_nvmem_add(struct mtd_info *mtd) 


int add_mtd_device(struct mtd_info *mtd)

{

	struct mtd_info *master = mtd_get_master(mtd);

	struct mtd_notifier *not;

	int i, error;
@@ -608,7 +613,7 @@ int add_mtd_device(struct mtd_info *mtd) 
		    (mtd->_read && mtd->_read_oob)))

		return -EINVAL;



	if (WARN_ON((!mtd->erasesize || !mtd->_erase) &&

	if (WARN_ON((!mtd->erasesize || !master->_erase) &&

		    !(mtd->flags & MTD_NO_ERASE)))

		return -EINVAL;
@@ -765,7 +770,8 @@ static void mtd_set_dev_defaults(struct mtd_info *mtd) 
		pr_debug("mtd device won't show a device symlink in sysfs\n");

	}



	mtd->orig_flags = mtd->flags;

	INIT_LIST_HEAD(&mtd->partitions);

	mutex_init(&mtd->master.partitions_lock);

}



/**
@@ -971,20 +977,26 @@ EXPORT_SYMBOL_GPL(get_mtd_device); 


int __get_mtd_device(struct mtd_info *mtd)

{

	struct mtd_info *master = mtd_get_master(mtd);

	int err;



	if (!try_module_get(mtd->owner))

	if (!try_module_get(master->owner))

		return -ENODEV;



	if (mtd->_get_device) {

		err = mtd->_get_device(mtd);

	if (master->_get_device) {

		err = master->_get_device(mtd);



		if (err) {

			module_put(mtd->owner);

			module_put(master->owner);

			return err;

		}

	}



	while (mtd->parent) {

		mtd->usecount++;

		mtd = mtd->parent;

	}



	return 0;

}

EXPORT_SYMBOL_GPL(__get_mtd_device);
@@ -1038,13 +1050,18 @@ EXPORT_SYMBOL_GPL(put_mtd_device); 


void __put_mtd_device(struct mtd_info *mtd)

{

	struct mtd_info *master = mtd_get_master(mtd);



	while (mtd->parent) {

		--mtd->usecount;

		BUG_ON(mtd->usecount < 0);

		mtd = mtd->parent;

	}



	if (mtd->_put_device)

		mtd->_put_device(mtd);

	if (master->_put_device)

		master->_put_device(master);



	module_put(mtd->owner);

	module_put(master->owner);

}

EXPORT_SYMBOL_GPL(__put_mtd_device);
@@ -1055,9 +1072,13 @@ EXPORT_SYMBOL_GPL(__put_mtd_device); 
 */

int mtd_erase(struct mtd_info *mtd, struct erase_info *instr)

{

	struct mtd_info *master = mtd_get_master(mtd);

	u64 mst_ofs = mtd_get_master_ofs(mtd, 0);

	int ret;



	instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;



	if (!mtd->erasesize || !mtd->_erase)

	if (!mtd->erasesize || !master->_erase)

		return -ENOTSUPP;



	if (instr->addr >= mtd->size || instr->len > mtd->size - instr->addr)
@@ -1069,7 +1090,14 @@ int mtd_erase(struct mtd_info *mtd, struct erase_info *instr) 
		return 0;



	ledtrig_mtd_activity();

	return mtd->_erase(mtd, instr);



	instr->addr += mst_ofs;

	ret = master->_erase(master, instr);

	if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)

		instr->fail_addr -= mst_ofs;



	instr->addr -= mst_ofs;

	return ret;

}

EXPORT_SYMBOL_GPL(mtd_erase);
@@ -1079,30 +1107,36 @@ EXPORT_SYMBOL_GPL(mtd_erase); 
int mtd_point(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen,

	      void **virt, resource_size_t *phys)

{

	struct mtd_info *master = mtd_get_master(mtd);



	*retlen = 0;

	*virt = NULL;

	if (phys)

		*phys = 0;

	if (!mtd->_point)

	if (!master->_point)

		return -EOPNOTSUPP;

	if (from < 0 || from >= mtd->size || len > mtd->size - from)

		return -EINVAL;

	if (!len)

		return 0;

	return mtd->_point(mtd, from, len, retlen, virt, phys);



	from = mtd_get_master_ofs(mtd, from);

	return master->_point(master, from, len, retlen, virt, phys);

}

EXPORT_SYMBOL_GPL(mtd_point);



/* We probably shouldn't allow XIP if the unpoint isn't a NULL */

int mtd_unpoint(struct mtd_info *mtd, loff_t from, size_t len)

{

	if (!mtd->_unpoint)

	struct mtd_info *master = mtd_get_master(mtd);



	if (!master->_unpoint)

		return -EOPNOTSUPP;

	if (from < 0 || from >= mtd->size || len > mtd->size - from)

		return -EINVAL;

	if (!len)

		return 0;

	return mtd->_unpoint(mtd, from, len);

	return master->_unpoint(master, mtd_get_master_ofs(mtd, from), len);

}

EXPORT_SYMBOL_GPL(mtd_unpoint);
@@ -1129,6 +1163,25 @@ unsigned long mtd_get_unmapped_area(struct mtd_info *mtd, unsigned long len, 
}

EXPORT_SYMBOL_GPL(mtd_get_unmapped_area);



static void mtd_update_ecc_stats(struct mtd_info *mtd, struct mtd_info *master,

				 const struct mtd_ecc_stats *old_stats)

{

	struct mtd_ecc_stats diff;



	if (master == mtd)

		return;



	diff = master->ecc_stats;

	diff.failed -= old_stats->failed;

	diff.corrected -= old_stats->corrected;



	while (mtd->parent) {

		mtd->ecc_stats.failed += diff.failed;

		mtd->ecc_stats.corrected += diff.corrected;

		mtd = mtd->parent;

	}

}



int mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen,

	     u_char *buf)

{
@@ -1171,8 +1224,10 @@ EXPORT_SYMBOL_GPL(mtd_write); 
int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,

		    const u_char *buf)

{

	struct mtd_info *master = mtd_get_master(mtd);



	*retlen = 0;

	if (!mtd->_panic_write)

	if (!master->_panic_write)

		return -EOPNOTSUPP;

	if (to < 0 || to >= mtd->size || len > mtd->size - to)

		return -EINVAL;
@@ -1183,7 +1238,8 @@ int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, 
	if (!mtd->oops_panic_write)

		mtd->oops_panic_write = true;



	return mtd->_panic_write(mtd, to, len, retlen, buf);

	return master->_panic_write(master, mtd_get_master_ofs(mtd, to), len,

				    retlen, buf);

}

EXPORT_SYMBOL_GPL(mtd_panic_write);
@@ -1222,7 +1278,10 @@ static int mtd_check_oob_ops(struct mtd_info *mtd, loff_t offs, 


int mtd_read_oob(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops)

{

	struct mtd_info *master = mtd_get_master(mtd);

	struct mtd_ecc_stats old_stats = master->ecc_stats;

	int ret_code;



	ops->retlen = ops->oobretlen = 0;



	ret_code = mtd_check_oob_ops(mtd, from, ops);
@@ -1232,15 +1291,18 @@ int mtd_read_oob(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops) 
	ledtrig_mtd_activity();



	/* Check the validity of a potential fallback on mtd->_read */

	if (!mtd->_read_oob && (!mtd->_read || ops->oobbuf))

	if (!master->_read_oob && (!master->_read || ops->oobbuf))

		return -EOPNOTSUPP;



	if (mtd->_read_oob)

		ret_code = mtd->_read_oob(mtd, from, ops);

	from = mtd_get_master_ofs(mtd, from);

	if (master->_read_oob)

		ret_code = master->_read_oob(master, from, ops);

	else

		ret_code = mtd->_read(mtd, from, ops->len, &ops->retlen,

		ret_code = master->_read(master, from, ops->len, &ops->retlen,

					 ops->datbuf);



	mtd_update_ecc_stats(mtd, master, &old_stats);



	/*

	 * In cases where ops->datbuf != NULL, mtd->_read_oob() has semantics

	 * similar to mtd->_read(), returning a non-negative integer
@@ -1258,6 +1320,7 @@ EXPORT_SYMBOL_GPL(mtd_read_oob); 
int mtd_write_oob(struct mtd_info *mtd, loff_t to,

				struct mtd_oob_ops *ops)

{

	struct mtd_info *master = mtd_get_master(mtd);

	int ret;



	ops->retlen = ops->oobretlen = 0;
@@ -1272,13 +1335,15 @@ int mtd_write_oob(struct mtd_info *mtd, loff_t to, 
	ledtrig_mtd_activity();



	/* Check the validity of a potential fallback on mtd->_write */

	if (!mtd->_write_oob && (!mtd->_write || ops->oobbuf))

	if (!master->_write_oob && (!master->_write || ops->oobbuf))

		return -EOPNOTSUPP;



	if (mtd->_write_oob)

		return mtd->_write_oob(mtd, to, ops);

	to = mtd_get_master_ofs(mtd, to);



	if (master->_write_oob)

		return master->_write_oob(master, to, ops);

	else

		return mtd->_write(mtd, to, ops->len, &ops->retlen,

		return master->_write(master, to, ops->len, &ops->retlen,

				      ops->datbuf);

}

EXPORT_SYMBOL_GPL(mtd_write_oob);
@@ -1302,15 +1367,17 @@ EXPORT_SYMBOL_GPL(mtd_write_oob); 
int mtd_ooblayout_ecc(struct mtd_info *mtd, int section,

		      struct mtd_oob_region *oobecc)

{

	struct mtd_info *master = mtd_get_master(mtd);



	memset(oobecc, 0, sizeof(*oobecc));



	if (!mtd || section < 0)

	if (!master || section < 0)

		return -EINVAL;



	if (!mtd->ooblayout || !mtd->ooblayout->ecc)

	if (!master->ooblayout || !master->ooblayout->ecc)

		return -ENOTSUPP;



	return mtd->ooblayout->ecc(mtd, section, oobecc);

	return master->ooblayout->ecc(master, section, oobecc);

}

EXPORT_SYMBOL_GPL(mtd_ooblayout_ecc);
@@ -1334,15 +1401,17 @@ EXPORT_SYMBOL_GPL(mtd_ooblayout_ecc); 
int mtd_ooblayout_free(struct mtd_info *mtd, int section,

		       struct mtd_oob_region *oobfree)

{

	struct mtd_info *master = mtd_get_master(mtd);



	memset(oobfree, 0, sizeof(*oobfree));



	if (!mtd || section < 0)

	if (!master || section < 0)

		return -EINVAL;



	if (!mtd->ooblayout || !mtd->ooblayout->free)

	if (!master->ooblayout || !master->ooblayout->free)

		return -ENOTSUPP;



	return mtd->ooblayout->free(mtd, section, oobfree);

	return master->ooblayout->free(master, section, oobfree);

}

EXPORT_SYMBOL_GPL(mtd_ooblayout_free);
@@ -1651,60 +1720,69 @@ EXPORT_SYMBOL_GPL(mtd_ooblayout_count_eccbytes); 
int mtd_get_fact_prot_info(struct mtd_info *mtd, size_t len, size_t *retlen,

			   struct otp_info *buf)

{

	if (!mtd->_get_fact_prot_info)

	struct mtd_info *master = mtd_get_master(mtd);



	if (!master->_get_fact_prot_info)

		return -EOPNOTSUPP;

	if (!len)

		return 0;

	return mtd->_get_fact_prot_info(mtd, len, retlen, buf);

	return master->_get_fact_prot_info(master, len, retlen, buf);

}

EXPORT_SYMBOL_GPL(mtd_get_fact_prot_info);



int mtd_read_fact_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,

			   size_t *retlen, u_char *buf)

{

	struct mtd_info *master = mtd_get_master(mtd);



	*retlen = 0;

	if (!mtd->_read_fact_prot_reg)

	if (!master->_read_fact_prot_reg)

		return -EOPNOTSUPP;

	if (!len)

		return 0;

	return mtd->_read_fact_prot_reg(mtd, from, len, retlen, buf);

	return master->_read_fact_prot_reg(master, from, len, retlen, buf);

}

EXPORT_SYMBOL_GPL(mtd_read_fact_prot_reg);



int mtd_get_user_prot_info(struct mtd_info *mtd, size_t len, size_t *retlen,

			   struct otp_info *buf)

{

	if (!mtd->_get_user_prot_info)

	struct mtd_info *master = mtd_get_master(mtd);



	if (!master->_get_user_prot_info)

		return -EOPNOTSUPP;

	if (!len)

		return 0;

	return mtd->_get_user_prot_info(mtd, len, retlen, buf);

	return master->_get_user_prot_info(master, len, retlen, buf);

}

EXPORT_SYMBOL_GPL(mtd_get_user_prot_info);



int mtd_read_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,

			   size_t *retlen, u_char *buf)

{

	struct mtd_info *master = mtd_get_master(mtd);



	*retlen = 0;

	if (!mtd->_read_user_prot_reg)

	if (!master->_read_user_prot_reg)

		return -EOPNOTSUPP;

	if (!len)

		return 0;

	return mtd->_read_user_prot_reg(mtd, from, len, retlen, buf);

	return master->_read_user_prot_reg(master, from, len, retlen, buf);

}

EXPORT_SYMBOL_GPL(mtd_read_user_prot_reg);



int mtd_write_user_prot_reg(struct mtd_info *mtd, loff_t to, size_t len,

			    size_t *retlen, u_char *buf)

{

	struct mtd_info *master = mtd_get_master(mtd);

	int ret;



	*retlen = 0;

	if (!mtd->_write_user_prot_reg)

	if (!master->_write_user_prot_reg)

		return -EOPNOTSUPP;

	if (!len)

		return 0;

	ret = mtd->_write_user_prot_reg(mtd, to, len, retlen, buf);

	ret = master->_write_user_prot_reg(master, to, len, retlen, buf);

	if (ret)

		return ret;
@@ -1718,80 +1796,105 @@ EXPORT_SYMBOL_GPL(mtd_write_user_prot_reg); 


int mtd_lock_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len)

{

	if (!mtd->_lock_user_prot_reg)

	struct mtd_info *master = mtd_get_master(mtd);



	if (!master->_lock_user_prot_reg)

		return -EOPNOTSUPP;

	if (!len)

		return 0;

	return mtd->_lock_user_prot_reg(mtd, from, len);

	return master->_lock_user_prot_reg(master, from, len);

}

EXPORT_SYMBOL_GPL(mtd_lock_user_prot_reg);



/* Chip-supported device locking */

int mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)

{

	if (!mtd->_lock)

	struct mtd_info *master = mtd_get_master(mtd);



	if (!master->_lock)

		return -EOPNOTSUPP;

	if (ofs < 0 || ofs >= mtd->size || len > mtd->size - ofs)

		return -EINVAL;

	if (!len)

		return 0;

	return mtd->_lock(mtd, ofs, len);

	return master->_lock(master, mtd_get_master_ofs(mtd, ofs), len);

}

EXPORT_SYMBOL_GPL(mtd_lock);



int mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)

{

	if (!mtd->_unlock)

	struct mtd_info *master = mtd_get_master(mtd);



	if (!master->_unlock)

		return -EOPNOTSUPP;

	if (ofs < 0 || ofs >= mtd->size || len > mtd->size - ofs)

		return -EINVAL;

	if (!len)

		return 0;

	return mtd->_unlock(mtd, ofs, len);

	return master->_unlock(master, mtd_get_master_ofs(mtd, ofs), len);

}

EXPORT_SYMBOL_GPL(mtd_unlock);



int mtd_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)

{

	if (!mtd->_is_locked)

	struct mtd_info *master = mtd_get_master(mtd);



	if (!master->_is_locked)

		return -EOPNOTSUPP;

	if (ofs < 0 || ofs >= mtd->size || len > mtd->size - ofs)

		return -EINVAL;

	if (!len)

		return 0;

	return mtd->_is_locked(mtd, ofs, len);

	return master->_is_locked(master, mtd_get_master_ofs(mtd, ofs), len);

}

EXPORT_SYMBOL_GPL(mtd_is_locked);



int mtd_block_isreserved(struct mtd_info *mtd, loff_t ofs)

{

	struct mtd_info *master = mtd_get_master(mtd);



	if (ofs < 0 || ofs >= mtd->size)

		return -EINVAL;

	if (!mtd->_block_isreserved)

	if (!master->_block_isreserved)

		return 0;

	return mtd->_block_isreserved(mtd, ofs);

	return master->_block_isreserved(master, mtd_get_master_ofs(mtd, ofs));

}

EXPORT_SYMBOL_GPL(mtd_block_isreserved);



int mtd_block_isbad(struct mtd_info *mtd, loff_t ofs)

{

	struct mtd_info *master = mtd_get_master(mtd);



	if (ofs < 0 || ofs >= mtd->size)

		return -EINVAL;

	if (!mtd->_block_isbad)

	if (!master->_block_isbad)

		return 0;

	return mtd->_block_isbad(mtd, ofs);

	return master->_block_isbad(master, mtd_get_master_ofs(mtd, ofs));

}

EXPORT_SYMBOL_GPL(mtd_block_isbad);



int mtd_block_markbad(struct mtd_info *mtd, loff_t ofs)

{

	if (!mtd->_block_markbad)

	struct mtd_info *master = mtd_get_master(mtd);

	int ret;



	if (!master->_block_markbad)

		return -EOPNOTSUPP;

	if (ofs < 0 || ofs >= mtd->size)

		return -EINVAL;

	if (!(mtd->flags & MTD_WRITEABLE))

		return -EROFS;

	return mtd->_block_markbad(mtd, ofs);



	ret = master->_block_markbad(master, mtd_get_master_ofs(mtd, ofs));

	if (ret)

		return ret;



	while (mtd->parent) {

		mtd->ecc_stats.badblocks++;

		mtd = mtd->parent;

	}



	return 0;

}

EXPORT_SYMBOL_GPL(mtd_block_markbad);
@@ -1841,12 +1944,17 @@ static int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs, 
int mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,

	       unsigned long count, loff_t to, size_t *retlen)

{

	struct mtd_info *master = mtd_get_master(mtd);



	*retlen = 0;

	if (!(mtd->flags & MTD_WRITEABLE))

		return -EROFS;

	if (!mtd->_writev)



	if (!master->_writev)

		return default_mtd_writev(mtd, vecs, count, to, retlen);

	return mtd->_writev(mtd, vecs, count, to, retlen);



	return master->_writev(master, vecs, count,

			       mtd_get_master_ofs(mtd, to), retlen);

}

EXPORT_SYMBOL_GPL(mtd_writev);

drivers/mtd/mtdpart.c

+177 −518

File changed.

Preview size limit exceeded, changes collapsed.

include/linux/mtd/mtd.h

+115 −10
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ 


#include <linux/types.h>

#include <linux/uio.h>

#include <linux/list.h>

#include <linux/notifier.h>

#include <linux/device.h>

#include <linux/of.h>
@@ -194,10 +195,43 @@ struct mtd_debug_info { 
	const char *partid;

};



/**

 * struct mtd_part - MTD partition specific fields

 *

 * @node: list node used to add an MTD partition to the parent partition list

 * @offset: offset of the partition relatively to the parent offset

 * @flags: original flags (before the mtdpart logic decided to tweak them based

 *	   on flash constraints, like eraseblock/pagesize alignment)

 *

 * This struct is embedded in mtd_info and contains partition-specific

 * properties/fields.

 */

struct mtd_part {

	struct list_head node;

	u64 offset;

	u32 flags;

};



/**

 * struct mtd_master - MTD master specific fields

 *

 * @partitions_lock: lock protecting accesses to the partition list. Protects

 *		     not only the master partition list, but also all

 *		     sub-partitions.

 * @suspended: et to 1 when the device is suspended, 0 otherwise

 *

 * This struct is embedded in mtd_info and contains master-specific

 * properties/fields. The master is the root MTD device from the MTD partition

 * point of view.

 */

struct mtd_master {

	struct mutex partitions_lock;

	unsigned int suspended : 1;

};



struct mtd_info {

	u_char type;

	uint32_t flags;

	uint32_t orig_flags; /* Flags as before running mtd checks */

	uint64_t size;	 // Total size of the MTD



	/* "Major" erase size for the device. Naïve users may take this
@@ -339,7 +373,51 @@ struct mtd_info { 
	int usecount;

	struct mtd_debug_info dbg;

	struct nvmem_device *nvmem;



	/*

	 * Parent device from the MTD partition point of view.

	 *

	 * MTD masters do not have any parent, MTD partitions do. The parent

	 * MTD device can itself be a partition.

	 */

	struct mtd_info *parent;



	/* List of partitions attached to this MTD device */

	struct list_head partitions;



	union {

		struct mtd_part part;

		struct mtd_master master;

	};

};



static inline struct mtd_info *mtd_get_master(struct mtd_info *mtd)

{

	while (mtd->parent)

		mtd = mtd->parent;



	return mtd;

}



static inline u64 mtd_get_master_ofs(struct mtd_info *mtd, u64 ofs)

{

	while (mtd->parent) {

		ofs += mtd->part.offset;

		mtd = mtd->parent;

	}



	return ofs;

}



static inline bool mtd_is_partition(const struct mtd_info *mtd)

{

	return mtd->parent;

}



static inline bool mtd_has_partitions(const struct mtd_info *mtd)

{

	return !list_empty(&mtd->partitions);

}



int mtd_ooblayout_ecc(struct mtd_info *mtd, int section,

		      struct mtd_oob_region *oobecc);
@@ -392,13 +470,16 @@ static inline u32 mtd_oobavail(struct mtd_info *mtd, struct mtd_oob_ops *ops) 
static inline int mtd_max_bad_blocks(struct mtd_info *mtd,

				     loff_t ofs, size_t len)

{

	if (!mtd->_max_bad_blocks)

	struct mtd_info *master = mtd_get_master(mtd);



	if (!master->_max_bad_blocks)

		return -ENOTSUPP;



	if (mtd->size < (len + ofs) || ofs < 0)

		return -EINVAL;



	return mtd->_max_bad_blocks(mtd, ofs, len);

	return master->_max_bad_blocks(master, mtd_get_master_ofs(mtd, ofs),

				       len);

}



int mtd_wunit_to_pairing_info(struct mtd_info *mtd, int wunit,
@@ -439,8 +520,10 @@ int mtd_writev(struct mtd_info *mtd, const struct kvec *vecs, 


static inline void mtd_sync(struct mtd_info *mtd)

{

	if (mtd->_sync)

		mtd->_sync(mtd);

	struct mtd_info *master = mtd_get_master(mtd);



	if (master->_sync)

		master->_sync(master);

}



int mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
@@ -452,13 +535,31 @@ int mtd_block_markbad(struct mtd_info *mtd, loff_t ofs); 


static inline int mtd_suspend(struct mtd_info *mtd)

{

	return mtd->_suspend ? mtd->_suspend(mtd) : 0;

	struct mtd_info *master = mtd_get_master(mtd);

	int ret;



	if (master->master.suspended)

		return 0;



	ret = master->_suspend ? master->_suspend(master) : 0;

	if (ret)

		return ret;



	master->master.suspended = 1;

	return 0;

}



static inline void mtd_resume(struct mtd_info *mtd)

{

	if (mtd->_resume)

		mtd->_resume(mtd);

	struct mtd_info *master = mtd_get_master(mtd);



	if (!master->master.suspended)

		return;



	if (master->_resume)

		master->_resume(master);



	master->master.suspended = 0;

}



static inline uint32_t mtd_div_by_eb(uint64_t sz, struct mtd_info *mtd)
@@ -538,7 +639,9 @@ static inline loff_t mtd_wunit_to_offset(struct mtd_info *mtd, loff_t base, 


static inline int mtd_has_oob(const struct mtd_info *mtd)

{

	return mtd->_read_oob && mtd->_write_oob;

	struct mtd_info *master = mtd_get_master((struct mtd_info *)mtd);



	return master->_read_oob && master->_write_oob;

}



static inline int mtd_type_is_nand(const struct mtd_info *mtd)
@@ -548,7 +651,9 @@ static inline int mtd_type_is_nand(const struct mtd_info *mtd) 


static inline int mtd_can_have_bb(const struct mtd_info *mtd)

{

	return !!mtd->_block_isbad;

	struct mtd_info *master = mtd_get_master((struct mtd_info *)mtd);



	return !!master->_block_isbad;

}



	/* Kernel-side ioctl definitions */

include/linux/mtd/partitions.h

+0 −1
Original line number Diff line number Diff line
@@ -105,7 +105,6 @@ extern void deregister_mtd_parser(struct mtd_part_parser *parser); 
	module_driver(__mtd_part_parser, register_mtd_parser, \

		      deregister_mtd_parser)



int mtd_is_partition(const struct mtd_info *mtd);

int mtd_add_partition(struct mtd_info *master, const char *name,

		      long long offset, long long length);

int mtd_del_partition(struct mtd_info *master, int partno);

CRA Git | Maintained and supported by SUSTech CRA and CCSE