From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= Subject: [PATCH V10 1/3] mtd: partitions: add of_match_table parser matching for the "ofpart" type Date: Wed, 14 Mar 2018 13:10:42 +0100 Message-ID: <20180314121044.12033-2-zajec5@gmail.com> References: <20180130201059.4424-1-zajec5@gmail.com> <20180314121044.12033-1-zajec5@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180314121044.12033-1-zajec5@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-mtd" Errors-To: linux-mtd-bounces+gldm-linux-mtd-36=gmane.org@lists.infradead.org To: Brian Norris , David Woodhouse , Boris Brezillon , Marek Vasut , Richard Weinberger , Cyrille Pitchen , Rob Herring Cc: Mark Rutland , devicetree@vger.kernel.org, Florian Fainelli , Geert Uytterhoeven , Linus Walleij , John Crispin , linux-mtd@lists.infradead.org, Jonas Gorski , =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= , Frank Rowand , Peter Rosin List-Id: devicetree@vger.kernel.org RnJvbTogUmFmYcWCIE1pxYJlY2tpIDxyYWZhbEBtaWxlY2tpLnBsPgoKSW4gb3JkZXIgdG8gcHJv cGVybHkgc3VwcG9ydCBjb21wYXRpYmlsaXR5IHN0cmluZ3MgYXMgZGVzY3JpYmVkIGluIHRoZQpi aW5kaW5ncy9tdGQvcGFydGl0aW9uLnR4dCAib2ZwYXJ0IiB0eXBlIHNob3VsZCBiZSB0cmVhdGVk IGFzIGFuCmluZGljYXRpb24gZm9yIGxvb2tpbmcgaW50byBPRi4gTVREIHNob3VsZCBjaGVjayAi Y29tcGF0aWJsZSIgcHJvcGVydHkKYW5kIHNlYXJjaCBmb3IgYSBtYXRjaGluZyBwYXJzZXIgcmF0 aGVyIHRoYW4gYmxpbmRseSB0cnlpbmcgdGhlIG9uZQpzdXBwb3J0aW5nICJmaXhlZC1wYXJ0aXRp b25zIi4KCkl0IGFsc28gbWVhbnMgdGhhdCBleGlzdGluZyAiZml4ZWQtcGFydGl0aW9ucyIgcGFy c2VyIHNob3VsZCBnZXQgcmVuYW1lZAp0byB1c2UgYSBtb3JlIG1lYW5pbmdmdWwgbmFtZS4KClRo aXMgY29tbWl0IGFjaGlldmllcyB0aGF0IGFpbSBieSBpbnRyb2R1Y2luZyBhIG5ldyBtdGRfcGFy dF9vZl9wYXJzZSgpLgpJdCB3b3JrcyBieSBsb29raW5nIGZvciBhIG1hdGNoaW5nIHBhcnNlciBm b3IgZXZlcnkgc3RyaW5nIGluIHRoZQoiY29tcGF0aWJpbGl0eSIgcHJvcGVydHkgKHN0YXJ0aW5n IHdpdGggdGhlIG1vc3Qgc3BlY2lmaWMgb25lKS4KClBsZWFzZSBub3RlIHRoYXQgZHJpdmVyLXNw ZWNpZmllZCBwYXJzZXJzIHN0aWxsIHRha2UgYSBwcmVjZWRlbmNlLiBJdCdzCmFzc3VtZWQgdGhh dCBkcml2ZXIgcHJvdmlkaW5nIGEgcGFyc2VyIHR5cGUgaGFzIGEgZ29vZCByZWFzb24gZm9yIHRo YXQKKGUuZy4gaGF2aW5nIHBsYXRmb3JtIGRhdGEgd2l0aCBkZXZpY2Utc3BlY2lmaWMgaW5mbyku IEFsc28gZG9pbmcKb3RoZXJ3aXNlIGNvdWxkIGJyZWFrIGV4aXN0aW5nIHNldHVwcy4gVGhlIHNh bWUgYXBwbGllcyB0byB1c2luZyBkZWZhdWx0CnBhcnNlcnMgKGluY2x1ZGluZyAiY21kbGluZXBh cnQiKSBhcyBzb21lIG92ZXJ3cml0ZSBEVCBkYXRhIHdpdGggY21kbGluZQphcmd1bWVudC4KClBh cnRpdGlvbiBwYXJzZXJzIGNhbiBub3cgcHJvdmlkZSBhbiBvZl9tYXRjaF90YWJsZSB0byBlbmFi bGUKZmxhc2g8LS0+cGFyc2VyIG1hdGNoaW5nIHZpYSBkZXZpY2UgdHJlZSBhcyBkb2N1bWVudGVk IGluIHRoZQptdGQvcGFydGl0aW9uLnR4dC4KClRoaXMgc3VwcG9ydCBpcyBjdXJyZW50bHkgbGlt aXRlZCB0byBidWlsdC1pbiBwYXJzZXJzIGFzIGl0IHVzZXMKcmVxdWVzdF9tb2R1bGUoKSBhbmQg ZnJpZW5kcy4gVGhpcyBzaG91bGQgYmUgc3VmZmljaWVudCBmb3IgbW9zdCBjYXNlcwp0aG91Z2gg YXMgY29tcGlsaW5nIHBhcnNlcnMgYXMgbW9kdWxlcyBpc24ndCBhIGNvbW1vbiBjaG9pY2UuCgpT aWduZWQtb2ZmLWJ5OiBCcmlhbiBOb3JyaXMgPGNvbXB1dGVyc2ZvcnBlYWNlQGdtYWlsLmNvbT4K U2lnbmVkLW9mZi1ieTogUmFmYcWCIE1pxYJlY2tpIDxyYWZhbEBtaWxlY2tpLnBsPgpUZXN0ZWQt Ynk6IFBldGVyIFJvc2luIDxwZWRhQGF4ZW50aWEuc2U+Ci0tLQpUaGlzIGlzIGJhc2VkIG9uIEJy aWFuJ3MgcGF0Y2hlczoKW1JGQyBQQVRDSCA0LzddIG10ZDogYWRkIG9mX21hdGNoX210ZF9wYXJz ZXIoKSBhbmQgb2ZfbXRkX21hdGNoX210ZF9wYXJzZXIoKSBoZWxwZXJzCltSRkMgUEFUQ0ggNi83 XSBSRkM6IG10ZDogcGFydGl0aW9uczogZW5hYmxlIG9mX21hdGNoX3RhYmxlIG1hdGNoaW5nCgpW MTogUHV0IGhlbHBlcnMgaW4gbXRkcGFydC5jIGluc3RlYWQgb2YgZHJpdmVycy9vZi9vZl9tdGQu YwogICAgTWVyZ2UgaGVscGVycyBpbnRvIGEgc2luZ2xlIG9mX210ZF9tYXRjaF9tdGRfcGFyc2Vy ClYzOiBBZGQgYSBzaW1wbGUgY29tbWVudCB0byBub3RlIHdlIHdpbGwgbmVlZCB0aGUgYmVzdCBt YXRjaCBpbiB0aGUgZnV0dXJlClY0OiBSZXdvcmsgbmV3IGZ1bmN0aW9ucyB0byBwaWNrIHBhcnNl ciB3aXRoIHRoZSBiZXN0IG1hdGNoCiAgICBNb3ZlIG5ldyBjb2RlIGluIHBhcnNlX210ZF9wYXJ0 aXRpb25zIHVwIHNvIGl0IGhhcyBwcmVjZWRlbmNlIG92ZXIgZmxhc2gKICAgIGRyaXZlciBkZWZh dWx0cyBhbmQgTVREIGRlZmF1bHRzClY1OiBSZXdvcmsgbWF0Y2hpbmcgY29kZSB0byBzdGFydCBj aGVja2luZyB3aXRoIHRoZSBtb3N0IHNwZWNpZmljIHN0cmluZyBpbiB0aGUKICAgICJjb21wYXRp YmlsaXR5IiBwcm9wZXJ0eS4KVjY6IEluaXRpYWxpemUgInJldCIgdmFyaWFibGUgaW4gbXRkX3Bh cnRfZ2V0X3BhcnNlcl9ieV9jcCB0byBOVUxMClY3OiBSZW5hbWUgZnVuY3Rpb24gIm10ZF9wYXJ0 X2dldF9wYXJzZXJfYnlfY3AiIHRvIHVzZSAiX2NvbXBhdGlibGVfIgogICAgUmVuYW1lICJjcCIg dmFyaWFibGUgdG8gImNvbXBhdCIKICAgIERyb3AgdW5uZWVkZWQgaWYgKG5wKSBjaGVjayBmcm9t IHRoZSBwYXJzZV9tdGRfcGFydGl0aW9ucwpWODogTW92ZSBuZXcgT0YgY29kZSBpbiBwYXJzZV9t dGRfcGFydGl0aW9ucygpIGxvd2VyIHNvIGRyaXZlci1zcGVjaWZpZWQgcGFyc2VycwogICAgdGFr ZSBhIHByZWNlZGVuY2UuIFVwZGF0ZSBjb21taXQgbWVzc2FnZSB0byBtYWtlIHRoYXQgY2xlYXIu ClY5OiBVcGRhdGUgdG8gbW9kaWZ5IG10ZF9wYXJ0X29mX3BhcnNlKCkgaW5zdGVhZCBvZiBwYXJz ZV9tdGRfcGFydGl0aW9ucygpClYxMDogQ29tbWl0IGFkZGluZyBzdXBwb3J0IGZvciAib2ZwYXJ0 IiBnb3Qgc3F1YXNoZWQgaW50byB0aGlzIG9uZS4KLS0tCiBkcml2ZXJzL210ZC9tdGRwYXJ0LmMg ICAgICAgICAgfCAxMTYgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0K IGluY2x1ZGUvbGludXgvbXRkL3BhcnRpdGlvbnMuaCB8ICAgMSArCiAyIGZpbGVzIGNoYW5nZWQs IDEwOCBpbnNlcnRpb25zKCspLCA5IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMv bXRkL210ZHBhcnQuYyBiL2RyaXZlcnMvbXRkL210ZHBhcnQuYwppbmRleCA3NmNkMjFkMTE3MWIu LjEwNWZlMmM3NzI5YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbXRkcGFydC5jCisrKyBiL2Ry aXZlcnMvbXRkL210ZHBhcnQuYwpAQCAtMzAsNiArMzAsNyBAQAogI2luY2x1ZGUgPGxpbnV4L210 ZC9tdGQuaD4KICNpbmNsdWRlIDxsaW51eC9tdGQvcGFydGl0aW9ucy5oPgogI2luY2x1ZGUgPGxp bnV4L2Vyci5oPgorI2luY2x1ZGUgPGxpbnV4L29mLmg+CiAKICNpbmNsdWRlICJtdGRjb3JlLmgi CiAKQEAgLTg2MSw2ICs4NjIsOTIgQEAgc3RhdGljIGludCBtdGRfcGFydF9kb19wYXJzZShzdHJ1 Y3QgbXRkX3BhcnRfcGFyc2VyICpwYXJzZXIsCiB9CiAKIC8qKgorICogbXRkX3BhcnRfZ2V0X2Nv bXBhdGlibGVfcGFyc2VyIC0gZmluZCBNVEQgcGFyc2VyIGJ5IGEgY29tcGF0aWJsZSBzdHJpbmcK KyAqCisgKiBAY29tcGF0OiBjb21wYXRpYmxlIHN0cmluZyBkZXNjcmliaW5nIHBhcnRpdGlvbnMg aW4gYSBkZXZpY2UgdHJlZQorICoKKyAqIE1URCBwYXJzZXJzIGNhbiBzcGVjaWZ5IHN1cHBvcnRl ZCBwYXJ0aXRpb25zIGJ5IHByb3ZpZGluZyBhIHRhYmxlIG9mCisgKiBjb21wYXRpYmlsaXR5IHN0 cmluZ3MuIFRoaXMgZnVuY3Rpb24gZmluZHMgYSBwYXJzZXIgdGhhdCBhZHZlcnRpc2VzIHN1cHBv cnQKKyAqIGZvciBhIHBhc3NlZCB2YWx1ZSBvZiAiY29tcGF0aWJsZSIuCisgKi8KK3N0YXRpYyBz dHJ1Y3QgbXRkX3BhcnRfcGFyc2VyICptdGRfcGFydF9nZXRfY29tcGF0aWJsZV9wYXJzZXIoY29u c3QgY2hhciAqY29tcGF0KQoreworCXN0cnVjdCBtdGRfcGFydF9wYXJzZXIgKnAsICpyZXQgPSBO VUxMOworCisJc3Bpbl9sb2NrKCZwYXJ0X3BhcnNlcl9sb2NrKTsKKworCWxpc3RfZm9yX2VhY2hf ZW50cnkocCwgJnBhcnRfcGFyc2VycywgbGlzdCkgeworCQljb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNl X2lkICptYXRjaGVzOworCisJCW1hdGNoZXMgPSBwLT5vZl9tYXRjaF90YWJsZTsKKwkJaWYgKCFt YXRjaGVzKQorCQkJY29udGludWU7CisKKwkJZm9yICg7IG1hdGNoZXMtPmNvbXBhdGlibGVbMF07 IG1hdGNoZXMrKykgeworCQkJaWYgKCFzdHJjbXAobWF0Y2hlcy0+Y29tcGF0aWJsZSwgY29tcGF0 KSAmJgorCQkJICAgIHRyeV9tb2R1bGVfZ2V0KHAtPm93bmVyKSkgeworCQkJCXJldCA9IHA7CisJ CQkJYnJlYWs7CisJCQl9CisJCX0KKworCQlpZiAocmV0KQorCQkJYnJlYWs7CisJfQorCisJc3Bp bl91bmxvY2soJnBhcnRfcGFyc2VyX2xvY2spOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGlj IGludCBtdGRfcGFydF9vZl9wYXJzZShzdHJ1Y3QgbXRkX2luZm8gKm1hc3RlciwKKwkJCSAgICAg c3RydWN0IG10ZF9wYXJ0aXRpb25zICpwcGFydHMpCit7CisJc3RydWN0IG10ZF9wYXJ0X3BhcnNl ciAqcGFyc2VyOworCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbnA7CisJc3RydWN0IHByb3BlcnR5ICpw cm9wOworCWNvbnN0IGNoYXIgKmNvbXBhdDsKKwljb25zdCBjaGFyICpmaXhlZCA9ICJvZnBhcnQi OworCWludCByZXQsIGVyciA9IDA7CisKKwlucCA9IG9mX2dldF9jaGlsZF9ieV9uYW1lKG10ZF9n ZXRfb2Zfbm9kZShtYXN0ZXIpLCAicGFydGl0aW9ucyIpOworCW9mX3Byb3BlcnR5X2Zvcl9lYWNo X3N0cmluZyhucCwgImNvbXBhdGlibGUiLCBwcm9wLCBjb21wYXQpIHsKKwkJcGFyc2VyID0gbXRk X3BhcnRfZ2V0X2NvbXBhdGlibGVfcGFyc2VyKGNvbXBhdCk7CisJCWlmICghcGFyc2VyKQorCQkJ Y29udGludWU7CisJCXJldCA9IG10ZF9wYXJ0X2RvX3BhcnNlKHBhcnNlciwgbWFzdGVyLCBwcGFy dHMsIE5VTEwpOworCQlpZiAocmV0ID4gMCkgeworCQkJb2Zfbm9kZV9wdXQobnApOworCQkJcmV0 dXJuIHJldDsKKwkJfQorCQltdGRfcGFydF9wYXJzZXJfcHV0KHBhcnNlcik7CisJCWlmIChyZXQg PCAwICYmICFlcnIpCisJCQllcnIgPSByZXQ7CisJfQorCW9mX25vZGVfcHV0KG5wKTsKKworCS8q CisJICogRm9yIGJhY2t3YXJkIGNvbXBhdGliaWxpdHkgd2UgaGF2ZSB0byB0cnkgdGhlICJvZnBh cnQiCisJICogcGFyc2VyLiBJdCBzdXBwb3J0cyBvbGQgRFQgZm9ybWF0IHdpdGggcGFydGl0aW9u cyBzcGVjaWZpZWQgYXMgYQorCSAqIGRpcmVjdCBzdWJub2RlcyBvZiBhIGZsYXNoIGRldmljZSBE VCBub2RlIHdpdGhvdXQgYW55IGNvbXBhdGliaWxpdHkKKwkgKiBzcGVjaWZpZWQgd2UgY291bGQg bWF0Y2guCisJICovCisJcGFyc2VyID0gbXRkX3BhcnRfcGFyc2VyX2dldChmaXhlZCk7CisJaWYg KCFwYXJzZXIgJiYgIXJlcXVlc3RfbW9kdWxlKCIlcyIsIGZpeGVkKSkKKwkJcGFyc2VyID0gbXRk X3BhcnRfcGFyc2VyX2dldChmaXhlZCk7CisJaWYgKHBhcnNlcikgeworCQlyZXQgPSBtdGRfcGFy dF9kb19wYXJzZShwYXJzZXIsIG1hc3RlciwgcHBhcnRzLCBOVUxMKTsKKwkJaWYgKHJldCA+IDAp CisJCQlyZXR1cm4gcmV0OworCQltdGRfcGFydF9wYXJzZXJfcHV0KHBhcnNlcik7CisJCWlmIChy ZXQgPCAwICYmICFlcnIpCisJCQllcnIgPSByZXQ7CisJfQorCisJcmV0dXJuIGVycjsKK30KKwor LyoqCiAgKiBwYXJzZV9tdGRfcGFydGl0aW9ucyAtIHBhcnNlIE1URCBwYXJ0aXRpb25zCiAgKiBA bWFzdGVyOiB0aGUgbWFzdGVyIHBhcnRpdGlvbiAoZGVzY3JpYmVzIHdob2xlIE1URCBkZXZpY2Up CiAgKiBAdHlwZXM6IG5hbWVzIG9mIHBhcnRpdGlvbiBwYXJzZXJzIHRvIHRyeSBvciAlTlVMTApA QCAtODkyLDE5ICs5NzksMzAgQEAgaW50IHBhcnNlX210ZF9wYXJ0aXRpb25zKHN0cnVjdCBtdGRf aW5mbyAqbWFzdGVyLCBjb25zdCBjaGFyICpjb25zdCAqdHlwZXMsCiAJCXR5cGVzID0gZGVmYXVs dF9tdGRfcGFydF90eXBlczsKIAogCWZvciAoIDsgKnR5cGVzOyB0eXBlcysrKSB7Ci0JCXByX2Rl YnVnKCIlczogcGFyc2luZyBwYXJ0aXRpb25zICVzXG4iLCBtYXN0ZXItPm5hbWUsICp0eXBlcyk7 Ci0JCXBhcnNlciA9IG10ZF9wYXJ0X3BhcnNlcl9nZXQoKnR5cGVzKTsKLQkJaWYgKCFwYXJzZXIg JiYgIXJlcXVlc3RfbW9kdWxlKCIlcyIsICp0eXBlcykpCisJCS8qCisJCSAqIG9mcGFydCBpcyBh IHNwZWNpYWwgdHlwZSB0aGF0IG1lYW5zIE9GIHBhcnRpdGlvbmluZyBpbmZvCisJCSAqIHNob3Vs ZCBiZSB1c2VkLiBJdCByZXF1aXJlcyBhIGJpdCBkaWZmZXJlbnQgbG9naWMgc28gaXQgaXMKKwkJ ICogaGFuZGxlZCBpbiBhIHNlcGFyYXRlZCBmdW5jdGlvbi4KKwkJICovCisJCWlmICghc3RyY21w KCp0eXBlcywgIm9mcGFydCIpKSB7CisJCQlyZXQgPSBtdGRfcGFydF9vZl9wYXJzZShtYXN0ZXIs IHBwYXJ0cyk7CisJCX0gZWxzZSB7CisJCQlwcl9kZWJ1ZygiJXM6IHBhcnNpbmcgcGFydGl0aW9u cyAlc1xuIiwgbWFzdGVyLT5uYW1lLAorCQkJCSAqdHlwZXMpOwogCQkJcGFyc2VyID0gbXRkX3Bh cnRfcGFyc2VyX2dldCgqdHlwZXMpOwotCQlwcl9kZWJ1ZygiJXM6IGdvdCBwYXJzZXIgJXNcbiIs IG1hc3Rlci0+bmFtZSwKLQkJCSBwYXJzZXIgPyBwYXJzZXItPm5hbWUgOiBOVUxMKTsKLQkJaWYg KCFwYXJzZXIpCi0JCQljb250aW51ZTsKLQkJcmV0ID0gbXRkX3BhcnRfZG9fcGFyc2UocGFyc2Vy LCBtYXN0ZXIsIHBwYXJ0cywgZGF0YSk7CisJCQlpZiAoIXBhcnNlciAmJiAhcmVxdWVzdF9tb2R1 bGUoIiVzIiwgKnR5cGVzKSkKKwkJCQlwYXJzZXIgPSBtdGRfcGFydF9wYXJzZXJfZ2V0KCp0eXBl cyk7CisJCQlwcl9kZWJ1ZygiJXM6IGdvdCBwYXJzZXIgJXNcbiIsIG1hc3Rlci0+bmFtZSwKKwkJ CQlwYXJzZXIgPyBwYXJzZXItPm5hbWUgOiBOVUxMKTsKKwkJCWlmICghcGFyc2VyKQorCQkJCWNv bnRpbnVlOworCQkJcmV0ID0gbXRkX3BhcnRfZG9fcGFyc2UocGFyc2VyLCBtYXN0ZXIsIHBwYXJ0 cywgZGF0YSk7CisJCQlpZiAocmV0IDw9IDApCisJCQkJbXRkX3BhcnRfcGFyc2VyX3B1dChwYXJz ZXIpOworCQl9CiAJCS8qIEZvdW5kIHBhcnRpdGlvbnMhICovCiAJCWlmIChyZXQgPiAwKQogCQkJ cmV0dXJuIDA7Ci0JCW10ZF9wYXJ0X3BhcnNlcl9wdXQocGFyc2VyKTsKIAkJLyoKIAkJICogU3Rh c2ggdGhlIGZpcnN0IGVycm9yIHdlIHNlZTsgb25seSByZXBvcnQgaXQgaWYgbm8gcGFyc2VyCiAJ CSAqIHN1Y2NlZWRzCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L210ZC9wYXJ0aXRpb25zLmgg Yi9pbmNsdWRlL2xpbnV4L210ZC9wYXJ0aXRpb25zLmgKaW5kZXggYzRiZWI3MGRhY2JkLi4xMWNi MGM1MGNkODQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbXRkL3BhcnRpdGlvbnMuaAorKysg Yi9pbmNsdWRlL2xpbnV4L210ZC9wYXJ0aXRpb25zLmgKQEAgLTc3LDYgKzc3LDcgQEAgc3RydWN0 IG10ZF9wYXJ0X3BhcnNlciB7CiAJc3RydWN0IGxpc3RfaGVhZCBsaXN0OwogCXN0cnVjdCBtb2R1 bGUgKm93bmVyOwogCWNvbnN0IGNoYXIgKm5hbWU7CisJY29uc3Qgc3RydWN0IG9mX2RldmljZV9p ZCAqb2ZfbWF0Y2hfdGFibGU7CiAJaW50ICgqcGFyc2VfZm4pKHN0cnVjdCBtdGRfaW5mbyAqLCBj b25zdCBzdHJ1Y3QgbXRkX3BhcnRpdGlvbiAqKiwKIAkJCXN0cnVjdCBtdGRfcGFydF9wYXJzZXJf ZGF0YSAqKTsKIAl2b2lkICgqY2xlYW51cCkoY29uc3Qgc3RydWN0IG10ZF9wYXJ0aXRpb24gKnBw YXJ0cywgaW50IG5yX3BhcnRzKTsKLS0gCjIuMTEuMAoKCl9fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpMaW51eCBNVEQgZGlzY3Vzc2lvbiBtYWls aW5nIGxpc3QKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51 eC1tdGQvCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-lf0-x243.google.com ([2a00:1450:4010:c07::243]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1ew5FL-0001JH-5l for linux-mtd@lists.infradead.org; Wed, 14 Mar 2018 12:11:12 +0000 Received: by mail-lf0-x243.google.com with SMTP id v9-v6so4396824lfa.11 for ; Wed, 14 Mar 2018 05:10:58 -0700 (PDT) From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= To: Brian Norris , David Woodhouse , Boris Brezillon , Marek Vasut , Richard Weinberger , Cyrille Pitchen , Rob Herring Cc: Mark Rutland , Frank Rowand , Linus Walleij , linux-mtd@lists.infradead.org, devicetree@vger.kernel.org, Geert Uytterhoeven , Jonas Gorski , Florian Fainelli , John Crispin , Peter Rosin , =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= Subject: [PATCH V10 1/3] mtd: partitions: add of_match_table parser matching for the "ofpart" type Date: Wed, 14 Mar 2018 13:10:42 +0100 Message-Id: <20180314121044.12033-2-zajec5@gmail.com> In-Reply-To: <20180314121044.12033-1-zajec5@gmail.com> References: <20180130201059.4424-1-zajec5@gmail.com> <20180314121044.12033-1-zajec5@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit List-Id: Linux MTD discussion mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , From: Rafał Miłecki 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 --- This is based on Brian's patches: [RFC PATCH 4/7] mtd: add of_match_mtd_parser() and of_mtd_match_mtd_parser() helpers [RFC PATCH 6/7] RFC: mtd: partitions: enable of_match_table matching V1: Put helpers in mtdpart.c instead of drivers/of/of_mtd.c Merge helpers into a single of_mtd_match_mtd_parser V3: Add a simple comment to note we will need the best match in the future V4: Rework new functions to pick parser with the best match Move new code in parse_mtd_partitions up so it has precedence over flash driver defaults and MTD defaults V5: Rework matching code to start checking with the most specific string in the "compatibility" property. V6: Initialize "ret" variable in mtd_part_get_parser_by_cp to NULL V7: Rename function "mtd_part_get_parser_by_cp" to use "_compatible_" Rename "cp" variable to "compat" Drop unneeded if (np) check from the parse_mtd_partitions V8: Move new OF code in parse_mtd_partitions() lower so driver-specified parsers take a precedence. Update commit message to make that clear. V9: Update to modify mtd_part_of_parse() instead of parse_mtd_partitions() V10: Commit adding support for "ofpart" got squashed into this one. --- drivers/mtd/mtdpart.c | 116 +++++++++++++++++++++++++++++++++++++---- include/linux/mtd/partitions.h | 1 + 2 files changed, 108 insertions(+), 9 deletions(-) diff --git a/drivers/mtd/mtdpart.c b/drivers/mtd/mtdpart.c index 76cd21d1171b..105fe2c7729c 100644 --- a/drivers/mtd/mtdpart.c +++ b/drivers/mtd/mtdpart.c @@ -30,6 +30,7 @@ #include #include #include +#include #include "mtdcore.h" @@ -861,6 +862,92 @@ static int mtd_part_do_parse(struct mtd_part_parser *parser, } /** + * 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 @@ -892,19 +979,30 @@ int parse_mtd_partitions(struct mtd_info *master, const char *const *types, 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 diff --git a/include/linux/mtd/partitions.h b/include/linux/mtd/partitions.h index c4beb70dacbd..11cb0c50cd84 100644 --- 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); -- 2.11.0