From: Rafał Miłecki Date: Wed, 14 Mar 2018 14:07:03 +0000 (+0100) Subject: kernel: use V10 of mtd patchset adding support for "compatible" string X-Git-Tag: v18.06.0-rc1~647 X-Git-Url: https://git.librecmc.org/?a=commitdiff_plain;h=ac9bcefa3b044;p=oweals%2Fopenwrt.git kernel: use V10 of mtd patchset adding support for "compatible" string In the commit bde5e7a632ef0 ("kernel: backport mtd implementation for "compatible" in "partitions" subnode") patches that got accepted into l2-mtd.git were backported to the kernels 4.9 and 4.14. Unfortunately there was a regression report, patches were dropped and never reached 4.16. This commit replaces these pseudo-backports with the latest version that includes regression fix and futher changes that were requested. Signed-off-by: Rafał Miłecki --- diff --git a/target/linux/generic/backport-4.14/041-v4.16-0001-mtd-partitions-add-of_match_table-parser-matching.patch b/target/linux/generic/backport-4.14/041-v4.16-0001-mtd-partitions-add-of_match_table-parser-matching.patch deleted file mode 100644 index d698821f3c..0000000000 --- a/target/linux/generic/backport-4.14/041-v4.16-0001-mtd-partitions-add-of_match_table-parser-matching.patch +++ /dev/null @@ -1,121 +0,0 @@ -From bb2192123ec70470d6ea33f138846b175403a968 Mon Sep 17 00:00:00 2001 -From: Brian Norris -Date: Thu, 4 Jan 2018 08:05:33 +0100 -Subject: [PATCH] mtd: partitions: add of_match_table parser matching -MIME-Version: 1.0 -Content-Type: text/plain; charset=UTF-8 -Content-Transfer-Encoding: 8bit - -Partition parsers can now provide an of_match_table to enable -flash<-->parser matching via device tree as documented in the -mtd/partition.txt. - -It works by looking for a matching parser for every string in the -"compatibility" property (starting with the most specific one). - -This support is currently limited to built-in parsers as it uses -request_module() and friends. This should be sufficient for most cases -though as compiling parsers as modules isn't a common choice. - -Signed-off-by: Brian Norris -Signed-off-by: Rafał Miłecki -Signed-off-by: Boris Brezillon ---- - drivers/mtd/mtdpart.c | 59 ++++++++++++++++++++++++++++++++++++++++++ - include/linux/mtd/partitions.h | 1 + - 2 files changed, 60 insertions(+) - ---- a/drivers/mtd/mtdpart.c -+++ b/drivers/mtd/mtdpart.c -@@ -30,6 +30,7 @@ - #include - #include - #include -+#include - - #include "mtdcore.h" - -@@ -894,6 +895,45 @@ static int mtd_part_do_parse(struct mtd_ - } - - /** -+ * mtd_part_get_compatible_parser - find MTD parser by a compatible string -+ * -+ * @compat: compatible string describing partitions in a device tree -+ * -+ * MTD parsers can specify supported partitions by providing a table of -+ * compatibility strings. This function finds a parser that advertises support -+ * for a passed value of "compatible". -+ */ -+static struct mtd_part_parser *mtd_part_get_compatible_parser(const char *compat) -+{ -+ struct mtd_part_parser *p, *ret = NULL; -+ -+ spin_lock(&part_parser_lock); -+ -+ list_for_each_entry(p, &part_parsers, list) { -+ const struct of_device_id *matches; -+ -+ matches = p->of_match_table; -+ if (!matches) -+ continue; -+ -+ for (; matches->compatible[0]; matches++) { -+ if (!strcmp(matches->compatible, compat) && -+ try_module_get(p->owner)) { -+ ret = p; -+ break; -+ } -+ } -+ -+ if (ret) -+ break; -+ } -+ -+ spin_unlock(&part_parser_lock); -+ -+ return ret; -+} -+ -+/** - * parse_mtd_partitions - parse MTD partitions - * @master: the master partition (describes whole MTD device) - * @types: names of partition parsers to try or %NULL -@@ -919,8 +959,27 @@ int parse_mtd_partitions(struct mtd_info - struct mtd_part_parser_data *data) - { - struct mtd_part_parser *parser; -+ struct device_node *np; -+ struct property *prop; -+ const char *compat; - int ret, err = 0; - -+ np = of_get_child_by_name(mtd_get_of_node(master), "partitions"); -+ of_property_for_each_string(np, "compatible", prop, compat) { -+ parser = mtd_part_get_compatible_parser(compat); -+ if (!parser) -+ continue; -+ ret = mtd_part_do_parse(parser, master, pparts, data); -+ if (ret > 0) { -+ of_node_put(np); -+ return 0; -+ } -+ mtd_part_parser_put(parser); -+ if (ret < 0 && !err) -+ err = ret; -+ } -+ of_node_put(np); -+ - if (!types) - types = default_mtd_part_types; - ---- a/include/linux/mtd/partitions.h -+++ b/include/linux/mtd/partitions.h -@@ -77,6 +77,7 @@ struct mtd_part_parser { - struct list_head list; - struct module *owner; - const char *name; -+ const struct of_device_id *of_match_table; - int (*parse_fn)(struct mtd_info *, const struct mtd_partition **, - struct mtd_part_parser_data *); - void (*cleanup)(const struct mtd_partition *pparts, int nr_parts); diff --git a/target/linux/generic/backport-4.14/041-v4.16-0002-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch b/target/linux/generic/backport-4.14/041-v4.16-0002-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch deleted file mode 100644 index 2092cc28fd..0000000000 --- a/target/linux/generic/backport-4.14/041-v4.16-0002-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch +++ /dev/null @@ -1,43 +0,0 @@ -From 4ac9222778478a00c7fc9d347b7ed1e0e595120d Mon Sep 17 00:00:00 2001 -From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= -Date: Thu, 4 Jan 2018 08:05:34 +0100 -Subject: [PATCH] mtd: ofpart: add of_match_table with "fixed-partitions" -MIME-Version: 1.0 -Content-Type: text/plain; charset=UTF-8 -Content-Transfer-Encoding: 8bit - -This allows using this parser with any flash driver that takes care of -setting of_node (using mtd_set_of_node helper) correctly. Up to now -support for "fixed-partitions" DT compatibility string was working only -with flash drivers that were specifying "ofpart" (manually or by letting -mtd use the default set of parsers). - -This matches existing bindings documentation. - -Signed-off-by: Rafał Miłecki -Reviewed-by: Brian Norris -Tested-by: Brian Norris -Signed-off-by: Boris Brezillon ---- - drivers/mtd/ofpart.c | 7 +++++++ - 1 file changed, 7 insertions(+) - ---- a/drivers/mtd/ofpart.c -+++ b/drivers/mtd/ofpart.c -@@ -140,9 +140,16 @@ ofpart_none: - return ret; - } - -+static const struct of_device_id parse_ofpart_match_table[] = { -+ { .compatible = "fixed-partitions" }, -+ {}, -+}; -+MODULE_DEVICE_TABLE(of, parse_ofpart_match_table); -+ - static struct mtd_part_parser ofpart_parser = { - .parse_fn = parse_ofpart_partitions, - .name = "ofpart", -+ .of_match_table = parse_ofpart_match_table, - }; - - static int parse_ofoldpart_partitions(struct mtd_info *master, diff --git a/target/linux/generic/backport-4.9/067-v4.17-0001-mtd-partitions-add-of_match_table-parser-matching.patch b/target/linux/generic/backport-4.9/067-v4.17-0001-mtd-partitions-add-of_match_table-parser-matching.patch deleted file mode 100644 index 06931ce2a4..0000000000 --- a/target/linux/generic/backport-4.9/067-v4.17-0001-mtd-partitions-add-of_match_table-parser-matching.patch +++ /dev/null @@ -1,121 +0,0 @@ -From bb2192123ec70470d6ea33f138846b175403a968 Mon Sep 17 00:00:00 2001 -From: Brian Norris -Date: Thu, 4 Jan 2018 08:05:33 +0100 -Subject: [PATCH] mtd: partitions: add of_match_table parser matching -MIME-Version: 1.0 -Content-Type: text/plain; charset=UTF-8 -Content-Transfer-Encoding: 8bit - -Partition parsers can now provide an of_match_table to enable -flash<-->parser matching via device tree as documented in the -mtd/partition.txt. - -It works by looking for a matching parser for every string in the -"compatibility" property (starting with the most specific one). - -This support is currently limited to built-in parsers as it uses -request_module() and friends. This should be sufficient for most cases -though as compiling parsers as modules isn't a common choice. - -Signed-off-by: Brian Norris -Signed-off-by: Rafał Miłecki -Signed-off-by: Boris Brezillon ---- - drivers/mtd/mtdpart.c | 59 ++++++++++++++++++++++++++++++++++++++++++ - include/linux/mtd/partitions.h | 1 + - 2 files changed, 60 insertions(+) - ---- a/drivers/mtd/mtdpart.c -+++ b/drivers/mtd/mtdpart.c -@@ -30,6 +30,7 @@ - #include - #include - #include -+#include - - #include "mtdcore.h" - -@@ -886,6 +887,45 @@ static int mtd_part_do_parse(struct mtd_ - } - - /** -+ * mtd_part_get_compatible_parser - find MTD parser by a compatible string -+ * -+ * @compat: compatible string describing partitions in a device tree -+ * -+ * MTD parsers can specify supported partitions by providing a table of -+ * compatibility strings. This function finds a parser that advertises support -+ * for a passed value of "compatible". -+ */ -+static struct mtd_part_parser *mtd_part_get_compatible_parser(const char *compat) -+{ -+ struct mtd_part_parser *p, *ret = NULL; -+ -+ spin_lock(&part_parser_lock); -+ -+ list_for_each_entry(p, &part_parsers, list) { -+ const struct of_device_id *matches; -+ -+ matches = p->of_match_table; -+ if (!matches) -+ continue; -+ -+ for (; matches->compatible[0]; matches++) { -+ if (!strcmp(matches->compatible, compat) && -+ try_module_get(p->owner)) { -+ ret = p; -+ break; -+ } -+ } -+ -+ if (ret) -+ break; -+ } -+ -+ spin_unlock(&part_parser_lock); -+ -+ return ret; -+} -+ -+/** - * parse_mtd_partitions - parse MTD partitions - * @master: the master partition (describes whole MTD device) - * @types: names of partition parsers to try or %NULL -@@ -911,8 +951,27 @@ int parse_mtd_partitions(struct mtd_info - struct mtd_part_parser_data *data) - { - struct mtd_part_parser *parser; -+ struct device_node *np; -+ struct property *prop; -+ const char *compat; - int ret, err = 0; - -+ np = of_get_child_by_name(mtd_get_of_node(master), "partitions"); -+ of_property_for_each_string(np, "compatible", prop, compat) { -+ parser = mtd_part_get_compatible_parser(compat); -+ if (!parser) -+ continue; -+ ret = mtd_part_do_parse(parser, master, pparts, data); -+ if (ret > 0) { -+ of_node_put(np); -+ return 0; -+ } -+ mtd_part_parser_put(parser); -+ if (ret < 0 && !err) -+ err = ret; -+ } -+ of_node_put(np); -+ - if (!types) - types = default_mtd_part_types; - ---- a/include/linux/mtd/partitions.h -+++ b/include/linux/mtd/partitions.h -@@ -77,6 +77,7 @@ struct mtd_part_parser { - struct list_head list; - struct module *owner; - const char *name; -+ const struct of_device_id *of_match_table; - int (*parse_fn)(struct mtd_info *, const struct mtd_partition **, - struct mtd_part_parser_data *); - void (*cleanup)(const struct mtd_partition *pparts, int nr_parts); diff --git a/target/linux/generic/backport-4.9/067-v4.17-0002-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch b/target/linux/generic/backport-4.9/067-v4.17-0002-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch deleted file mode 100644 index 2092cc28fd..0000000000 --- a/target/linux/generic/backport-4.9/067-v4.17-0002-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch +++ /dev/null @@ -1,43 +0,0 @@ -From 4ac9222778478a00c7fc9d347b7ed1e0e595120d Mon Sep 17 00:00:00 2001 -From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= -Date: Thu, 4 Jan 2018 08:05:34 +0100 -Subject: [PATCH] mtd: ofpart: add of_match_table with "fixed-partitions" -MIME-Version: 1.0 -Content-Type: text/plain; charset=UTF-8 -Content-Transfer-Encoding: 8bit - -This allows using this parser with any flash driver that takes care of -setting of_node (using mtd_set_of_node helper) correctly. Up to now -support for "fixed-partitions" DT compatibility string was working only -with flash drivers that were specifying "ofpart" (manually or by letting -mtd use the default set of parsers). - -This matches existing bindings documentation. - -Signed-off-by: Rafał Miłecki -Reviewed-by: Brian Norris -Tested-by: Brian Norris -Signed-off-by: Boris Brezillon ---- - drivers/mtd/ofpart.c | 7 +++++++ - 1 file changed, 7 insertions(+) - ---- a/drivers/mtd/ofpart.c -+++ b/drivers/mtd/ofpart.c -@@ -140,9 +140,16 @@ ofpart_none: - return ret; - } - -+static const struct of_device_id parse_ofpart_match_table[] = { -+ { .compatible = "fixed-partitions" }, -+ {}, -+}; -+MODULE_DEVICE_TABLE(of, parse_ofpart_match_table); -+ - static struct mtd_part_parser ofpart_parser = { - .parse_fn = parse_ofpart_partitions, - .name = "ofpart", -+ .of_match_table = parse_ofpart_match_table, - }; - - static int parse_ofoldpart_partitions(struct mtd_info *master, diff --git a/target/linux/generic/pending-4.14/160-0001-mtd-partitions-add-of_match_table-parser-matching-fo.patch b/target/linux/generic/pending-4.14/160-0001-mtd-partitions-add-of_match_table-parser-matching-fo.patch new file mode 100644 index 0000000000..3334203d8a --- /dev/null +++ b/target/linux/generic/pending-4.14/160-0001-mtd-partitions-add-of_match_table-parser-matching-fo.patch @@ -0,0 +1,194 @@ +From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= +Date: Tue, 30 Jan 2018 11:55:16 +0100 +Subject: [PATCH V10 1/3] mtd: partitions: add of_match_table parser matching + for the "ofpart" type +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +In order to properly support compatibility strings as described in the +bindings/mtd/partition.txt "ofpart" type should be treated as an +indication for looking into OF. MTD should check "compatible" property +and search for a matching parser rather than blindly trying the one +supporting "fixed-partitions". + +It also means that existing "fixed-partitions" parser should get renamed +to use a more meaningful name. + +This commit achievies that aim by introducing a new mtd_part_of_parse(). +It works by looking for a matching parser for every string in the +"compatibility" property (starting with the most specific one). + +Please note that driver-specified parsers still take a precedence. It's +assumed that driver providing a parser type has a good reason for that +(e.g. having platform data with device-specific info). Also doing +otherwise could break existing setups. The same applies to using default +parsers (including "cmdlinepart") as some overwrite DT data with cmdline +argument. + +Partition parsers can now provide an of_match_table to enable +flash<-->parser matching via device tree as documented in the +mtd/partition.txt. + +This support is currently limited to built-in parsers as it uses +request_module() and friends. This should be sufficient for most cases +though as compiling parsers as modules isn't a common choice. + +Signed-off-by: Brian Norris +Signed-off-by: Rafał Miłecki +Tested-by: Peter Rosin +--- + +--- a/drivers/mtd/mtdpart.c ++++ b/drivers/mtd/mtdpart.c +@@ -30,6 +30,7 @@ + #include + #include + #include ++#include + + #include "mtdcore.h" + +@@ -894,6 +895,92 @@ static int mtd_part_do_parse(struct mtd_ + } + + /** ++ * mtd_part_get_compatible_parser - find MTD parser by a compatible string ++ * ++ * @compat: compatible string describing partitions in a device tree ++ * ++ * MTD parsers can specify supported partitions by providing a table of ++ * compatibility strings. This function finds a parser that advertises support ++ * for a passed value of "compatible". ++ */ ++static struct mtd_part_parser *mtd_part_get_compatible_parser(const char *compat) ++{ ++ struct mtd_part_parser *p, *ret = NULL; ++ ++ spin_lock(&part_parser_lock); ++ ++ list_for_each_entry(p, &part_parsers, list) { ++ const struct of_device_id *matches; ++ ++ matches = p->of_match_table; ++ if (!matches) ++ continue; ++ ++ for (; matches->compatible[0]; matches++) { ++ if (!strcmp(matches->compatible, compat) && ++ try_module_get(p->owner)) { ++ ret = p; ++ break; ++ } ++ } ++ ++ if (ret) ++ break; ++ } ++ ++ spin_unlock(&part_parser_lock); ++ ++ return ret; ++} ++ ++static int mtd_part_of_parse(struct mtd_info *master, ++ struct mtd_partitions *pparts) ++{ ++ struct mtd_part_parser *parser; ++ struct device_node *np; ++ struct property *prop; ++ const char *compat; ++ const char *fixed = "ofpart"; ++ int ret, err = 0; ++ ++ np = of_get_child_by_name(mtd_get_of_node(master), "partitions"); ++ of_property_for_each_string(np, "compatible", prop, compat) { ++ parser = mtd_part_get_compatible_parser(compat); ++ if (!parser) ++ continue; ++ ret = mtd_part_do_parse(parser, master, pparts, NULL); ++ if (ret > 0) { ++ of_node_put(np); ++ return ret; ++ } ++ mtd_part_parser_put(parser); ++ if (ret < 0 && !err) ++ err = ret; ++ } ++ of_node_put(np); ++ ++ /* ++ * For backward compatibility we have to try the "ofpart" ++ * parser. It supports old DT format with partitions specified as a ++ * direct subnodes of a flash device DT node without any compatibility ++ * specified we could match. ++ */ ++ parser = mtd_part_parser_get(fixed); ++ if (!parser && !request_module("%s", fixed)) ++ parser = mtd_part_parser_get(fixed); ++ if (parser) { ++ ret = mtd_part_do_parse(parser, master, pparts, NULL); ++ if (ret > 0) ++ return ret; ++ mtd_part_parser_put(parser); ++ if (ret < 0 && !err) ++ err = ret; ++ } ++ ++ return err; ++} ++ ++/** + * parse_mtd_partitions - parse MTD partitions + * @master: the master partition (describes whole MTD device) + * @types: names of partition parsers to try or %NULL +@@ -925,19 +1012,30 @@ int parse_mtd_partitions(struct mtd_info + types = default_mtd_part_types; + + for ( ; *types; types++) { +- pr_debug("%s: parsing partitions %s\n", master->name, *types); +- parser = mtd_part_parser_get(*types); +- if (!parser && !request_module("%s", *types)) ++ /* ++ * ofpart is a special type that means OF partitioning info ++ * should be used. It requires a bit different logic so it is ++ * handled in a separated function. ++ */ ++ if (!strcmp(*types, "ofpart")) { ++ ret = mtd_part_of_parse(master, pparts); ++ } else { ++ pr_debug("%s: parsing partitions %s\n", master->name, ++ *types); + parser = mtd_part_parser_get(*types); +- pr_debug("%s: got parser %s\n", master->name, +- parser ? parser->name : NULL); +- if (!parser) +- continue; +- ret = mtd_part_do_parse(parser, master, pparts, data); ++ if (!parser && !request_module("%s", *types)) ++ parser = mtd_part_parser_get(*types); ++ pr_debug("%s: got parser %s\n", master->name, ++ parser ? parser->name : NULL); ++ if (!parser) ++ continue; ++ ret = mtd_part_do_parse(parser, master, pparts, data); ++ if (ret <= 0) ++ mtd_part_parser_put(parser); ++ } + /* Found partitions! */ + if (ret > 0) + return 0; +- mtd_part_parser_put(parser); + /* + * Stash the first error we see; only report it if no parser + * succeeds +--- a/include/linux/mtd/partitions.h ++++ b/include/linux/mtd/partitions.h +@@ -77,6 +77,7 @@ struct mtd_part_parser { + struct list_head list; + struct module *owner; + const char *name; ++ const struct of_device_id *of_match_table; + int (*parse_fn)(struct mtd_info *, const struct mtd_partition **, + struct mtd_part_parser_data *); + void (*cleanup)(const struct mtd_partition *pparts, int nr_parts); diff --git a/target/linux/generic/pending-4.14/160-0002-mtd-rename-ofpart-parser-to-fixed-partitions-as-it-f.patch b/target/linux/generic/pending-4.14/160-0002-mtd-rename-ofpart-parser-to-fixed-partitions-as-it-f.patch new file mode 100644 index 0000000000..c380655635 --- /dev/null +++ b/target/linux/generic/pending-4.14/160-0002-mtd-rename-ofpart-parser-to-fixed-partitions-as-it-f.patch @@ -0,0 +1,68 @@ +From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= +Date: Tue, 30 Jan 2018 12:09:58 +0100 +Subject: [PATCH V10 2/3] mtd: rename "ofpart" parser to "fixed-partitions" as + it fits it better +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Type "ofpart" means that OF should be used to get partitioning info and +this driver supports "fixed-partitions" binding only. Renaming it should +lead to less confusion especially when parsers for new compatibility +strings start to appear. + +Signed-off-by: Rafał Miłecki +--- + +--- a/drivers/mtd/mtdpart.c ++++ b/drivers/mtd/mtdpart.c +@@ -940,7 +940,7 @@ static int mtd_part_of_parse(struct mtd_ + struct device_node *np; + struct property *prop; + const char *compat; +- const char *fixed = "ofpart"; ++ const char *fixed = "fixed-partitions"; + int ret, err = 0; + + np = of_get_child_by_name(mtd_get_of_node(master), "partitions"); +@@ -960,7 +960,7 @@ static int mtd_part_of_parse(struct mtd_ + of_node_put(np); + + /* +- * For backward compatibility we have to try the "ofpart" ++ * For backward compatibility we have to try the "fixed-partitions" + * parser. It supports old DT format with partitions specified as a + * direct subnodes of a flash device DT node without any compatibility + * specified we could match. +--- a/drivers/mtd/ofpart.c ++++ b/drivers/mtd/ofpart.c +@@ -25,9 +25,9 @@ static bool node_has_compatible(struct d + return of_get_property(pp, "compatible", NULL); + } + +-static int parse_ofpart_partitions(struct mtd_info *master, +- const struct mtd_partition **pparts, +- struct mtd_part_parser_data *data) ++static int parse_fixed_partitions(struct mtd_info *master, ++ const struct mtd_partition **pparts, ++ struct mtd_part_parser_data *data) + { + struct mtd_partition *parts; + struct device_node *mtd_node; +@@ -141,8 +141,8 @@ ofpart_none: + } + + static struct mtd_part_parser ofpart_parser = { +- .parse_fn = parse_ofpart_partitions, +- .name = "ofpart", ++ .parse_fn = parse_fixed_partitions, ++ .name = "fixed-partitions", + }; + + static int parse_ofoldpart_partitions(struct mtd_info *master, +@@ -229,4 +229,5 @@ MODULE_AUTHOR("Vitaly Wool, David Gibson + * with the same name. Since we provide the ofoldpart parser, we should have + * the corresponding alias. + */ ++MODULE_ALIAS("fixed-partitions"); + MODULE_ALIAS("ofoldpart"); diff --git a/target/linux/generic/pending-4.14/160-0003-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch b/target/linux/generic/pending-4.14/160-0003-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch new file mode 100644 index 0000000000..08f048f42a --- /dev/null +++ b/target/linux/generic/pending-4.14/160-0003-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch @@ -0,0 +1,40 @@ +From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= +Date: Thu, 4 Jan 2018 08:05:34 +0100 +Subject: [PATCH V10 3/3] mtd: ofpart: add of_match_table with + "fixed-partitions" +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +This allows using this parser with any flash driver that takes care of +setting of_node (using mtd_set_of_node helper) correctly. Up to now +support for "fixed-partitions" DT compatibility string was working only +with flash drivers that were specifying "ofpart" (manually or by letting +mtd use the default set of parsers). + +This matches existing bindings documentation. + +Signed-off-by: Rafał Miłecki +Reviewed-by: Brian Norris +Tested-by: Brian Norris +--- + +--- a/drivers/mtd/ofpart.c ++++ b/drivers/mtd/ofpart.c +@@ -140,9 +140,16 @@ ofpart_none: + return ret; + } + ++static const struct of_device_id parse_ofpart_match_table[] = { ++ { .compatible = "fixed-partitions" }, ++ {}, ++}; ++MODULE_DEVICE_TABLE(of, parse_ofpart_match_table); ++ + static struct mtd_part_parser ofpart_parser = { + .parse_fn = parse_fixed_partitions, + .name = "fixed-partitions", ++ .of_match_table = parse_ofpart_match_table, + }; + + static int parse_ofoldpart_partitions(struct mtd_info *master, diff --git a/target/linux/generic/pending-4.14/160-mtd-part-add-generic-parsing-of-linux-part-probe.patch b/target/linux/generic/pending-4.14/160-mtd-part-add-generic-parsing-of-linux-part-probe.patch deleted file mode 100644 index e57214ba05..0000000000 --- a/target/linux/generic/pending-4.14/160-mtd-part-add-generic-parsing-of-linux-part-probe.patch +++ /dev/null @@ -1,161 +0,0 @@ -From: Hauke Mehrtens -Subject: mtd: part: add generic parsing of linux,part-probe - -This moves the linux,part-probe device tree parsing code from -physmap_of.c to mtdpart.c. Now all drivers can use this feature by just -providing a reference to their device tree node in struct -mtd_part_parser_data. - -Signed-off-by: Hauke Mehrtens ---- - Documentation/devicetree/bindings/mtd/nand.txt | 16 +++++++++ - drivers/mtd/maps/physmap_of.c | 46 +------------------------- - drivers/mtd/mtdpart.c | 45 +++++++++++++++++++++++++ - 3 files changed, 62 insertions(+), 45 deletions(-) - ---- a/Documentation/devicetree/bindings/mtd/nand.txt -+++ b/Documentation/devicetree/bindings/mtd/nand.txt -@@ -44,6 +44,22 @@ Optional NAND chip properties: - used by the upper layers, and you want to make your NAND - as reliable as possible. - -+- linux,part-probe: list of name as strings of the partition parser -+ which should be used to parse the partition table. -+ They will be tried in the specified ordering and -+ the next one will be used if the previous one -+ failed. -+ -+ Example: linux,part-probe = "cmdlinepart", "ofpart"; -+ -+ This is also the default value, which will be used -+ if this attribute is not specified. It could be -+ that the flash driver in use overwrote the default -+ value and uses some other default. -+ -+ Possible values are: bcm47xxpart, afs, ar7part, -+ ofoldpart, ofpart, bcm63xxpart, RedBoot, cmdlinepart -+ - The ECC strength and ECC step size properties define the correction capability - of a controller. Together, they say a controller can correct "{strength} bit - errors per {size} bytes". ---- a/drivers/mtd/maps/physmap_of_core.c -+++ b/drivers/mtd/maps/physmap_of_core.c -@@ -114,37 +114,9 @@ static struct mtd_info *obsolete_probe(s - static const char * const part_probe_types_def[] = { - "cmdlinepart", "RedBoot", "ofpart", "ofoldpart", NULL }; - --static const char * const *of_get_probes(struct device_node *dp) --{ -- const char **res; -- int count; -- -- count = of_property_count_strings(dp, "linux,part-probe"); -- if (count < 0) -- return part_probe_types_def; -- -- res = kzalloc((count + 1) * sizeof(*res), GFP_KERNEL); -- if (!res) -- return NULL; -- -- count = of_property_read_string_array(dp, "linux,part-probe", res, -- count); -- if (count < 0) -- return NULL; -- -- return res; --} -- --static void of_free_probes(const char * const *probes) --{ -- if (probes != part_probe_types_def) -- kfree(probes); --} -- - static const struct of_device_id of_flash_match[]; - static int of_flash_probe(struct platform_device *dev) - { -- const char * const *part_probe_types; - const struct of_device_id *match; - struct device_node *dp = dev->dev.of_node; - struct resource res; -@@ -310,14 +282,8 @@ static int of_flash_probe(struct platfor - - info->cmtd->dev.parent = &dev->dev; - mtd_set_of_node(info->cmtd, dp); -- part_probe_types = of_get_probes(dp); -- if (!part_probe_types) { -- err = -ENOMEM; -- goto err_out; -- } -- mtd_device_parse_register(info->cmtd, part_probe_types, NULL, -+ mtd_device_parse_register(info->cmtd, part_probe_types_def, NULL, - NULL, 0); -- of_free_probes(part_probe_types); - - kfree(mtd_list); - ---- a/drivers/mtd/mtdpart.c -+++ b/drivers/mtd/mtdpart.c -@@ -29,6 +29,7 @@ - #include - #include - #include -+#include - #include - #include - -@@ -864,6 +865,32 @@ void deregister_mtd_parser(struct mtd_pa - EXPORT_SYMBOL_GPL(deregister_mtd_parser); - - /* -+ * Parses the linux,part-probe device tree property. -+ * When a non null value is returned it has to be freed with kfree() by -+ * the caller. -+ */ -+static const char * const *of_get_probes(struct device_node *dp) -+{ -+ const char **res; -+ int count; -+ -+ count = of_property_count_strings(dp, "linux,part-probe"); -+ if (count < 0) -+ return NULL; -+ -+ res = kzalloc((count + 1) * sizeof(*res), GFP_KERNEL); -+ if (!res) -+ return NULL; -+ -+ count = of_property_read_string_array(dp, "linux,part-probe", res, -+ count); -+ if (count < 0) -+ return NULL; -+ -+ return res; -+} -+ -+/* - * Do not forget to update 'parse_mtd_partitions()' kerneldoc comment if you - * are changing this array! - */ -@@ -963,6 +990,13 @@ int parse_mtd_partitions(struct mtd_info - struct property *prop; - const char *compat; - int ret, err = 0; -+ const char *const *types_of = NULL; -+ -+ if (mtd_get_of_node(master)) { -+ types_of = of_get_probes(mtd_get_of_node(master)); -+ if (types_of != NULL) -+ types = types_of; -+ } - - np = of_get_child_by_name(mtd_get_of_node(master), "partitions"); - of_property_for_each_string(np, "compatible", prop, compat) { -@@ -1004,6 +1038,7 @@ int parse_mtd_partitions(struct mtd_info - if (ret < 0 && !err) - err = ret; - } -+ kfree(types_of); - return err; - } - diff --git a/target/linux/generic/pending-4.14/161-mtd-part-add-generic-parsing-of-linux-part-probe.patch b/target/linux/generic/pending-4.14/161-mtd-part-add-generic-parsing-of-linux-part-probe.patch new file mode 100644 index 0000000000..6379ff33fd --- /dev/null +++ b/target/linux/generic/pending-4.14/161-mtd-part-add-generic-parsing-of-linux-part-probe.patch @@ -0,0 +1,161 @@ +From: Hauke Mehrtens +Subject: mtd: part: add generic parsing of linux,part-probe + +This moves the linux,part-probe device tree parsing code from +physmap_of.c to mtdpart.c. Now all drivers can use this feature by just +providing a reference to their device tree node in struct +mtd_part_parser_data. + +Signed-off-by: Hauke Mehrtens +--- + Documentation/devicetree/bindings/mtd/nand.txt | 16 +++++++++ + drivers/mtd/maps/physmap_of.c | 46 +------------------------- + drivers/mtd/mtdpart.c | 45 +++++++++++++++++++++++++ + 3 files changed, 62 insertions(+), 45 deletions(-) + +--- a/Documentation/devicetree/bindings/mtd/nand.txt ++++ b/Documentation/devicetree/bindings/mtd/nand.txt +@@ -44,6 +44,22 @@ Optional NAND chip properties: + used by the upper layers, and you want to make your NAND + as reliable as possible. + ++- linux,part-probe: list of name as strings of the partition parser ++ which should be used to parse the partition table. ++ They will be tried in the specified ordering and ++ the next one will be used if the previous one ++ failed. ++ ++ Example: linux,part-probe = "cmdlinepart", "ofpart"; ++ ++ This is also the default value, which will be used ++ if this attribute is not specified. It could be ++ that the flash driver in use overwrote the default ++ value and uses some other default. ++ ++ Possible values are: bcm47xxpart, afs, ar7part, ++ ofoldpart, ofpart, bcm63xxpart, RedBoot, cmdlinepart ++ + The ECC strength and ECC step size properties define the correction capability + of a controller. Together, they say a controller can correct "{strength} bit + errors per {size} bytes". +--- a/drivers/mtd/maps/physmap_of_core.c ++++ b/drivers/mtd/maps/physmap_of_core.c +@@ -114,37 +114,9 @@ static struct mtd_info *obsolete_probe(s + static const char * const part_probe_types_def[] = { + "cmdlinepart", "RedBoot", "ofpart", "ofoldpart", NULL }; + +-static const char * const *of_get_probes(struct device_node *dp) +-{ +- const char **res; +- int count; +- +- count = of_property_count_strings(dp, "linux,part-probe"); +- if (count < 0) +- return part_probe_types_def; +- +- res = kzalloc((count + 1) * sizeof(*res), GFP_KERNEL); +- if (!res) +- return NULL; +- +- count = of_property_read_string_array(dp, "linux,part-probe", res, +- count); +- if (count < 0) +- return NULL; +- +- return res; +-} +- +-static void of_free_probes(const char * const *probes) +-{ +- if (probes != part_probe_types_def) +- kfree(probes); +-} +- + static const struct of_device_id of_flash_match[]; + static int of_flash_probe(struct platform_device *dev) + { +- const char * const *part_probe_types; + const struct of_device_id *match; + struct device_node *dp = dev->dev.of_node; + struct resource res; +@@ -310,14 +282,8 @@ static int of_flash_probe(struct platfor + + info->cmtd->dev.parent = &dev->dev; + mtd_set_of_node(info->cmtd, dp); +- part_probe_types = of_get_probes(dp); +- if (!part_probe_types) { +- err = -ENOMEM; +- goto err_out; +- } +- mtd_device_parse_register(info->cmtd, part_probe_types, NULL, ++ mtd_device_parse_register(info->cmtd, part_probe_types_def, NULL, + NULL, 0); +- of_free_probes(part_probe_types); + + kfree(mtd_list); + +--- a/drivers/mtd/mtdpart.c ++++ b/drivers/mtd/mtdpart.c +@@ -29,6 +29,7 @@ + #include + #include + #include ++#include + #include + #include + +@@ -864,6 +865,32 @@ void deregister_mtd_parser(struct mtd_pa + EXPORT_SYMBOL_GPL(deregister_mtd_parser); + + /* ++ * Parses the linux,part-probe device tree property. ++ * When a non null value is returned it has to be freed with kfree() by ++ * the caller. ++ */ ++static const char * const *of_get_probes(struct device_node *dp) ++{ ++ const char **res; ++ int count; ++ ++ count = of_property_count_strings(dp, "linux,part-probe"); ++ if (count < 0) ++ return NULL; ++ ++ res = kzalloc((count + 1) * sizeof(*res), GFP_KERNEL); ++ if (!res) ++ return NULL; ++ ++ count = of_property_read_string_array(dp, "linux,part-probe", res, ++ count); ++ if (count < 0) ++ return NULL; ++ ++ return res; ++} ++ ++/* + * Do not forget to update 'parse_mtd_partitions()' kerneldoc comment if you + * are changing this array! + */ +@@ -1007,6 +1034,13 @@ int parse_mtd_partitions(struct mtd_info + { + struct mtd_part_parser *parser; + int ret, err = 0; ++ const char *const *types_of = NULL; ++ ++ if (mtd_get_of_node(master)) { ++ types_of = of_get_probes(mtd_get_of_node(master)); ++ if (types_of != NULL) ++ types = types_of; ++ } + + if (!types) + types = default_mtd_part_types; +@@ -1043,6 +1077,7 @@ int parse_mtd_partitions(struct mtd_info + if (ret < 0 && !err) + err = ret; + } ++ kfree(types_of); + return err; + } + diff --git a/target/linux/generic/pending-4.14/401-mtd-add-support-for-different-partition-parser-types.patch b/target/linux/generic/pending-4.14/401-mtd-add-support-for-different-partition-parser-types.patch index 7481225be8..182d8d4741 100644 --- a/target/linux/generic/pending-4.14/401-mtd-add-support-for-different-partition-parser-types.patch +++ b/target/linux/generic/pending-4.14/401-mtd-add-support-for-different-partition-parser-types.patch @@ -9,7 +9,7 @@ Signed-off-by: Gabor Juhos --- a/drivers/mtd/mtdpart.c +++ b/drivers/mtd/mtdpart.c -@@ -1093,6 +1093,62 @@ void mtd_part_parser_cleanup(struct mtd_ +@@ -1132,6 +1132,62 @@ void mtd_part_parser_cleanup(struct mtd_ } } diff --git a/target/linux/generic/pending-4.14/404-mtd-add-more-helper-functions.patch b/target/linux/generic/pending-4.14/404-mtd-add-more-helper-functions.patch index a4fb155863..9b2fcac93d 100644 --- a/target/linux/generic/pending-4.14/404-mtd-add-more-helper-functions.patch +++ b/target/linux/generic/pending-4.14/404-mtd-add-more-helper-functions.patch @@ -29,7 +29,7 @@ Signed-off-by: Gabor Juhos #ifdef CONFIG_MTD_SPLIT_FIRMWARE_NAME #define SPLIT_FIRMWARE_NAME CONFIG_MTD_SPLIT_FIRMWARE_NAME #else -@@ -1203,6 +1214,24 @@ int mtd_is_partition(const struct mtd_in +@@ -1242,6 +1253,24 @@ int mtd_is_partition(const struct mtd_in } EXPORT_SYMBOL_GPL(mtd_is_partition); diff --git a/target/linux/generic/pending-4.9/160-0001-mtd-partitions-add-of_match_table-parser-matching-fo.patch b/target/linux/generic/pending-4.9/160-0001-mtd-partitions-add-of_match_table-parser-matching-fo.patch new file mode 100644 index 0000000000..3a0115d521 --- /dev/null +++ b/target/linux/generic/pending-4.9/160-0001-mtd-partitions-add-of_match_table-parser-matching-fo.patch @@ -0,0 +1,194 @@ +From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= +Date: Tue, 30 Jan 2018 11:55:16 +0100 +Subject: [PATCH V10 1/3] mtd: partitions: add of_match_table parser matching + for the "ofpart" type +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +In order to properly support compatibility strings as described in the +bindings/mtd/partition.txt "ofpart" type should be treated as an +indication for looking into OF. MTD should check "compatible" property +and search for a matching parser rather than blindly trying the one +supporting "fixed-partitions". + +It also means that existing "fixed-partitions" parser should get renamed +to use a more meaningful name. + +This commit achievies that aim by introducing a new mtd_part_of_parse(). +It works by looking for a matching parser for every string in the +"compatibility" property (starting with the most specific one). + +Please note that driver-specified parsers still take a precedence. It's +assumed that driver providing a parser type has a good reason for that +(e.g. having platform data with device-specific info). Also doing +otherwise could break existing setups. The same applies to using default +parsers (including "cmdlinepart") as some overwrite DT data with cmdline +argument. + +Partition parsers can now provide an of_match_table to enable +flash<-->parser matching via device tree as documented in the +mtd/partition.txt. + +This support is currently limited to built-in parsers as it uses +request_module() and friends. This should be sufficient for most cases +though as compiling parsers as modules isn't a common choice. + +Signed-off-by: Brian Norris +Signed-off-by: Rafał Miłecki +Tested-by: Peter Rosin +--- + +--- a/drivers/mtd/mtdpart.c ++++ b/drivers/mtd/mtdpart.c +@@ -30,6 +30,7 @@ + #include + #include + #include ++#include + + #include "mtdcore.h" + +@@ -886,6 +887,92 @@ static int mtd_part_do_parse(struct mtd_ + } + + /** ++ * mtd_part_get_compatible_parser - find MTD parser by a compatible string ++ * ++ * @compat: compatible string describing partitions in a device tree ++ * ++ * MTD parsers can specify supported partitions by providing a table of ++ * compatibility strings. This function finds a parser that advertises support ++ * for a passed value of "compatible". ++ */ ++static struct mtd_part_parser *mtd_part_get_compatible_parser(const char *compat) ++{ ++ struct mtd_part_parser *p, *ret = NULL; ++ ++ spin_lock(&part_parser_lock); ++ ++ list_for_each_entry(p, &part_parsers, list) { ++ const struct of_device_id *matches; ++ ++ matches = p->of_match_table; ++ if (!matches) ++ continue; ++ ++ for (; matches->compatible[0]; matches++) { ++ if (!strcmp(matches->compatible, compat) && ++ try_module_get(p->owner)) { ++ ret = p; ++ break; ++ } ++ } ++ ++ if (ret) ++ break; ++ } ++ ++ spin_unlock(&part_parser_lock); ++ ++ return ret; ++} ++ ++static int mtd_part_of_parse(struct mtd_info *master, ++ struct mtd_partitions *pparts) ++{ ++ struct mtd_part_parser *parser; ++ struct device_node *np; ++ struct property *prop; ++ const char *compat; ++ const char *fixed = "ofpart"; ++ int ret, err = 0; ++ ++ np = of_get_child_by_name(mtd_get_of_node(master), "partitions"); ++ of_property_for_each_string(np, "compatible", prop, compat) { ++ parser = mtd_part_get_compatible_parser(compat); ++ if (!parser) ++ continue; ++ ret = mtd_part_do_parse(parser, master, pparts, NULL); ++ if (ret > 0) { ++ of_node_put(np); ++ return ret; ++ } ++ mtd_part_parser_put(parser); ++ if (ret < 0 && !err) ++ err = ret; ++ } ++ of_node_put(np); ++ ++ /* ++ * For backward compatibility we have to try the "ofpart" ++ * parser. It supports old DT format with partitions specified as a ++ * direct subnodes of a flash device DT node without any compatibility ++ * specified we could match. ++ */ ++ parser = mtd_part_parser_get(fixed); ++ if (!parser && !request_module("%s", fixed)) ++ parser = mtd_part_parser_get(fixed); ++ if (parser) { ++ ret = mtd_part_do_parse(parser, master, pparts, NULL); ++ if (ret > 0) ++ return ret; ++ mtd_part_parser_put(parser); ++ if (ret < 0 && !err) ++ err = ret; ++ } ++ ++ return err; ++} ++ ++/** + * parse_mtd_partitions - parse MTD partitions + * @master: the master partition (describes whole MTD device) + * @types: names of partition parsers to try or %NULL +@@ -917,19 +1004,30 @@ int parse_mtd_partitions(struct mtd_info + types = default_mtd_part_types; + + for ( ; *types; types++) { +- pr_debug("%s: parsing partitions %s\n", master->name, *types); +- parser = mtd_part_parser_get(*types); +- if (!parser && !request_module("%s", *types)) ++ /* ++ * ofpart is a special type that means OF partitioning info ++ * should be used. It requires a bit different logic so it is ++ * handled in a separated function. ++ */ ++ if (!strcmp(*types, "ofpart")) { ++ ret = mtd_part_of_parse(master, pparts); ++ } else { ++ pr_debug("%s: parsing partitions %s\n", master->name, ++ *types); + parser = mtd_part_parser_get(*types); +- pr_debug("%s: got parser %s\n", master->name, +- parser ? parser->name : NULL); +- if (!parser) +- continue; +- ret = mtd_part_do_parse(parser, master, pparts, data); ++ if (!parser && !request_module("%s", *types)) ++ parser = mtd_part_parser_get(*types); ++ pr_debug("%s: got parser %s\n", master->name, ++ parser ? parser->name : NULL); ++ if (!parser) ++ continue; ++ ret = mtd_part_do_parse(parser, master, pparts, data); ++ if (ret <= 0) ++ mtd_part_parser_put(parser); ++ } + /* Found partitions! */ + if (ret > 0) + return 0; +- mtd_part_parser_put(parser); + /* + * Stash the first error we see; only report it if no parser + * succeeds +--- a/include/linux/mtd/partitions.h ++++ b/include/linux/mtd/partitions.h +@@ -77,6 +77,7 @@ struct mtd_part_parser { + struct list_head list; + struct module *owner; + const char *name; ++ const struct of_device_id *of_match_table; + int (*parse_fn)(struct mtd_info *, const struct mtd_partition **, + struct mtd_part_parser_data *); + void (*cleanup)(const struct mtd_partition *pparts, int nr_parts); diff --git a/target/linux/generic/pending-4.9/160-0002-mtd-rename-ofpart-parser-to-fixed-partitions-as-it-f.patch b/target/linux/generic/pending-4.9/160-0002-mtd-rename-ofpart-parser-to-fixed-partitions-as-it-f.patch new file mode 100644 index 0000000000..7b17b55bf5 --- /dev/null +++ b/target/linux/generic/pending-4.9/160-0002-mtd-rename-ofpart-parser-to-fixed-partitions-as-it-f.patch @@ -0,0 +1,68 @@ +From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= +Date: Tue, 30 Jan 2018 12:09:58 +0100 +Subject: [PATCH V10 2/3] mtd: rename "ofpart" parser to "fixed-partitions" as + it fits it better +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Type "ofpart" means that OF should be used to get partitioning info and +this driver supports "fixed-partitions" binding only. Renaming it should +lead to less confusion especially when parsers for new compatibility +strings start to appear. + +Signed-off-by: Rafał Miłecki +--- + +--- a/drivers/mtd/mtdpart.c ++++ b/drivers/mtd/mtdpart.c +@@ -932,7 +932,7 @@ static int mtd_part_of_parse(struct mtd_ + struct device_node *np; + struct property *prop; + const char *compat; +- const char *fixed = "ofpart"; ++ const char *fixed = "fixed-partitions"; + int ret, err = 0; + + np = of_get_child_by_name(mtd_get_of_node(master), "partitions"); +@@ -952,7 +952,7 @@ static int mtd_part_of_parse(struct mtd_ + of_node_put(np); + + /* +- * For backward compatibility we have to try the "ofpart" ++ * For backward compatibility we have to try the "fixed-partitions" + * parser. It supports old DT format with partitions specified as a + * direct subnodes of a flash device DT node without any compatibility + * specified we could match. +--- a/drivers/mtd/ofpart.c ++++ b/drivers/mtd/ofpart.c +@@ -25,9 +25,9 @@ static bool node_has_compatible(struct d + return of_get_property(pp, "compatible", NULL); + } + +-static int parse_ofpart_partitions(struct mtd_info *master, +- const struct mtd_partition **pparts, +- struct mtd_part_parser_data *data) ++static int parse_fixed_partitions(struct mtd_info *master, ++ const struct mtd_partition **pparts, ++ struct mtd_part_parser_data *data) + { + struct mtd_partition *parts; + struct device_node *mtd_node; +@@ -141,8 +141,8 @@ ofpart_none: + } + + static struct mtd_part_parser ofpart_parser = { +- .parse_fn = parse_ofpart_partitions, +- .name = "ofpart", ++ .parse_fn = parse_fixed_partitions, ++ .name = "fixed-partitions", + }; + + static int parse_ofoldpart_partitions(struct mtd_info *master, +@@ -230,4 +230,5 @@ MODULE_AUTHOR("Vitaly Wool, David Gibson + * with the same name. Since we provide the ofoldpart parser, we should have + * the corresponding alias. + */ ++MODULE_ALIAS("fixed-partitions"); + MODULE_ALIAS("ofoldpart"); diff --git a/target/linux/generic/pending-4.9/160-0003-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch b/target/linux/generic/pending-4.9/160-0003-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch new file mode 100644 index 0000000000..08f048f42a --- /dev/null +++ b/target/linux/generic/pending-4.9/160-0003-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch @@ -0,0 +1,40 @@ +From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= +Date: Thu, 4 Jan 2018 08:05:34 +0100 +Subject: [PATCH V10 3/3] mtd: ofpart: add of_match_table with + "fixed-partitions" +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +This allows using this parser with any flash driver that takes care of +setting of_node (using mtd_set_of_node helper) correctly. Up to now +support for "fixed-partitions" DT compatibility string was working only +with flash drivers that were specifying "ofpart" (manually or by letting +mtd use the default set of parsers). + +This matches existing bindings documentation. + +Signed-off-by: Rafał Miłecki +Reviewed-by: Brian Norris +Tested-by: Brian Norris +--- + +--- a/drivers/mtd/ofpart.c ++++ b/drivers/mtd/ofpart.c +@@ -140,9 +140,16 @@ ofpart_none: + return ret; + } + ++static const struct of_device_id parse_ofpart_match_table[] = { ++ { .compatible = "fixed-partitions" }, ++ {}, ++}; ++MODULE_DEVICE_TABLE(of, parse_ofpart_match_table); ++ + static struct mtd_part_parser ofpart_parser = { + .parse_fn = parse_fixed_partitions, + .name = "fixed-partitions", ++ .of_match_table = parse_ofpart_match_table, + }; + + static int parse_ofoldpart_partitions(struct mtd_info *master, diff --git a/target/linux/generic/pending-4.9/160-mtd-part-add-generic-parsing-of-linux-part-probe.patch b/target/linux/generic/pending-4.9/160-mtd-part-add-generic-parsing-of-linux-part-probe.patch deleted file mode 100644 index 6c2e2602e1..0000000000 --- a/target/linux/generic/pending-4.9/160-mtd-part-add-generic-parsing-of-linux-part-probe.patch +++ /dev/null @@ -1,181 +0,0 @@ -From: Hauke Mehrtens -Subject: mtd: part: add generic parsing of linux,part-probe - -This moves the linux,part-probe device tree parsing code from -physmap_of.c to mtdpart.c. Now all drivers can use this feature by just -providing a reference to their device tree node in struct -mtd_part_parser_data. - -Signed-off-by: Hauke Mehrtens ---- - Documentation/devicetree/bindings/mtd/nand.txt | 16 +++++++++ - drivers/mtd/maps/physmap_of.c | 46 +------------------------- - drivers/mtd/mtdpart.c | 45 +++++++++++++++++++++++++ - 3 files changed, 62 insertions(+), 45 deletions(-) - ---- a/Documentation/devicetree/bindings/mtd/nand.txt -+++ b/Documentation/devicetree/bindings/mtd/nand.txt -@@ -44,6 +44,22 @@ Optional NAND chip properties: - used by the upper layers, and you want to make your NAND - as reliable as possible. - -+- linux,part-probe: list of name as strings of the partition parser -+ which should be used to parse the partition table. -+ They will be tried in the specified ordering and -+ the next one will be used if the previous one -+ failed. -+ -+ Example: linux,part-probe = "cmdlinepart", "ofpart"; -+ -+ This is also the default value, which will be used -+ if this attribute is not specified. It could be -+ that the flash driver in use overwrote the default -+ value and uses some other default. -+ -+ Possible values are: bcm47xxpart, afs, ar7part, -+ ofoldpart, ofpart, bcm63xxpart, RedBoot, cmdlinepart -+ - The ECC strength and ECC step size properties define the correction capability - of a controller. Together, they say a controller can correct "{strength} bit - errors per {size} bytes". ---- a/drivers/mtd/maps/physmap_of.c -+++ b/drivers/mtd/maps/physmap_of.c -@@ -113,47 +113,9 @@ static struct mtd_info *obsolete_probe(s - static const char * const part_probe_types_def[] = { - "cmdlinepart", "RedBoot", "ofpart", "ofoldpart", NULL }; - --static const char * const *of_get_probes(struct device_node *dp) --{ -- const char *cp; -- int cplen; -- unsigned int l; -- unsigned int count; -- const char **res; -- -- cp = of_get_property(dp, "linux,part-probe", &cplen); -- if (cp == NULL) -- return part_probe_types_def; -- -- count = 0; -- for (l = 0; l != cplen; l++) -- if (cp[l] == 0) -- count++; -- -- res = kzalloc((count + 1)*sizeof(*res), GFP_KERNEL); -- if (!res) -- return NULL; -- count = 0; -- while (cplen > 0) { -- res[count] = cp; -- l = strlen(cp) + 1; -- cp += l; -- cplen -= l; -- count++; -- } -- return res; --} -- --static void of_free_probes(const char * const *probes) --{ -- if (probes != part_probe_types_def) -- kfree(probes); --} -- - static const struct of_device_id of_flash_match[]; - static int of_flash_probe(struct platform_device *dev) - { -- const char * const *part_probe_types; - const struct of_device_id *match; - struct device_node *dp = dev->dev.of_node; - struct resource res; -@@ -317,14 +279,8 @@ static int of_flash_probe(struct platfor - - info->cmtd->dev.parent = &dev->dev; - mtd_set_of_node(info->cmtd, dp); -- part_probe_types = of_get_probes(dp); -- if (!part_probe_types) { -- err = -ENOMEM; -- goto err_out; -- } -- mtd_device_parse_register(info->cmtd, part_probe_types, NULL, -+ mtd_device_parse_register(info->cmtd, part_probe_types_def, NULL, - NULL, 0); -- of_free_probes(part_probe_types); - - kfree(mtd_list); - ---- a/drivers/mtd/mtdpart.c -+++ b/drivers/mtd/mtdpart.c -@@ -29,6 +29,7 @@ - #include - #include - #include -+#include - #include - #include - -@@ -856,6 +857,42 @@ void deregister_mtd_parser(struct mtd_pa - EXPORT_SYMBOL_GPL(deregister_mtd_parser); - - /* -+ * Parses the linux,part-probe device tree property. -+ * When a non null value is returned it has to be freed with kfree() by -+ * the caller. -+ */ -+static const char * const *of_get_probes(struct device_node *dp) -+{ -+ const char *cp; -+ int cplen; -+ unsigned int l; -+ unsigned int count; -+ const char **res; -+ -+ cp = of_get_property(dp, "linux,part-probe", &cplen); -+ if (cp == NULL) -+ return NULL; -+ -+ count = 0; -+ for (l = 0; l != cplen; l++) -+ if (cp[l] == 0) -+ count++; -+ -+ res = kzalloc((count + 1) * sizeof(*res), GFP_KERNEL); -+ if (!res) -+ return NULL; -+ count = 0; -+ while (cplen > 0) { -+ res[count] = cp; -+ l = strlen(cp) + 1; -+ cp += l; -+ cplen -= l; -+ count++; -+ } -+ return res; -+} -+ -+/* - * Do not forget to update 'parse_mtd_partitions()' kerneldoc comment if you - * are changing this array! - */ -@@ -955,6 +992,13 @@ int parse_mtd_partitions(struct mtd_info - struct property *prop; - const char *compat; - int ret, err = 0; -+ const char *const *types_of = NULL; -+ -+ if (mtd_get_of_node(master)) { -+ types_of = of_get_probes(mtd_get_of_node(master)); -+ if (types_of != NULL) -+ types = types_of; -+ } - - np = of_get_child_by_name(mtd_get_of_node(master), "partitions"); - of_property_for_each_string(np, "compatible", prop, compat) { -@@ -996,6 +1040,7 @@ int parse_mtd_partitions(struct mtd_info - if (ret < 0 && !err) - err = ret; - } -+ kfree(types_of); - return err; - } - diff --git a/target/linux/generic/pending-4.9/161-mtd-part-add-generic-parsing-of-linux-part-probe.patch b/target/linux/generic/pending-4.9/161-mtd-part-add-generic-parsing-of-linux-part-probe.patch new file mode 100644 index 0000000000..5f0fa3a418 --- /dev/null +++ b/target/linux/generic/pending-4.9/161-mtd-part-add-generic-parsing-of-linux-part-probe.patch @@ -0,0 +1,181 @@ +From: Hauke Mehrtens +Subject: mtd: part: add generic parsing of linux,part-probe + +This moves the linux,part-probe device tree parsing code from +physmap_of.c to mtdpart.c. Now all drivers can use this feature by just +providing a reference to their device tree node in struct +mtd_part_parser_data. + +Signed-off-by: Hauke Mehrtens +--- + Documentation/devicetree/bindings/mtd/nand.txt | 16 +++++++++ + drivers/mtd/maps/physmap_of.c | 46 +------------------------- + drivers/mtd/mtdpart.c | 45 +++++++++++++++++++++++++ + 3 files changed, 62 insertions(+), 45 deletions(-) + +--- a/Documentation/devicetree/bindings/mtd/nand.txt ++++ b/Documentation/devicetree/bindings/mtd/nand.txt +@@ -44,6 +44,22 @@ Optional NAND chip properties: + used by the upper layers, and you want to make your NAND + as reliable as possible. + ++- linux,part-probe: list of name as strings of the partition parser ++ which should be used to parse the partition table. ++ They will be tried in the specified ordering and ++ the next one will be used if the previous one ++ failed. ++ ++ Example: linux,part-probe = "cmdlinepart", "ofpart"; ++ ++ This is also the default value, which will be used ++ if this attribute is not specified. It could be ++ that the flash driver in use overwrote the default ++ value and uses some other default. ++ ++ Possible values are: bcm47xxpart, afs, ar7part, ++ ofoldpart, ofpart, bcm63xxpart, RedBoot, cmdlinepart ++ + The ECC strength and ECC step size properties define the correction capability + of a controller. Together, they say a controller can correct "{strength} bit + errors per {size} bytes". +--- a/drivers/mtd/maps/physmap_of.c ++++ b/drivers/mtd/maps/physmap_of.c +@@ -113,47 +113,9 @@ static struct mtd_info *obsolete_probe(s + static const char * const part_probe_types_def[] = { + "cmdlinepart", "RedBoot", "ofpart", "ofoldpart", NULL }; + +-static const char * const *of_get_probes(struct device_node *dp) +-{ +- const char *cp; +- int cplen; +- unsigned int l; +- unsigned int count; +- const char **res; +- +- cp = of_get_property(dp, "linux,part-probe", &cplen); +- if (cp == NULL) +- return part_probe_types_def; +- +- count = 0; +- for (l = 0; l != cplen; l++) +- if (cp[l] == 0) +- count++; +- +- res = kzalloc((count + 1)*sizeof(*res), GFP_KERNEL); +- if (!res) +- return NULL; +- count = 0; +- while (cplen > 0) { +- res[count] = cp; +- l = strlen(cp) + 1; +- cp += l; +- cplen -= l; +- count++; +- } +- return res; +-} +- +-static void of_free_probes(const char * const *probes) +-{ +- if (probes != part_probe_types_def) +- kfree(probes); +-} +- + static const struct of_device_id of_flash_match[]; + static int of_flash_probe(struct platform_device *dev) + { +- const char * const *part_probe_types; + const struct of_device_id *match; + struct device_node *dp = dev->dev.of_node; + struct resource res; +@@ -317,14 +279,8 @@ static int of_flash_probe(struct platfor + + info->cmtd->dev.parent = &dev->dev; + mtd_set_of_node(info->cmtd, dp); +- part_probe_types = of_get_probes(dp); +- if (!part_probe_types) { +- err = -ENOMEM; +- goto err_out; +- } +- mtd_device_parse_register(info->cmtd, part_probe_types, NULL, ++ mtd_device_parse_register(info->cmtd, part_probe_types_def, NULL, + NULL, 0); +- of_free_probes(part_probe_types); + + kfree(mtd_list); + +--- a/drivers/mtd/mtdpart.c ++++ b/drivers/mtd/mtdpart.c +@@ -29,6 +29,7 @@ + #include + #include + #include ++#include + #include + #include + +@@ -856,6 +857,42 @@ void deregister_mtd_parser(struct mtd_pa + EXPORT_SYMBOL_GPL(deregister_mtd_parser); + + /* ++ * Parses the linux,part-probe device tree property. ++ * When a non null value is returned it has to be freed with kfree() by ++ * the caller. ++ */ ++static const char * const *of_get_probes(struct device_node *dp) ++{ ++ const char *cp; ++ int cplen; ++ unsigned int l; ++ unsigned int count; ++ const char **res; ++ ++ cp = of_get_property(dp, "linux,part-probe", &cplen); ++ if (cp == NULL) ++ return NULL; ++ ++ count = 0; ++ for (l = 0; l != cplen; l++) ++ if (cp[l] == 0) ++ count++; ++ ++ res = kzalloc((count + 1) * sizeof(*res), GFP_KERNEL); ++ if (!res) ++ return NULL; ++ count = 0; ++ while (cplen > 0) { ++ res[count] = cp; ++ l = strlen(cp) + 1; ++ cp += l; ++ cplen -= l; ++ count++; ++ } ++ return res; ++} ++ ++/* + * Do not forget to update 'parse_mtd_partitions()' kerneldoc comment if you + * are changing this array! + */ +@@ -999,6 +1036,13 @@ int parse_mtd_partitions(struct mtd_info + { + struct mtd_part_parser *parser; + int ret, err = 0; ++ const char *const *types_of = NULL; ++ ++ if (mtd_get_of_node(master)) { ++ types_of = of_get_probes(mtd_get_of_node(master)); ++ if (types_of != NULL) ++ types = types_of; ++ } + + if (!types) + types = default_mtd_part_types; +@@ -1035,6 +1079,7 @@ int parse_mtd_partitions(struct mtd_info + if (ret < 0 && !err) + err = ret; + } ++ kfree(types_of); + return err; + } + diff --git a/target/linux/generic/pending-4.9/401-mtd-add-support-for-different-partition-parser-types.patch b/target/linux/generic/pending-4.9/401-mtd-add-support-for-different-partition-parser-types.patch index 66c499d3e7..54cfcb0c36 100644 --- a/target/linux/generic/pending-4.9/401-mtd-add-support-for-different-partition-parser-types.patch +++ b/target/linux/generic/pending-4.9/401-mtd-add-support-for-different-partition-parser-types.patch @@ -9,7 +9,7 @@ Signed-off-by: Gabor Juhos --- a/drivers/mtd/mtdpart.c +++ b/drivers/mtd/mtdpart.c -@@ -1095,6 +1095,62 @@ void mtd_part_parser_cleanup(struct mtd_ +@@ -1134,6 +1134,62 @@ void mtd_part_parser_cleanup(struct mtd_ } } diff --git a/target/linux/generic/pending-4.9/404-mtd-add-more-helper-functions.patch b/target/linux/generic/pending-4.9/404-mtd-add-more-helper-functions.patch index 0ec5540d03..a08f46c317 100644 --- a/target/linux/generic/pending-4.9/404-mtd-add-more-helper-functions.patch +++ b/target/linux/generic/pending-4.9/404-mtd-add-more-helper-functions.patch @@ -29,7 +29,7 @@ Signed-off-by: Gabor Juhos #ifdef CONFIG_MTD_SPLIT_FIRMWARE_NAME #define SPLIT_FIRMWARE_NAME CONFIG_MTD_SPLIT_FIRMWARE_NAME #else -@@ -1205,6 +1216,24 @@ int mtd_is_partition(const struct mtd_in +@@ -1244,6 +1255,24 @@ int mtd_is_partition(const struct mtd_in } EXPORT_SYMBOL_GPL(mtd_is_partition);