From: Rafał Miłecki Date: Mon, 9 Apr 2018 05:14:04 +0000 (+0200) Subject: kernel: use accepted mtd patchset adding support for "compatible" string X-Git-Url: http://git.lede-project.org./?a=commitdiff_plain;h=cdcd5c93d733f6c0d6c2b21b98f5793310b867a2;p=openwrt%2Fstaging%2Fadrian.git kernel: use accepted mtd patchset adding support for "compatible" string These patches were finally accepted and are already present in the Linus's tree. This should be good enough to make is "backport" material. Signed-off-by: Rafał Miłecki --- diff --git a/target/linux/generic/backport-4.14/041-v4.17-0001-mtd-partitions-add-of_match_table-parser-matching-fo.patch b/target/linux/generic/backport-4.14/041-v4.17-0001-mtd-partitions-add-of_match_table-parser-matching-fo.patch new file mode 100644 index 0000000000..bd39a2625e --- /dev/null +++ b/target/linux/generic/backport-4.14/041-v4.17-0001-mtd-partitions-add-of_match_table-parser-matching-fo.patch @@ -0,0 +1,200 @@ +From 5b644aa012f67fd211138a067b9f351f30bdcc60 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= +Date: Wed, 14 Mar 2018 13:10:42 +0100 +Subject: [PATCH] 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 +Reviewed-by: Richard Weinberger +Signed-off-by: Boris Brezillon +--- + drivers/mtd/mtdpart.c | 116 +++++++++++++++++++++++++++++++++++++---- + include/linux/mtd/partitions.h | 1 + + 2 files changed, 108 insertions(+), 9 deletions(-) + +--- 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/backport-4.14/041-v4.17-0002-mtd-rename-ofpart-parser-to-fixed-partitions-as-it-f.patch b/target/linux/generic/backport-4.14/041-v4.17-0002-mtd-rename-ofpart-parser-to-fixed-partitions-as-it-f.patch new file mode 100644 index 0000000000..66b67d7676 --- /dev/null +++ b/target/linux/generic/backport-4.14/041-v4.17-0002-mtd-rename-ofpart-parser-to-fixed-partitions-as-it-f.patch @@ -0,0 +1,74 @@ +From c0faf43482e7f7dfb6d61847cb93d17748560b24 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= +Date: Wed, 14 Mar 2018 13:10:43 +0100 +Subject: [PATCH] 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 +Reviewed-by: Richard Weinberger +Signed-off-by: Boris Brezillon +--- + drivers/mtd/mtdpart.c | 4 ++-- + drivers/mtd/ofpart.c | 11 ++++++----- + 2 files changed, 8 insertions(+), 7 deletions(-) + +--- 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/backport-4.14/041-v4.17-0003-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch b/target/linux/generic/backport-4.14/041-v4.17-0003-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch new file mode 100644 index 0000000000..d6958c3eac --- /dev/null +++ b/target/linux/generic/backport-4.14/041-v4.17-0003-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch @@ -0,0 +1,44 @@ +From 97b0c7c0df3efd7048ed39d7e2dee34cafd55887 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= +Date: Wed, 14 Mar 2018 13:10:44 +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 +Reviewed-by: Richard Weinberger +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_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/backport-4.9/067-v4.17-0001-mtd-partitions-add-of_match_table-parser-matching-fo.patch b/target/linux/generic/backport-4.9/067-v4.17-0001-mtd-partitions-add-of_match_table-parser-matching-fo.patch new file mode 100644 index 0000000000..60eace2a34 --- /dev/null +++ b/target/linux/generic/backport-4.9/067-v4.17-0001-mtd-partitions-add-of_match_table-parser-matching-fo.patch @@ -0,0 +1,200 @@ +From 5b644aa012f67fd211138a067b9f351f30bdcc60 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= +Date: Wed, 14 Mar 2018 13:10:42 +0100 +Subject: [PATCH] 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 +Reviewed-by: Richard Weinberger +Signed-off-by: Boris Brezillon +--- + drivers/mtd/mtdpart.c | 116 +++++++++++++++++++++++++++++++++++++---- + include/linux/mtd/partitions.h | 1 + + 2 files changed, 108 insertions(+), 9 deletions(-) + +--- 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/backport-4.9/067-v4.17-0002-mtd-rename-ofpart-parser-to-fixed-partitions-as-it-f.patch b/target/linux/generic/backport-4.9/067-v4.17-0002-mtd-rename-ofpart-parser-to-fixed-partitions-as-it-f.patch new file mode 100644 index 0000000000..59f53df101 --- /dev/null +++ b/target/linux/generic/backport-4.9/067-v4.17-0002-mtd-rename-ofpart-parser-to-fixed-partitions-as-it-f.patch @@ -0,0 +1,74 @@ +From c0faf43482e7f7dfb6d61847cb93d17748560b24 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= +Date: Wed, 14 Mar 2018 13:10:43 +0100 +Subject: [PATCH] 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 +Reviewed-by: Richard Weinberger +Signed-off-by: Boris Brezillon +--- + drivers/mtd/mtdpart.c | 4 ++-- + drivers/mtd/ofpart.c | 11 ++++++----- + 2 files changed, 8 insertions(+), 7 deletions(-) + +--- 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/backport-4.9/067-v4.17-0003-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch b/target/linux/generic/backport-4.9/067-v4.17-0003-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch new file mode 100644 index 0000000000..d6958c3eac --- /dev/null +++ b/target/linux/generic/backport-4.9/067-v4.17-0003-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch @@ -0,0 +1,44 @@ +From 97b0c7c0df3efd7048ed39d7e2dee34cafd55887 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= +Date: Wed, 14 Mar 2018 13:10:44 +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 +Reviewed-by: Richard Weinberger +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_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-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 deleted file mode 100644 index 3334203d8a..0000000000 --- a/target/linux/generic/pending-4.14/160-0001-mtd-partitions-add-of_match_table-parser-matching-fo.patch +++ /dev/null @@ -1,194 +0,0 @@ -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 deleted file mode 100644 index c380655635..0000000000 --- a/target/linux/generic/pending-4.14/160-0002-mtd-rename-ofpart-parser-to-fixed-partitions-as-it-f.patch +++ /dev/null @@ -1,68 +0,0 @@ -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 deleted file mode 100644 index 08f048f42a..0000000000 --- a/target/linux/generic/pending-4.14/160-0003-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch +++ /dev/null @@ -1,40 +0,0 @@ -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-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 deleted file mode 100644 index 3a0115d521..0000000000 --- a/target/linux/generic/pending-4.9/160-0001-mtd-partitions-add-of_match_table-parser-matching-fo.patch +++ /dev/null @@ -1,194 +0,0 @@ -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 deleted file mode 100644 index 7b17b55bf5..0000000000 --- a/target/linux/generic/pending-4.9/160-0002-mtd-rename-ofpart-parser-to-fixed-partitions-as-it-f.patch +++ /dev/null @@ -1,68 +0,0 @@ -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 deleted file mode 100644 index 08f048f42a..0000000000 --- a/target/linux/generic/pending-4.9/160-0003-mtd-ofpart-add-of_match_table-with-fixed-partitions.patch +++ /dev/null @@ -1,40 +0,0 @@ -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,