From 74d00a8c3849c1340efd713eb94b786e304c201f Mon Sep 17 00:00:00 2001 From: John Crispin Date: Sun, 25 Dec 2016 20:11:34 +0100 Subject: kernel: split patches folder up into backport, pending and hack folders * properly format/comment all patches * merge debloat patches * merge Kconfig patches * merge swconfig patches * merge hotplug patches * drop 200-fix_localversion.patch - upstream * drop 222-arm_zimage_none.patch - unused * drop 252-mv_cesa_depends.patch - no longer required * drop 410-mtd-move-forward-declaration-of-struct-mtd_info.patch - unused * drop 661-fq_codel_keep_dropped_stats.patch - outdated * drop 702-phy_add_aneg_done_function.patch - upstream * drop 840-rtc7301.patch - unused * drop 841-rtc_pt7c4338.patch - upstream * drop 921-use_preinit_as_init.patch - unused * drop spio-gpio-old and gpio-mmc - unused Signed-off-by: John Crispin --- ...ons-rename-master-to-the-parent-where-app.patch | 606 +++++++++++++++++++++ 1 file changed, 606 insertions(+) create mode 100644 target/linux/generic/backport-4.9/065-v4.13-0005-mtd-partitions-rename-master-to-the-parent-where-app.patch (limited to 'target/linux/generic/backport-4.9/065-v4.13-0005-mtd-partitions-rename-master-to-the-parent-where-app.patch') diff --git a/target/linux/generic/backport-4.9/065-v4.13-0005-mtd-partitions-rename-master-to-the-parent-where-app.patch b/target/linux/generic/backport-4.9/065-v4.13-0005-mtd-partitions-rename-master-to-the-parent-where-app.patch new file mode 100644 index 0000000000..7951227654 --- /dev/null +++ b/target/linux/generic/backport-4.9/065-v4.13-0005-mtd-partitions-rename-master-to-the-parent-where-app.patch @@ -0,0 +1,606 @@ +From 0a9d72b69da6d8dae1abd7990c6c4c749846ef3e Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= +Date: Wed, 21 Jun 2017 08:26:44 +0200 +Subject: [PATCH] mtd: partitions: rename "master" to the "parent" where + appropriate +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +This prepares mtd subsystem for the new feature: subpartitions. In some +cases flash device partition can be a container with extra subpartitions +(volumes). + +So far there was a flat structure implemented. One master (flash device) +could be partitioned into few partitions. Every partition got its master +and it was enough to get things running. + +To support subpartitions we need to store pointer to the parent for each +partition. This is required to implement more natural tree structure and +handle all recursion and offsets calculation. + +To make code consistent this patch renamed "master" to the "parent" in +places where we can be dealing with subpartitions. + +Signed-off-by: Rafał Miłecki +Signed-off-by: Brian Norris +--- + drivers/mtd/mtdpart.c | 204 ++++++++++++++++++++++++++------------------------ + 1 file changed, 105 insertions(+), 99 deletions(-) + +--- a/drivers/mtd/mtdpart.c ++++ b/drivers/mtd/mtdpart.c +@@ -37,10 +37,16 @@ + static LIST_HEAD(mtd_partitions); + static DEFINE_MUTEX(mtd_partitions_mutex); + +-/* Our partition node structure */ ++/** ++ * struct mtd_part - our partition node structure ++ * ++ * @mtd: struct holding partition details ++ * @parent: parent mtd - flash device or another partition ++ * @offset: partition offset relative to the *flash device* ++ */ + struct mtd_part { + struct mtd_info mtd; +- struct mtd_info *master; ++ struct mtd_info *parent; + uint64_t offset; + struct list_head list; + }; +@@ -67,15 +73,15 @@ static int part_read(struct mtd_info *mt + struct mtd_ecc_stats stats; + int res; + +- stats = part->master->ecc_stats; +- res = part->master->_read(part->master, from + part->offset, len, ++ stats = part->parent->ecc_stats; ++ res = part->parent->_read(part->parent, from + part->offset, len, + retlen, buf); + if (unlikely(mtd_is_eccerr(res))) + mtd->ecc_stats.failed += +- part->master->ecc_stats.failed - stats.failed; ++ part->parent->ecc_stats.failed - stats.failed; + else + mtd->ecc_stats.corrected += +- part->master->ecc_stats.corrected - stats.corrected; ++ part->parent->ecc_stats.corrected - stats.corrected; + return res; + } + +@@ -84,7 +90,7 @@ static int part_point(struct mtd_info *m + { + struct mtd_part *part = mtd_to_part(mtd); + +- return part->master->_point(part->master, from + part->offset, len, ++ return part->parent->_point(part->parent, from + part->offset, len, + retlen, virt, phys); + } + +@@ -92,7 +98,7 @@ static int part_unpoint(struct mtd_info + { + struct mtd_part *part = mtd_to_part(mtd); + +- return part->master->_unpoint(part->master, from + part->offset, len); ++ return part->parent->_unpoint(part->parent, from + part->offset, len); + } + + static unsigned long part_get_unmapped_area(struct mtd_info *mtd, +@@ -103,7 +109,7 @@ static unsigned long part_get_unmapped_a + struct mtd_part *part = mtd_to_part(mtd); + + offset += part->offset; +- return part->master->_get_unmapped_area(part->master, len, offset, ++ return part->parent->_get_unmapped_area(part->parent, len, offset, + flags); + } + +@@ -132,7 +138,7 @@ static int part_read_oob(struct mtd_info + return -EINVAL; + } + +- res = part->master->_read_oob(part->master, from + part->offset, ops); ++ res = part->parent->_read_oob(part->parent, from + part->offset, ops); + if (unlikely(res)) { + if (mtd_is_bitflip(res)) + mtd->ecc_stats.corrected++; +@@ -146,7 +152,7 @@ static int part_read_user_prot_reg(struc + size_t len, size_t *retlen, u_char *buf) + { + struct mtd_part *part = mtd_to_part(mtd); +- return part->master->_read_user_prot_reg(part->master, from, len, ++ return part->parent->_read_user_prot_reg(part->parent, from, len, + retlen, buf); + } + +@@ -154,7 +160,7 @@ static int part_get_user_prot_info(struc + size_t *retlen, struct otp_info *buf) + { + struct mtd_part *part = mtd_to_part(mtd); +- return part->master->_get_user_prot_info(part->master, len, retlen, ++ return part->parent->_get_user_prot_info(part->parent, len, retlen, + buf); + } + +@@ -162,7 +168,7 @@ static int part_read_fact_prot_reg(struc + size_t len, size_t *retlen, u_char *buf) + { + struct mtd_part *part = mtd_to_part(mtd); +- return part->master->_read_fact_prot_reg(part->master, from, len, ++ return part->parent->_read_fact_prot_reg(part->parent, from, len, + retlen, buf); + } + +@@ -170,7 +176,7 @@ static int part_get_fact_prot_info(struc + size_t *retlen, struct otp_info *buf) + { + struct mtd_part *part = mtd_to_part(mtd); +- return part->master->_get_fact_prot_info(part->master, len, retlen, ++ return part->parent->_get_fact_prot_info(part->parent, len, retlen, + buf); + } + +@@ -178,7 +184,7 @@ static int part_write(struct mtd_info *m + size_t *retlen, const u_char *buf) + { + struct mtd_part *part = mtd_to_part(mtd); +- return part->master->_write(part->master, to + part->offset, len, ++ return part->parent->_write(part->parent, to + part->offset, len, + retlen, buf); + } + +@@ -186,7 +192,7 @@ static int part_panic_write(struct mtd_i + size_t *retlen, const u_char *buf) + { + struct mtd_part *part = mtd_to_part(mtd); +- return part->master->_panic_write(part->master, to + part->offset, len, ++ return part->parent->_panic_write(part->parent, to + part->offset, len, + retlen, buf); + } + +@@ -199,14 +205,14 @@ static int part_write_oob(struct mtd_inf + return -EINVAL; + if (ops->datbuf && to + ops->len > mtd->size) + return -EINVAL; +- return part->master->_write_oob(part->master, to + part->offset, ops); ++ return part->parent->_write_oob(part->parent, to + part->offset, ops); + } + + static int part_write_user_prot_reg(struct mtd_info *mtd, loff_t from, + size_t len, size_t *retlen, u_char *buf) + { + struct mtd_part *part = mtd_to_part(mtd); +- return part->master->_write_user_prot_reg(part->master, from, len, ++ return part->parent->_write_user_prot_reg(part->parent, from, len, + retlen, buf); + } + +@@ -214,14 +220,14 @@ static int part_lock_user_prot_reg(struc + size_t len) + { + struct mtd_part *part = mtd_to_part(mtd); +- return part->master->_lock_user_prot_reg(part->master, from, len); ++ return part->parent->_lock_user_prot_reg(part->parent, from, len); + } + + static int part_writev(struct mtd_info *mtd, const struct kvec *vecs, + unsigned long count, loff_t to, size_t *retlen) + { + struct mtd_part *part = mtd_to_part(mtd); +- return part->master->_writev(part->master, vecs, count, ++ return part->parent->_writev(part->parent, vecs, count, + to + part->offset, retlen); + } + +@@ -231,7 +237,7 @@ static int part_erase(struct mtd_info *m + int ret; + + instr->addr += part->offset; +- ret = part->master->_erase(part->master, instr); ++ ret = part->parent->_erase(part->parent, instr); + if (ret) { + if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN) + instr->fail_addr -= part->offset; +@@ -257,51 +263,51 @@ EXPORT_SYMBOL_GPL(mtd_erase_callback); + static int part_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len) + { + struct mtd_part *part = mtd_to_part(mtd); +- return part->master->_lock(part->master, ofs + part->offset, len); ++ return part->parent->_lock(part->parent, ofs + part->offset, len); + } + + static int part_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len) + { + struct mtd_part *part = mtd_to_part(mtd); +- return part->master->_unlock(part->master, ofs + part->offset, len); ++ return part->parent->_unlock(part->parent, ofs + part->offset, len); + } + + static int part_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len) + { + struct mtd_part *part = mtd_to_part(mtd); +- return part->master->_is_locked(part->master, ofs + part->offset, len); ++ return part->parent->_is_locked(part->parent, ofs + part->offset, len); + } + + static void part_sync(struct mtd_info *mtd) + { + struct mtd_part *part = mtd_to_part(mtd); +- part->master->_sync(part->master); ++ part->parent->_sync(part->parent); + } + + static int part_suspend(struct mtd_info *mtd) + { + struct mtd_part *part = mtd_to_part(mtd); +- return part->master->_suspend(part->master); ++ return part->parent->_suspend(part->parent); + } + + static void part_resume(struct mtd_info *mtd) + { + struct mtd_part *part = mtd_to_part(mtd); +- part->master->_resume(part->master); ++ part->parent->_resume(part->parent); + } + + static int part_block_isreserved(struct mtd_info *mtd, loff_t ofs) + { + struct mtd_part *part = mtd_to_part(mtd); + ofs += part->offset; +- return part->master->_block_isreserved(part->master, ofs); ++ return part->parent->_block_isreserved(part->parent, ofs); + } + + static int part_block_isbad(struct mtd_info *mtd, loff_t ofs) + { + struct mtd_part *part = mtd_to_part(mtd); + ofs += part->offset; +- return part->master->_block_isbad(part->master, ofs); ++ return part->parent->_block_isbad(part->parent, ofs); + } + + static int part_block_markbad(struct mtd_info *mtd, loff_t ofs) +@@ -310,7 +316,7 @@ static int part_block_markbad(struct mtd + int res; + + ofs += part->offset; +- res = part->master->_block_markbad(part->master, ofs); ++ res = part->parent->_block_markbad(part->parent, ofs); + if (!res) + mtd->ecc_stats.badblocks++; + return res; +@@ -319,13 +325,13 @@ static int part_block_markbad(struct mtd + static int part_get_device(struct mtd_info *mtd) + { + struct mtd_part *part = mtd_to_part(mtd); +- return part->master->_get_device(part->master); ++ return part->parent->_get_device(part->parent); + } + + static void part_put_device(struct mtd_info *mtd) + { + struct mtd_part *part = mtd_to_part(mtd); +- part->master->_put_device(part->master); ++ part->parent->_put_device(part->parent); + } + + static int part_ooblayout_ecc(struct mtd_info *mtd, int section, +@@ -333,7 +339,7 @@ static int part_ooblayout_ecc(struct mtd + { + struct mtd_part *part = mtd_to_part(mtd); + +- return mtd_ooblayout_ecc(part->master, section, oobregion); ++ return mtd_ooblayout_ecc(part->parent, section, oobregion); + } + + static int part_ooblayout_free(struct mtd_info *mtd, int section, +@@ -341,7 +347,7 @@ static int part_ooblayout_free(struct mt + { + struct mtd_part *part = mtd_to_part(mtd); + +- return mtd_ooblayout_free(part->master, section, oobregion); ++ return mtd_ooblayout_free(part->parent, section, oobregion); + } + + static const struct mtd_ooblayout_ops part_ooblayout_ops = { +@@ -353,7 +359,7 @@ static int part_max_bad_blocks(struct mt + { + struct mtd_part *part = mtd_to_part(mtd); + +- return part->master->_max_bad_blocks(part->master, ++ return part->parent->_max_bad_blocks(part->parent, + ofs + part->offset, len); + } + +@@ -363,12 +369,12 @@ static inline void free_partition(struct + kfree(p); + } + +-static struct mtd_part *allocate_partition(struct mtd_info *master, ++static struct mtd_part *allocate_partition(struct mtd_info *parent, + const struct mtd_partition *part, int partno, + uint64_t cur_offset) + { +- int wr_alignment = (master->flags & MTD_NO_ERASE) ? master->writesize: +- master->erasesize; ++ int wr_alignment = (parent->flags & MTD_NO_ERASE) ? parent->writesize: ++ parent->erasesize; + struct mtd_part *slave; + u32 remainder; + char *name; +@@ -379,25 +385,25 @@ static struct mtd_part *allocate_partiti + name = kstrdup(part->name, GFP_KERNEL); + if (!name || !slave) { + printk(KERN_ERR"memory allocation error while creating partitions for \"%s\"\n", +- master->name); ++ parent->name); + kfree(name); + kfree(slave); + return ERR_PTR(-ENOMEM); + } + + /* set up the MTD object for this partition */ +- slave->mtd.type = master->type; +- slave->mtd.flags = master->flags & ~part->mask_flags; ++ slave->mtd.type = parent->type; ++ slave->mtd.flags = parent->flags & ~part->mask_flags; + slave->mtd.size = part->size; +- slave->mtd.writesize = master->writesize; +- slave->mtd.writebufsize = master->writebufsize; +- slave->mtd.oobsize = master->oobsize; +- slave->mtd.oobavail = master->oobavail; +- slave->mtd.subpage_sft = master->subpage_sft; +- slave->mtd.pairing = master->pairing; ++ slave->mtd.writesize = parent->writesize; ++ slave->mtd.writebufsize = parent->writebufsize; ++ slave->mtd.oobsize = parent->oobsize; ++ slave->mtd.oobavail = parent->oobavail; ++ slave->mtd.subpage_sft = parent->subpage_sft; ++ slave->mtd.pairing = parent->pairing; + + slave->mtd.name = name; +- slave->mtd.owner = master->owner; ++ slave->mtd.owner = parent->owner; + + /* NOTE: Historically, we didn't arrange MTDs as a tree out of + * concern for showing the same data in multiple partitions. +@@ -408,70 +414,70 @@ static struct mtd_part *allocate_partiti + * distinguish between the master and the partition in sysfs. + */ + slave->mtd.dev.parent = IS_ENABLED(CONFIG_MTD_PARTITIONED_MASTER) ? +- &master->dev : +- master->dev.parent; ++ &parent->dev : ++ parent->dev.parent; + slave->mtd.dev.of_node = part->of_node; + + slave->mtd._read = part_read; + slave->mtd._write = part_write; + +- if (master->_panic_write) ++ if (parent->_panic_write) + slave->mtd._panic_write = part_panic_write; + +- if (master->_point && master->_unpoint) { ++ if (parent->_point && parent->_unpoint) { + slave->mtd._point = part_point; + slave->mtd._unpoint = part_unpoint; + } + +- if (master->_get_unmapped_area) ++ if (parent->_get_unmapped_area) + slave->mtd._get_unmapped_area = part_get_unmapped_area; +- if (master->_read_oob) ++ if (parent->_read_oob) + slave->mtd._read_oob = part_read_oob; +- if (master->_write_oob) ++ if (parent->_write_oob) + slave->mtd._write_oob = part_write_oob; +- if (master->_read_user_prot_reg) ++ if (parent->_read_user_prot_reg) + slave->mtd._read_user_prot_reg = part_read_user_prot_reg; +- if (master->_read_fact_prot_reg) ++ if (parent->_read_fact_prot_reg) + slave->mtd._read_fact_prot_reg = part_read_fact_prot_reg; +- if (master->_write_user_prot_reg) ++ if (parent->_write_user_prot_reg) + slave->mtd._write_user_prot_reg = part_write_user_prot_reg; +- if (master->_lock_user_prot_reg) ++ if (parent->_lock_user_prot_reg) + slave->mtd._lock_user_prot_reg = part_lock_user_prot_reg; +- if (master->_get_user_prot_info) ++ if (parent->_get_user_prot_info) + slave->mtd._get_user_prot_info = part_get_user_prot_info; +- if (master->_get_fact_prot_info) ++ if (parent->_get_fact_prot_info) + slave->mtd._get_fact_prot_info = part_get_fact_prot_info; +- if (master->_sync) ++ if (parent->_sync) + slave->mtd._sync = part_sync; +- if (!partno && !master->dev.class && master->_suspend && +- master->_resume) { ++ if (!partno && !parent->dev.class && parent->_suspend && ++ parent->_resume) { + slave->mtd._suspend = part_suspend; + slave->mtd._resume = part_resume; + } +- if (master->_writev) ++ if (parent->_writev) + slave->mtd._writev = part_writev; +- if (master->_lock) ++ if (parent->_lock) + slave->mtd._lock = part_lock; +- if (master->_unlock) ++ if (parent->_unlock) + slave->mtd._unlock = part_unlock; +- if (master->_is_locked) ++ if (parent->_is_locked) + slave->mtd._is_locked = part_is_locked; +- if (master->_block_isreserved) ++ if (parent->_block_isreserved) + slave->mtd._block_isreserved = part_block_isreserved; +- if (master->_block_isbad) ++ if (parent->_block_isbad) + slave->mtd._block_isbad = part_block_isbad; +- if (master->_block_markbad) ++ if (parent->_block_markbad) + slave->mtd._block_markbad = part_block_markbad; +- if (master->_max_bad_blocks) ++ if (parent->_max_bad_blocks) + slave->mtd._max_bad_blocks = part_max_bad_blocks; + +- if (master->_get_device) ++ if (parent->_get_device) + slave->mtd._get_device = part_get_device; +- if (master->_put_device) ++ if (parent->_put_device) + slave->mtd._put_device = part_put_device; + + slave->mtd._erase = part_erase; +- slave->master = master; ++ slave->parent = parent; + slave->offset = part->offset; + + if (slave->offset == MTDPART_OFS_APPEND) +@@ -489,25 +495,25 @@ static struct mtd_part *allocate_partiti + } + if (slave->offset == MTDPART_OFS_RETAIN) { + slave->offset = cur_offset; +- if (master->size - slave->offset >= slave->mtd.size) { +- slave->mtd.size = master->size - slave->offset ++ if (parent->size - slave->offset >= slave->mtd.size) { ++ slave->mtd.size = parent->size - slave->offset + - slave->mtd.size; + } else { + printk(KERN_ERR "mtd partition \"%s\" doesn't have enough space: %#llx < %#llx, disabled\n", +- part->name, master->size - slave->offset, ++ part->name, parent->size - slave->offset, + slave->mtd.size); + /* register to preserve ordering */ + goto out_register; + } + } + if (slave->mtd.size == MTDPART_SIZ_FULL) +- slave->mtd.size = master->size - slave->offset; ++ slave->mtd.size = parent->size - slave->offset; + + printk(KERN_NOTICE "0x%012llx-0x%012llx : \"%s\"\n", (unsigned long long)slave->offset, + (unsigned long long)(slave->offset + slave->mtd.size), slave->mtd.name); + + /* let's do some sanity checks */ +- if (slave->offset >= master->size) { ++ if (slave->offset >= parent->size) { + /* let's register it anyway to preserve ordering */ + slave->offset = 0; + slave->mtd.size = 0; +@@ -515,16 +521,16 @@ static struct mtd_part *allocate_partiti + part->name); + goto out_register; + } +- if (slave->offset + slave->mtd.size > master->size) { +- slave->mtd.size = master->size - slave->offset; ++ if (slave->offset + slave->mtd.size > parent->size) { ++ slave->mtd.size = parent->size - slave->offset; + printk(KERN_WARNING"mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#llx\n", +- part->name, master->name, (unsigned long long)slave->mtd.size); ++ part->name, parent->name, (unsigned long long)slave->mtd.size); + } +- if (master->numeraseregions > 1) { ++ if (parent->numeraseregions > 1) { + /* Deal with variable erase size stuff */ +- int i, max = master->numeraseregions; ++ int i, max = parent->numeraseregions; + u64 end = slave->offset + slave->mtd.size; +- struct mtd_erase_region_info *regions = master->eraseregions; ++ struct mtd_erase_region_info *regions = parent->eraseregions; + + /* Find the first erase regions which is part of this + * partition. */ +@@ -543,7 +549,7 @@ static struct mtd_part *allocate_partiti + BUG_ON(slave->mtd.erasesize == 0); + } else { + /* Single erase size */ +- slave->mtd.erasesize = master->erasesize; ++ slave->mtd.erasesize = parent->erasesize; + } + + tmp = slave->offset; +@@ -566,17 +572,17 @@ static struct mtd_part *allocate_partiti + } + + mtd_set_ooblayout(&slave->mtd, &part_ooblayout_ops); +- slave->mtd.ecc_step_size = master->ecc_step_size; +- slave->mtd.ecc_strength = master->ecc_strength; +- slave->mtd.bitflip_threshold = master->bitflip_threshold; ++ slave->mtd.ecc_step_size = parent->ecc_step_size; ++ slave->mtd.ecc_strength = parent->ecc_strength; ++ slave->mtd.bitflip_threshold = parent->bitflip_threshold; + +- if (master->_block_isbad) { ++ if (parent->_block_isbad) { + uint64_t offs = 0; + + while (offs < slave->mtd.size) { +- if (mtd_block_isreserved(master, offs + slave->offset)) ++ if (mtd_block_isreserved(parent, offs + slave->offset)) + slave->mtd.ecc_stats.bbtblocks++; +- else if (mtd_block_isbad(master, offs + slave->offset)) ++ else if (mtd_block_isbad(parent, offs + slave->offset)) + slave->mtd.ecc_stats.badblocks++; + offs += slave->mtd.erasesize; + } +@@ -610,7 +616,7 @@ static int mtd_add_partition_attrs(struc + return ret; + } + +-int mtd_add_partition(struct mtd_info *master, const char *name, ++int mtd_add_partition(struct mtd_info *parent, const char *name, + long long offset, long long length) + { + struct mtd_partition part; +@@ -623,7 +629,7 @@ int mtd_add_partition(struct mtd_info *m + return -EINVAL; + + if (length == MTDPART_SIZ_FULL) +- length = master->size - offset; ++ length = parent->size - offset; + + if (length <= 0) + return -EINVAL; +@@ -633,7 +639,7 @@ int mtd_add_partition(struct mtd_info *m + part.size = length; + part.offset = offset; + +- new = allocate_partition(master, &part, -1, offset); ++ new = allocate_partition(parent, &part, -1, offset); + if (IS_ERR(new)) + return PTR_ERR(new); + +@@ -683,7 +689,7 @@ int del_mtd_partitions(struct mtd_info * + + mutex_lock(&mtd_partitions_mutex); + list_for_each_entry_safe(slave, next, &mtd_partitions, list) +- if (slave->master == master) { ++ if (slave->parent == master) { + ret = __mtd_del_partition(slave); + if (ret < 0) + err = ret; +@@ -700,7 +706,7 @@ int mtd_del_partition(struct mtd_info *m + + mutex_lock(&mtd_partitions_mutex); + list_for_each_entry_safe(slave, next, &mtd_partitions, list) +- if ((slave->master == master) && ++ if ((slave->parent == master) && + (slave->mtd.index == partno)) { + ret = __mtd_del_partition(slave); + break; +@@ -933,6 +939,6 @@ uint64_t mtd_get_device_size(const struc + if (!mtd_is_partition(mtd)) + return mtd->size; + +- return mtd_to_part(mtd)->master->size; ++ return mtd_to_part(mtd)->parent->size; + } + EXPORT_SYMBOL_GPL(mtd_get_device_size); -- cgit v1.2.3