From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jonas Gorski Subject: [PATCH 3/5] mtd: bcm63xxpart: move imagetag parsing to its own parser Date: Tue, 28 Aug 2018 13:19:42 +0200 Message-ID: <20180828111944.5956-4-jonas.gorski@gmail.com> References: <20180828111944.5956-1-jonas.gorski@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180828111944.5956-1-jonas.gorski@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: linux-mtd@lists.infradead.org, devicetree@vger.kernel.org Cc: Mark Rutland , Florian Fainelli , Marek Vasut , Richard Weinberger , Boris Brezillon , Rob Herring , Brian Norris , David Woodhouse List-Id: devicetree@vger.kernel.org TW92ZSB0aGUgYmNtOTYzeHggSW1hZ2UgVGFnIHBhcnNpbmcgaW50byBpdHMgb3duIHBhcnRpdGlv biBwYXJzZXIuIFRoaXMKQWxsb3dzIHJldXNpbmcgdGhlIHBhcnNlciB3aXRoIGRpZmZlcmVudCBm dWxsIGZsYXNoIHBhcnNlcnMuCgpXaGlsZSBtb3ZpbmcgaXQsIHJlbmFtZSBpdCB0byBiY205NjMq IHRvIGJldHRlciByZWZsZWN0IGl0IGlzbid0IGNoaXAsCmJ1dCByZWZlcmVuY2UgaW1wbGVtZW50 YXRpb24gc3BlY2lmaWMuCgpTaWduZWQtb2ZmLWJ5OiBKb25hcyBHb3Jza2kgPGpvbmFzLmdvcnNr aUBnbWFpbC5jb20+Ci0tLQogZHJpdmVycy9tdGQvS2NvbmZpZyAgICAgICAgICAgICAgICAgICB8 ICAgMSArCiBkcml2ZXJzL210ZC9iY202M3h4cGFydC5jICAgICAgICAgICAgIHwgMTU1ICsrLS0t LS0tLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9tdGQvcGFyc2Vycy9LY29uZmlnICAgICAgICAg ICB8ICAxMSArKwogZHJpdmVycy9tdGQvcGFyc2Vycy9NYWtlZmlsZSAgICAgICAgICB8ICAgMSAr CiBkcml2ZXJzL210ZC9wYXJzZXJzL3BhcnNlcl9pbWFnZXRhZy5jIHwgMjE0ICsrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysKIDUgZmlsZXMgY2hhbmdlZCwgMjM1IGluc2VydGlvbnMo KyksIDE0NyBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL210ZC9wYXJz ZXJzL3BhcnNlcl9pbWFnZXRhZy5jCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvS2NvbmZpZyBi L2RyaXZlcnMvbXRkL0tjb25maWcKaW5kZXggYzc3ZjUzNzMyM2VjLi5hM2JkMGUzMTU5OTAgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL0tjb25maWcKKysrIGIvZHJpdmVycy9tdGQvS2NvbmZpZwpA QCAtMTQzLDYgKzE0Myw3IEBAIGNvbmZpZyBNVERfQkNNNjNYWF9QQVJUUwogCXRyaXN0YXRlICJC Q002M1hYIENGRSBwYXJ0aXRpb25pbmcgc3VwcG9ydCIKIAlkZXBlbmRzIG9uIEJDTTYzWFggfHwg Qk1JUFNfR0VORVJJQyB8fCBDT01QSUxFX1RFU1QKIAlzZWxlY3QgQ1JDMzIKKwlzZWxlY3QgTVRE X1BBUlNFUl9JTUFHRVRBRwogCWhlbHAKIAkgIFRoaXMgcHJvdmlkZXMgcGFydGlvbnMgcGFyc2lu ZyBmb3IgQkNNNjN4eCBkZXZpY2VzIHdpdGggQ0ZFCiAJICBib290bG9hZGVycy4KZGlmZiAtLWdp dCBhL2RyaXZlcnMvbXRkL2JjbTYzeHhwYXJ0LmMgYi9kcml2ZXJzL210ZC9iY202M3h4cGFydC5j CmluZGV4IGY2MzliNGM5NjBmMC4uYjJiZDA0NzY0ZTk1IDEwMDY0NAotLS0gYS9kcml2ZXJzL210 ZC9iY202M3h4cGFydC5jCisrKyBiL2RyaXZlcnMvbXRkL2JjbTYzeHhwYXJ0LmMKQEAgLTk0LDUx ICs5NCwxOSBAQCBzdGF0aWMgaW50IGJjbTYzeHhfcmVhZF9udnJhbShzdHJ1Y3QgbXRkX2luZm8g Km1hc3RlciwKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGludCBiY202M3h4X3JlYWRfaW1hZ2Vf dGFnKHN0cnVjdCBtdGRfaW5mbyAqbWFzdGVyLCBjb25zdCBjaGFyICpuYW1lLAotCWxvZmZfdCB0 YWdfb2Zmc2V0LCBzdHJ1Y3QgYmNtX3RhZyAqYnVmKQotewotCWludCByZXQ7Ci0Jc2l6ZV90IHJl dGxlbjsKLQl1MzIgY29tcHV0ZWRfY3JjOwotCi0JcmV0ID0gbXRkX3JlYWQobWFzdGVyLCB0YWdf b2Zmc2V0LCBzaXplb2YoKmJ1ZiksICZyZXRsZW4sICh2b2lkICopYnVmKTsKLQlpZiAocmV0KQot CQlyZXR1cm4gcmV0OwotCi0JaWYgKHJldGxlbiAhPSBzaXplb2YoKmJ1ZikpCi0JCXJldHVybiAt RUlPOwotCi0JY29tcHV0ZWRfY3JjID0gY3JjMzJfbGUoSU1BR0VUQUdfQ1JDX1NUQVJULCAodTgg KilidWYsCi0JCQkJb2Zmc2V0b2Yoc3RydWN0IGJjbV90YWcsIGhlYWRlcl9jcmMpKTsKLQlpZiAo Y29tcHV0ZWRfY3JjID09IGJ1Zi0+aGVhZGVyX2NyYykgewotCQlTVFJfTlVMTF9URVJNSU5BVEUo YnVmLT5ib2FyZF9pZCk7Ci0JCVNUUl9OVUxMX1RFUk1JTkFURShidWYtPnRhZ192ZXJzaW9uKTsK LQotCQlwcl9pbmZvKCIlczogQ0ZFIGltYWdlIHRhZyBmb3VuZCBhdCAweCVsbHggd2l0aCB2ZXJz aW9uICVzLCBib2FyZCB0eXBlICVzXG4iLAotCQkJbmFtZSwgdGFnX29mZnNldCwgYnVmLT50YWdf dmVyc2lvbiwgYnVmLT5ib2FyZF9pZCk7Ci0KLQkJcmV0dXJuIDA7Ci0JfQotCi0JcHJfd2Fybigi JXM6IENGRSBpbWFnZSB0YWcgYXQgMHglbGx4IENSQyBpbnZhbGlkIChleHBlY3RlZCAlMDh4LCBh Y3R1YWwgJTA4eClcbiIsCi0JCW5hbWUsIHRhZ19vZmZzZXQsIGJ1Zi0+aGVhZGVyX2NyYywgY29t cHV0ZWRfY3JjKTsKLQlyZXR1cm4gMTsKLX0KK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgYmNt NjN4eF9jZmVfcGFydF90eXBlc1tdID0geworCSJiY205NjN4eC1pbWFnZXRhZyIsCisJTlVMTCwK K307CiAKIHN0YXRpYyBpbnQgYmNtNjN4eF9wYXJzZV9jZmVfbm9yX3BhcnRpdGlvbnMoc3RydWN0 IG10ZF9pbmZvICptYXN0ZXIsCiAJY29uc3Qgc3RydWN0IG10ZF9wYXJ0aXRpb24gKipwcGFydHMs IHN0cnVjdCBiY205NjN4eF9udnJhbSAqbnZyYW0pCiB7Ci0JLyogQ0ZFLCBOVlJBTSBhbmQgZ2xv YmFsIExpbnV4IGFyZSBhbHdheXMgcHJlc2VudCAqLwotCWludCBucnBhcnRzID0gMywgY3VycGFy dCA9IDA7Ci0Jc3RydWN0IGJjbV90YWcgKmJ1ZiA9IE5VTEw7CiAJc3RydWN0IG10ZF9wYXJ0aXRp b24gKnBhcnRzOwotCWludCByZXQ7Ci0JdW5zaWduZWQgaW50IHJvb3Rmc2FkZHIsIGtlcm5lbGFk ZHIsIHNwYXJlYWRkcjsKLQl1bnNpZ25lZCBpbnQgcm9vdGZzbGVuLCBrZXJuZWxsZW4sIHNwYXJl bGVuLCB0b3RhbGxlbjsKKwlpbnQgbnJwYXJ0cyA9IDMsIGN1cnBhcnQgPSAwOwogCXVuc2lnbmVk IGludCBjZmVsZW4sIG52cmFtbGVuOwogCXVuc2lnbmVkIGludCBjZmVfZXJhc2VzaXplOwogCWlu dCBpOwotCWJvb2wgcm9vdGZzX2ZpcnN0ID0gZmFsc2U7CiAKIAljZmVfZXJhc2VzaXplID0gbWF4 X3QodWludDMyX3QsIG1hc3Rlci0+ZXJhc2VzaXplLAogCQkJICAgICAgQkNNOTYzWFhfQ0ZFX0JM T0NLX1NJWkUpOwpAQCAtMTQ3LDgzICsxMTUsOSBAQCBzdGF0aWMgaW50IGJjbTYzeHhfcGFyc2Vf Y2ZlX25vcl9wYXJ0aXRpb25zKHN0cnVjdCBtdGRfaW5mbyAqbWFzdGVyLAogCW52cmFtbGVuID0g bnZyYW0tPnBzaV9zaXplICogU1pfMUs7CiAJbnZyYW1sZW4gPSByb3VuZHVwKG52cmFtbGVuLCBj ZmVfZXJhc2VzaXplKTsKIAotCWJ1ZiA9IHZtYWxsb2Moc2l6ZW9mKHN0cnVjdCBiY21fdGFnKSk7 Ci0JaWYgKCFidWYpCi0JCXJldHVybiAtRU5PTUVNOwotCi0JLyogR2V0IHRoZSB0YWcgKi8KLQly ZXQgPSBiY202M3h4X3JlYWRfaW1hZ2VfdGFnKG1hc3RlciwgInJvb3RmcyIsIGNmZWxlbiwgYnVm KTsKLQlpZiAoIXJldCkgewotCQlTVFJfTlVMTF9URVJNSU5BVEUoYnVmLT5mbGFzaF9pbWFnZV9z dGFydCk7Ci0JCWlmIChrc3RydG91aW50KGJ1Zi0+Zmxhc2hfaW1hZ2Vfc3RhcnQsIDEwLCAmcm9v dGZzYWRkcikgfHwKLQkJCQlyb290ZnNhZGRyIDwgQkNNOTYzWFhfRVhURU5ERURfU0laRSkgewot CQkJcHJfZXJyKCJpbnZhbGlkIHJvb3RmcyBhZGRyZXNzOiAlKnBoXG4iLAotCQkJCShpbnQpc2l6 ZW9mKGJ1Zi0+Zmxhc2hfaW1hZ2Vfc3RhcnQpLAotCQkJCWJ1Zi0+Zmxhc2hfaW1hZ2Vfc3RhcnQp OwotCQkJZ290byBpbnZhbGlkX3RhZzsKLQkJfQotCi0JCVNUUl9OVUxMX1RFUk1JTkFURShidWYt Pmtlcm5lbF9hZGRyZXNzKTsKLQkJaWYgKGtzdHJ0b3VpbnQoYnVmLT5rZXJuZWxfYWRkcmVzcywg MTAsICZrZXJuZWxhZGRyKSB8fAotCQkJCWtlcm5lbGFkZHIgPCBCQ005NjNYWF9FWFRFTkRFRF9T SVpFKSB7Ci0JCQlwcl9lcnIoImludmFsaWQga2VybmVsIGFkZHJlc3M6ICUqcGhcbiIsCi0JCQkJ KGludClzaXplb2YoYnVmLT5rZXJuZWxfYWRkcmVzcyksCi0JCQkJYnVmLT5rZXJuZWxfYWRkcmVz cyk7Ci0JCQlnb3RvIGludmFsaWRfdGFnOwotCQl9Ci0KLQkJU1RSX05VTExfVEVSTUlOQVRFKGJ1 Zi0+a2VybmVsX2xlbmd0aCk7Ci0JCWlmIChrc3RydG91aW50KGJ1Zi0+a2VybmVsX2xlbmd0aCwg MTAsICZrZXJuZWxsZW4pKSB7Ci0JCQlwcl9lcnIoImludmFsaWQga2VybmVsIGxlbmd0aDogJSpw aFxuIiwKLQkJCQkoaW50KXNpemVvZihidWYtPmtlcm5lbF9sZW5ndGgpLAotCQkJCWJ1Zi0+a2Vy bmVsX2xlbmd0aCk7Ci0JCQlnb3RvIGludmFsaWRfdGFnOwotCQl9Ci0KLQkJU1RSX05VTExfVEVS TUlOQVRFKGJ1Zi0+dG90YWxfbGVuZ3RoKTsKLQkJaWYgKGtzdHJ0b3VpbnQoYnVmLT50b3RhbF9s ZW5ndGgsIDEwLCAmdG90YWxsZW4pKSB7Ci0JCQlwcl9lcnIoImludmFsaWQgdG90YWwgbGVuZ3Ro OiAlKnBoXG4iLAotCQkJCShpbnQpc2l6ZW9mKGJ1Zi0+dG90YWxfbGVuZ3RoKSwKLQkJCQlidWYt PnRvdGFsX2xlbmd0aCk7Ci0JCQlnb3RvIGludmFsaWRfdGFnOwotCQl9Ci0KLQkJa2VybmVsYWRk ciA9IGtlcm5lbGFkZHIgLSBCQ005NjNYWF9FWFRFTkRFRF9TSVpFOwotCQlyb290ZnNhZGRyID0g cm9vdGZzYWRkciAtIEJDTTk2M1hYX0VYVEVOREVEX1NJWkU7Ci0JCXNwYXJlYWRkciA9IHJvdW5k dXAodG90YWxsZW4sIG1hc3Rlci0+ZXJhc2VzaXplKSArIGNmZWxlbjsKLQotCQlpZiAocm9vdGZz YWRkciA8IGtlcm5lbGFkZHIpIHsKLQkJCS8qIGRlZmF1bHQgQnJvYWRjb20gbGF5b3V0ICovCi0J CQlyb290ZnNsZW4gPSBrZXJuZWxhZGRyIC0gcm9vdGZzYWRkcjsKLQkJCXJvb3Rmc19maXJzdCA9 IHRydWU7Ci0JCX0gZWxzZSB7Ci0JCQkvKiBPcGVuV3J0IGxheW91dCAqLwotCQkJcm9vdGZzYWRk ciA9IGtlcm5lbGFkZHIgKyBrZXJuZWxsZW47Ci0JCQlyb290ZnNsZW4gPSBzcGFyZWFkZHIgLSBy b290ZnNhZGRyOwotCQl9Ci0JfSBlbHNlIGlmIChyZXQgPiAwKSB7Ci1pbnZhbGlkX3RhZzoKLQkJ a2VybmVsbGVuID0gMDsKLQkJcm9vdGZzbGVuID0gMDsKLQkJcm9vdGZzYWRkciA9IDA7Ci0JCXNw YXJlYWRkciA9IGNmZWxlbjsKLQl9IGVsc2UgewotCQlnb3RvIG91dDsKLQl9Ci0Jc3BhcmVsZW4g PSBtYXN0ZXItPnNpemUgLSBzcGFyZWFkZHIgLSBudnJhbWxlbjsKLQotCS8qIERldGVybWluZSBu dW1iZXIgb2YgcGFydGl0aW9ucyAqLwotCWlmIChyb290ZnNsZW4gPiAwKQotCQlucnBhcnRzKys7 Ci0KLQlpZiAoa2VybmVsbGVuID4gMCkKLQkJbnJwYXJ0cysrOwotCiAJcGFydHMgPSBremFsbG9j KHNpemVvZigqcGFydHMpICogbnJwYXJ0cyArIDEwICogbnJwYXJ0cywgR0ZQX0tFUk5FTCk7Ci0J aWYgKCFwYXJ0cykgewotCQlyZXQgPSAtRU5PTUVNOwotCQlnb3RvIG91dDsKLQl9CisJaWYgKCFw YXJ0cykKKwkJcmV0dXJuIC1FTk9NRU07CiAKIAkvKiBTdGFydCBidWlsZGluZyBwYXJ0aXRpb24g bGlzdCAqLwogCXBhcnRzW2N1cnBhcnRdLm5hbWUgPSAiQ0ZFIjsKQEAgLTIzMSwzMCArMTI1LDYg QEAgc3RhdGljIGludCBiY202M3h4X3BhcnNlX2NmZV9ub3JfcGFydGl0aW9ucyhzdHJ1Y3QgbXRk X2luZm8gKm1hc3RlciwKIAlwYXJ0c1tjdXJwYXJ0XS5zaXplID0gY2ZlbGVuOwogCWN1cnBhcnQr KzsKIAotCWlmIChrZXJuZWxsZW4gPiAwKSB7Ci0JCWludCBrZXJuZWxwYXJ0ID0gY3VycGFydDsK LQotCQlpZiAocm9vdGZzbGVuID4gMCAmJiByb290ZnNfZmlyc3QpCi0JCQlrZXJuZWxwYXJ0Kys7 Ci0JCXBhcnRzW2tlcm5lbHBhcnRdLm5hbWUgPSAia2VybmVsIjsKLQkJcGFydHNba2VybmVscGFy dF0ub2Zmc2V0ID0ga2VybmVsYWRkcjsKLQkJcGFydHNba2VybmVscGFydF0uc2l6ZSA9IGtlcm5l bGxlbjsKLQkJY3VycGFydCsrOwotCX0KLQotCWlmIChyb290ZnNsZW4gPiAwKSB7Ci0JCWludCBy b290ZnNwYXJ0ID0gY3VycGFydDsKLQotCQlpZiAoa2VybmVsbGVuID4gMCAmJiByb290ZnNfZmly c3QpCi0JCQlyb290ZnNwYXJ0LS07Ci0JCXBhcnRzW3Jvb3Rmc3BhcnRdLm5hbWUgPSAicm9vdGZz IjsKLQkJcGFydHNbcm9vdGZzcGFydF0ub2Zmc2V0ID0gcm9vdGZzYWRkcjsKLQkJcGFydHNbcm9v dGZzcGFydF0uc2l6ZSA9IHJvb3Rmc2xlbjsKLQkJaWYgKHNwYXJlbGVuID4gMCAgJiYgIXJvb3Rm c19maXJzdCkKLQkJCXBhcnRzW3Jvb3Rmc3BhcnRdLnNpemUgKz0gc3BhcmVsZW47Ci0JCWN1cnBh cnQrKzsKLQl9Ci0KIAlwYXJ0c1tjdXJwYXJ0XS5uYW1lID0gIm52cmFtIjsKIAlwYXJ0c1tjdXJw YXJ0XS5vZmZzZXQgPSBtYXN0ZXItPnNpemUgLSBudnJhbWxlbjsKIAlwYXJ0c1tjdXJwYXJ0XS5z aXplID0gbnZyYW1sZW47CkBAIC0yNjQsMjIgKzEzNCwxMyBAQCBzdGF0aWMgaW50IGJjbTYzeHhf cGFyc2VfY2ZlX25vcl9wYXJ0aXRpb25zKHN0cnVjdCBtdGRfaW5mbyAqbWFzdGVyLAogCXBhcnRz W2N1cnBhcnRdLm5hbWUgPSAibGludXgiOwogCXBhcnRzW2N1cnBhcnRdLm9mZnNldCA9IGNmZWxl bjsKIAlwYXJ0c1tjdXJwYXJ0XS5zaXplID0gbWFzdGVyLT5zaXplIC0gY2ZlbGVuIC0gbnZyYW1s ZW47CisJcGFydHNbY3VycGFydF0udHlwZXMgPSBiY202M3h4X2NmZV9wYXJ0X3R5cGVzOwogCiAJ Zm9yIChpID0gMDsgaSA8IG5ycGFydHM7IGkrKykKIAkJcHJfaW5mbygiUGFydGl0aW9uICVkIGlz ICVzIG9mZnNldCAlbGx4IGFuZCBsZW5ndGggJWxseFxuIiwgaSwKIAkJCXBhcnRzW2ldLm5hbWUs IHBhcnRzW2ldLm9mZnNldCwJcGFydHNbaV0uc2l6ZSk7CiAKLQlwcl9pbmZvKCJTcGFyZSBwYXJ0 aXRpb24gaXMgb2Zmc2V0ICV4IGFuZCBsZW5ndGggJXhcbiIsCXNwYXJlYWRkciwKLQkJc3BhcmVs ZW4pOwotCiAJKnBwYXJ0cyA9IHBhcnRzOwotCXJldCA9IDA7Ci0KLW91dDoKLQl2ZnJlZShidWYp OwotCi0JaWYgKHJldCkKLQkJcmV0dXJuIHJldDsKIAogCXJldHVybiBucnBhcnRzOwogfQpkaWZm IC0tZ2l0IGEvZHJpdmVycy9tdGQvcGFyc2Vycy9LY29uZmlnIGIvZHJpdmVycy9tdGQvcGFyc2Vy cy9LY29uZmlnCmluZGV4IGVlNWFiOTk0MTMyZi4uYTE3ZDc1MWFmOGRhIDEwMDY0NAotLS0gYS9k cml2ZXJzL210ZC9wYXJzZXJzL0tjb25maWcKKysrIGIvZHJpdmVycy9tdGQvcGFyc2Vycy9LY29u ZmlnCkBAIC0xLDMgKzEsMTQgQEAKK2NvbmZpZyBNVERfUEFSU0VSX0lNQUdFVEFHCisJdHJpc3Rh dGUgIlBhcnNlciBmb3IgQkNNOTYzWFggSW1hZ2UgVGFnIGZvcm1hdCBwYXJ0aXRpb25zIgorCWRl cGVuZHMgb24gQkNNNjNYWCB8fCBCTUlQU19HRU5FUklDIHx8IENPTVBJTEVfVEVTVAorCXNlbGVj dCBDUkMzMgorCWhlbHAKKwkgIEltYWdlIFRhZyBpcyB0aGUgZmlybXdhcmUgaGVhZGVyIHVzZWQg YnkgYnJvYWRjb20gb24gdGhlaXIgeERTTCBsaW5lCisJICBvZiBkZXZpY2VzLiBJdCBpcyB1c2Vk IHRvIGRlc2NyaWJlIHRoZSBvZmZzZXRzIGFuZCBsZW5ndGhzIG9mIGtlcm5lbAorCSAgYW5kIHJv b3RmcyBwYXJ0aXRpb25zLgorCSAgVGhpcyBkcml2ZXIgYWRkcyBzdXBwb3J0IGZvciBwYXJzaW5n IGEgcGFydGl0aW9uIHdpdGggYW4gSW1hZ2UgVGFnCisJICBoZWFkZXIgYW5kIGNyZWF0ZXMgdXAg dG8gdHdvIHBhcnRpdGlvbnMsIGtlcm5lbCBhbmQgcm9vdGZzLgorCiBjb25maWcgTVREX1BBUlNF Ul9UUlgKIAl0cmlzdGF0ZSAiUGFyc2VyIGZvciBUUlggZm9ybWF0IHBhcnRpdGlvbnMiCiAJZGVw ZW5kcyBvbiBNVEQgJiYgKEJDTTQ3WFggfHwgQVJDSF9CQ01fNTMwMVggfHwgQ09NUElMRV9URVNU KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvcGFyc2Vycy9NYWtlZmlsZSBiL2RyaXZlcnMvbXRk L3BhcnNlcnMvTWFrZWZpbGUKaW5kZXggNWIxYmNjM2Q5MGQ5Li4wMmQ3YTlkYjgzNzAgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvbXRkL3BhcnNlcnMvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9tdGQvcGFy c2Vycy9NYWtlZmlsZQpAQCAtMSwyICsxLDMgQEAKK29iai0kKENPTkZJR19NVERfUEFSU0VSX0lN QUdFVEFHKQkrPSBwYXJzZXJfaW1hZ2V0YWcubwogb2JqLSQoQ09ORklHX01URF9QQVJTRVJfVFJY KQkJKz0gcGFyc2VyX3RyeC5vCiBvYmotJChDT05GSUdfTVREX1NIQVJQU0xfUEFSVFMpCQkrPSBz aGFycHNscGFydC5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9wYXJzZXJzL3BhcnNlcl9pbWFn ZXRhZy5jIGIvZHJpdmVycy9tdGQvcGFyc2Vycy9wYXJzZXJfaW1hZ2V0YWcuYwpuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjgxZTJmYzcwYzg4OQotLS0gL2Rldi9udWxs CisrKyBiL2RyaXZlcnMvbXRkL3BhcnNlcnMvcGFyc2VyX2ltYWdldGFnLmMKQEAgLTAsMCArMSwy MTQgQEAKKy8qCisgKiBCQ002M1hYIENGRSBpbWFnZSB0YWcgcGFyc2VyCisgKgorICogQ29weXJp Z2h0IMKpIDIwMDYtMjAwOCAgRmxvcmlhbiBGYWluZWxsaSA8ZmxvcmlhbkBvcGVud3J0Lm9yZz4K KyAqCQkJICBNaWtlIEFsYm9uIDxtYWxib25Ab3BlbndydC5vcmc+CisgKiBDb3B5cmlnaHQgwqkg MjAwOS0yMDEwICBEYW5pZWwgRGlja2luc29uIDxvcGVud3J0QGNzaG9yZS5uZW9tYWlsYm94Lm5l dD4KKyAqIENvcHlyaWdodCDCqSAyMDExLTIwMTMgIEpvbmFzIEdvcnNraSA8am9uYXMuZ29yc2tp QGdtYWlsLmNvbT4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNh biByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9m IHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAqIHRoZSBG cmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2Us IG9yCisgKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqLworCisj ZGVmaW5lIHByX2ZtdChmbXQpIEtCVUlMRF9NT0ROQU1FICI6ICIgZm10CisKKyNpbmNsdWRlIDxs aW51eC9iY205NjN4eF90YWcuaD4KKyNpbmNsdWRlIDxsaW51eC9jcmMzMi5oPgorI2luY2x1ZGUg PGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxp bnV4L3NpemVzLmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1ZGUgPGxpbnV4L3Zt YWxsb2MuaD4KKyNpbmNsdWRlIDxsaW51eC9tdGQvbXRkLmg+CisjaW5jbHVkZSA8bGludXgvbXRk L3BhcnRpdGlvbnMuaD4KKworLyogRW5zdXJlIHN0cmluZ3MgcmVhZCBmcm9tIGZsYXNoIHN0cnVj dHMgYXJlIG51bGwgdGVybWluYXRlZCAqLworI2RlZmluZSBTVFJfTlVMTF9URVJNSU5BVEUoeCkg XAorCWRvIHsgY2hhciAqX3N0ciA9ICh4KTsgX3N0cltzaXplb2YoeCkgLSAxXSA9IDA7IH0gd2hp bGUgKDApCisKK3N0YXRpYyBpbnQgYmNtOTYzeHhfcmVhZF9pbWFnZXRhZyhzdHJ1Y3QgbXRkX2lu Zm8gKm1hc3RlciwgY29uc3QgY2hhciAqbmFtZSwKKwlsb2ZmX3QgdGFnX29mZnNldCwgc3RydWN0 IGJjbV90YWcgKmJ1ZikKK3sKKwlpbnQgcmV0OworCXNpemVfdCByZXRsZW47CisJdTMyIGNvbXB1 dGVkX2NyYzsKKworCXJldCA9IG10ZF9yZWFkKG1hc3RlciwgdGFnX29mZnNldCwgc2l6ZW9mKCpi dWYpLCAmcmV0bGVuLCAodm9pZCAqKWJ1Zik7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKwor CWlmIChyZXRsZW4gIT0gc2l6ZW9mKCpidWYpKQorCQlyZXR1cm4gLUVJTzsKKworCWNvbXB1dGVk X2NyYyA9IGNyYzMyX2xlKElNQUdFVEFHX0NSQ19TVEFSVCwgKHU4ICopYnVmLAorCQkJCW9mZnNl dG9mKHN0cnVjdCBiY21fdGFnLCBoZWFkZXJfY3JjKSk7CisJaWYgKGNvbXB1dGVkX2NyYyA9PSBi dWYtPmhlYWRlcl9jcmMpIHsKKwkJU1RSX05VTExfVEVSTUlOQVRFKGJ1Zi0+Ym9hcmRfaWQpOwor CQlTVFJfTlVMTF9URVJNSU5BVEUoYnVmLT50YWdfdmVyc2lvbik7CisKKwkJcHJfaW5mbygiJXM6 IENGRSBpbWFnZSB0YWcgZm91bmQgYXQgMHglbGx4IHdpdGggdmVyc2lvbiAlcywgYm9hcmQgdHlw ZSAlc1xuIiwKKwkJCW5hbWUsIHRhZ19vZmZzZXQsIGJ1Zi0+dGFnX3ZlcnNpb24sIGJ1Zi0+Ym9h cmRfaWQpOworCisJCXJldHVybiAwOworCX0KKworCXByX3dhcm4oIiVzOiBDRkUgaW1hZ2UgdGFn IGF0IDB4JWxseCBDUkMgaW52YWxpZCAoZXhwZWN0ZWQgJTA4eCwgYWN0dWFsICUwOHgpXG4iLAor CQluYW1lLCB0YWdfb2Zmc2V0LCBidWYtPmhlYWRlcl9jcmMsIGNvbXB1dGVkX2NyYyk7CisJcmV0 dXJuIC1FSU5WQUw7Cit9CisKK3N0YXRpYyBpbnQgYmNtOTYzeHhfcGFyc2VfaW1hZ2V0YWdfcGFy dGl0aW9ucyhzdHJ1Y3QgbXRkX2luZm8gKm1hc3RlciwKKwkJCQkJY29uc3Qgc3RydWN0IG10ZF9w YXJ0aXRpb24gKipwcGFydHMsCisJCQkJCXN0cnVjdCBtdGRfcGFydF9wYXJzZXJfZGF0YSAqZGF0 YSkKK3sKKwkvKiBDRkUsIE5WUkFNIGFuZCBnbG9iYWwgTGludXggYXJlIGFsd2F5cyBwcmVzZW50 ICovCisJaW50IG5ycGFydHMgPSAwLCBjdXJwYXJ0ID0gMDsKKwlzdHJ1Y3QgYmNtX3RhZyAqYnVm ID0gTlVMTDsKKwlzdHJ1Y3QgbXRkX3BhcnRpdGlvbiAqcGFydHM7CisJaW50IHJldDsKKwl1bnNp Z25lZCBpbnQgcm9vdGZzYWRkciwga2VybmVsYWRkciwgc3BhcmVhZGRyLCBvZmZzZXQ7CisJdW5z aWduZWQgaW50IHJvb3Rmc2xlbiwga2VybmVsbGVuLCBzcGFyZWxlbiwgdG90YWxsZW47CisJaW50 IGk7CisJYm9vbCByb290ZnNfZmlyc3QgPSBmYWxzZTsKKworCWJ1ZiA9IHZtYWxsb2Moc2l6ZW9m KHN0cnVjdCBiY21fdGFnKSk7CisJaWYgKCFidWYpCisJCXJldHVybiAtRU5PTUVNOworCisJLyog R2V0IHRoZSB0YWcgKi8KKwlyZXQgPSBiY205NjN4eF9yZWFkX2ltYWdldGFnKG1hc3RlciwgInJv b3RmcyIsIDAsIGJ1Zik7CisJaWYgKCFyZXQpIHsKKwkJU1RSX05VTExfVEVSTUlOQVRFKGJ1Zi0+ Zmxhc2hfaW1hZ2Vfc3RhcnQpOworCQlpZiAoa3N0cnRvdWludChidWYtPmZsYXNoX2ltYWdlX3N0 YXJ0LCAxMCwgJnJvb3Rmc2FkZHIpIHx8CisJCQkJcm9vdGZzYWRkciA8IEJDTTk2M1hYX0VYVEVO REVEX1NJWkUpIHsKKwkJCXByX2VycigiaW52YWxpZCByb290ZnMgYWRkcmVzczogJSpwaFxuIiwK KwkJCQkoaW50KXNpemVvZihidWYtPmZsYXNoX2ltYWdlX3N0YXJ0KSwKKwkJCQlidWYtPmZsYXNo X2ltYWdlX3N0YXJ0KTsKKwkJCWdvdG8gb3V0OworCQl9CisKKwkJU1RSX05VTExfVEVSTUlOQVRF KGJ1Zi0+a2VybmVsX2FkZHJlc3MpOworCQlpZiAoa3N0cnRvdWludChidWYtPmtlcm5lbF9hZGRy ZXNzLCAxMCwgJmtlcm5lbGFkZHIpIHx8CisJCQkJa2VybmVsYWRkciA8IEJDTTk2M1hYX0VYVEVO REVEX1NJWkUpIHsKKwkJCXByX2VycigiaW52YWxpZCBrZXJuZWwgYWRkcmVzczogJSpwaFxuIiwK KwkJCQkoaW50KXNpemVvZihidWYtPmtlcm5lbF9hZGRyZXNzKSwKKwkJCQlidWYtPmtlcm5lbF9h ZGRyZXNzKTsKKwkJCWdvdG8gb3V0OworCQl9CisKKwkJU1RSX05VTExfVEVSTUlOQVRFKGJ1Zi0+ a2VybmVsX2xlbmd0aCk7CisJCWlmIChrc3RydG91aW50KGJ1Zi0+a2VybmVsX2xlbmd0aCwgMTAs ICZrZXJuZWxsZW4pKSB7CisJCQlwcl9lcnIoImludmFsaWQga2VybmVsIGxlbmd0aDogJSpwaFxu IiwKKwkJCQkoaW50KXNpemVvZihidWYtPmtlcm5lbF9sZW5ndGgpLAorCQkJCWJ1Zi0+a2VybmVs X2xlbmd0aCk7CisJCQlnb3RvIG91dDsKKwkJfQorCisJCVNUUl9OVUxMX1RFUk1JTkFURShidWYt PnRvdGFsX2xlbmd0aCk7CisJCWlmIChrc3RydG91aW50KGJ1Zi0+dG90YWxfbGVuZ3RoLCAxMCwg JnRvdGFsbGVuKSkgeworCQkJcHJfZXJyKCJpbnZhbGlkIHRvdGFsIGxlbmd0aDogJSpwaFxuIiwK KwkJCQkoaW50KXNpemVvZihidWYtPnRvdGFsX2xlbmd0aCksCisJCQkJYnVmLT50b3RhbF9sZW5n dGgpOworCQkJZ290byBvdXQ7CisJCX0KKworCQkvKgorCQkgKiBBZGRyZXNzZXMgYXJlIGZsYXNo IGFic29sdXRlLCBzbyBjb252ZXJ0IHRvIHBhcnRpdGlvbgorCQkgKiByZWxhdGl2ZSBhZGRyZXNz ZXMuIEFzc3VtZSBlaXRoZXIga2VybmVsIG9yIHJvb3RmcyB3aWxsCisJCSAqIGRpcmVjdGx5IGZv bGxvdyB0aGUgaW1hZ2UgdGFnLgorCQkgKi8KKwkJaWYgKHJvb3Rmc2FkZHIgPCBrZXJuZWxhZGRy KQorCQkJb2Zmc2V0ID0gcm9vdGZzYWRkciAtIHNpemVvZihzdHJ1Y3QgYmNtX3RhZyk7CisJCWVs c2UKKwkJCW9mZnNldCA9IGtlcm5lbGFkZHIgLSBzaXplb2Yoc3RydWN0IGJjbV90YWcpOworCisJ CWtlcm5lbGFkZHIgPSBrZXJuZWxhZGRyIC0gb2Zmc2V0OworCQlyb290ZnNhZGRyID0gcm9vdGZz YWRkciAtIG9mZnNldDsKKwkJc3BhcmVhZGRyID0gcm91bmR1cCh0b3RhbGxlbiwgbWFzdGVyLT5l cmFzZXNpemUpOworCisJCWlmIChyb290ZnNhZGRyIDwga2VybmVsYWRkcikgeworCQkJLyogZGVm YXVsdCBCcm9hZGNvbSBsYXlvdXQgKi8KKwkJCXJvb3Rmc2xlbiA9IGtlcm5lbGFkZHIgLSByb290 ZnNhZGRyOworCQkJcm9vdGZzX2ZpcnN0ID0gdHJ1ZTsKKwkJfSBlbHNlIHsKKwkJCS8qIE9wZW5X cnQgbGF5b3V0ICovCisJCQlyb290ZnNhZGRyID0ga2VybmVsYWRkciArIGtlcm5lbGxlbjsKKwkJ CXJvb3Rmc2xlbiA9IHNwYXJlYWRkciAtIHJvb3Rmc2FkZHI7CisJCX0KKwl9IGVsc2UgeworCQln b3RvIG91dDsKKwl9CisJc3BhcmVsZW4gPSBtYXN0ZXItPnNpemUgLSBzcGFyZWFkZHI7CisKKwkv KiBEZXRlcm1pbmUgbnVtYmVyIG9mIHBhcnRpdGlvbnMgKi8KKwlpZiAocm9vdGZzbGVuID4gMCkK KwkJbnJwYXJ0cysrOworCisJaWYgKGtlcm5lbGxlbiA+IDApCisJCW5ycGFydHMrKzsKKworCXBh cnRzID0ga3phbGxvYyhzaXplb2YoKnBhcnRzKSAqIG5ycGFydHMgKyAxMCAqIG5ycGFydHMsIEdG UF9LRVJORUwpOworCWlmICghcGFydHMpIHsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBvdXQ7 CisJfQorCisJLyogU3RhcnQgYnVpbGRpbmcgcGFydGl0aW9uIGxpc3QgKi8KKwlpZiAoa2VybmVs bGVuID4gMCkgeworCQlpbnQga2VybmVscGFydCA9IGN1cnBhcnQ7CisKKwkJaWYgKHJvb3Rmc2xl biA+IDAgJiYgcm9vdGZzX2ZpcnN0KQorCQkJa2VybmVscGFydCsrOworCQlwYXJ0c1trZXJuZWxw YXJ0XS5uYW1lID0gImtlcm5lbCI7CisJCXBhcnRzW2tlcm5lbHBhcnRdLm9mZnNldCA9IGtlcm5l bGFkZHI7CisJCXBhcnRzW2tlcm5lbHBhcnRdLnNpemUgPSBrZXJuZWxsZW47CisJCWN1cnBhcnQr KzsKKwl9CisKKwlpZiAocm9vdGZzbGVuID4gMCkgeworCQlpbnQgcm9vdGZzcGFydCA9IGN1cnBh cnQ7CisKKwkJaWYgKGtlcm5lbGxlbiA+IDAgJiYgcm9vdGZzX2ZpcnN0KQorCQkJcm9vdGZzcGFy dC0tOworCQlwYXJ0c1tyb290ZnNwYXJ0XS5uYW1lID0gInJvb3RmcyI7CisJCXBhcnRzW3Jvb3Rm c3BhcnRdLm9mZnNldCA9IHJvb3Rmc2FkZHI7CisJCXBhcnRzW3Jvb3Rmc3BhcnRdLnNpemUgPSBy b290ZnNsZW47CisJCWlmIChzcGFyZWxlbiA+IDAgICYmICFyb290ZnNfZmlyc3QpCisJCQlwYXJ0 c1tyb290ZnNwYXJ0XS5zaXplICs9IHNwYXJlbGVuOworCQljdXJwYXJ0Kys7CisJfQorCisJZm9y IChpID0gMDsgaSA8IG5ycGFydHM7IGkrKykKKwkJcHJfaW5mbygiUGFydGl0aW9uICVkIGlzICVz IG9mZnNldCAlbGx4IGFuZCBsZW5ndGggJWxseFxuIiwgaSwKKwkJCXBhcnRzW2ldLm5hbWUsIHBh cnRzW2ldLm9mZnNldCwJcGFydHNbaV0uc2l6ZSk7CisKKwlwcl9pbmZvKCJTcGFyZSBwYXJ0aXRp b24gaXMgb2Zmc2V0ICV4IGFuZCBsZW5ndGggJXhcbiIsCXNwYXJlYWRkciwKKwkJc3BhcmVsZW4p OworCisJKnBwYXJ0cyA9IHBhcnRzOworCXJldCA9IDA7CisKK291dDoKKwl2ZnJlZShidWYpOwor CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCXJldHVybiBucnBhcnRzOworfQorCitzdGF0 aWMgc3RydWN0IG10ZF9wYXJ0X3BhcnNlciBiY205NjN4eF9pbWFnZXRhZ19wYXJzZXIgPSB7CisJ LnBhcnNlX2ZuID0gYmNtOTYzeHhfcGFyc2VfaW1hZ2V0YWdfcGFydGl0aW9ucywKKwkubmFtZSA9 ICJiY205NjN4eC1pbWFnZXRhZyIsCit9OworbW9kdWxlX210ZF9wYXJ0X3BhcnNlcihiY205NjN4 eF9pbWFnZXRhZ19wYXJzZXIpOworCitNT0RVTEVfTElDRU5TRSgiR1BMIik7CitNT0RVTEVfQVVU SE9SKCJEYW5pZWwgRGlja2luc29uIDxvcGVud3J0QGNzaG9yZS5uZW9tYWlsYm94Lm5ldD4iKTsK K01PRFVMRV9BVVRIT1IoIkZsb3JpYW4gRmFpbmVsbGkgPGZsb3JpYW5Ab3BlbndydC5vcmc+Iik7 CitNT0RVTEVfQVVUSE9SKCJNaWtlIEFsYm9uIDxtYWxib25Ab3BlbndydC5vcmc+Iik7CitNT0RV TEVfQVVUSE9SKCJKb25hcyBHb3Jza2kgPGpvbmFzLmdvcnNraUBnbWFpbC5jb20iKTsKK01PRFVM RV9ERVNDUklQVElPTigiTVREIHBhcnNlciBmb3IgQkNNOTYzWFggQ0ZFIEltYWdlIFRhZyBwYXJ0 aXRpb25zIik7Ci0tIAoyLjEzLjIKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KTGludXggTVREIGRpc2N1c3Npb24gbWFpbGluZyBsaXN0Cmh0 dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtbXRkLwo= From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-wr1-x442.google.com ([2a00:1450:4864:20::442]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1fuc2j-000416-Gv for linux-mtd@lists.infradead.org; Tue, 28 Aug 2018 11:20:21 +0000 Received: by mail-wr1-x442.google.com with SMTP id w11-v6so1212242wrc.5 for ; Tue, 28 Aug 2018 04:20:05 -0700 (PDT) From: Jonas Gorski To: linux-mtd@lists.infradead.org, devicetree@vger.kernel.org Cc: David Woodhouse , Brian Norris , Boris Brezillon , Marek Vasut , Richard Weinberger , Rob Herring , Mark Rutland , Florian Fainelli Subject: [PATCH 3/5] mtd: bcm63xxpart: move imagetag parsing to its own parser Date: Tue, 28 Aug 2018 13:19:42 +0200 Message-Id: <20180828111944.5956-4-jonas.gorski@gmail.com> In-Reply-To: <20180828111944.5956-1-jonas.gorski@gmail.com> References: <20180828111944.5956-1-jonas.gorski@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: , Move the bcm963xx Image Tag parsing into its own partition parser. This Allows reusing the parser with different full flash parsers. While moving it, rename it to bcm963* to better reflect it isn't chip, but reference implementation specific. Signed-off-by: Jonas Gorski --- drivers/mtd/Kconfig | 1 + drivers/mtd/bcm63xxpart.c | 155 ++---------------------- drivers/mtd/parsers/Kconfig | 11 ++ drivers/mtd/parsers/Makefile | 1 + drivers/mtd/parsers/parser_imagetag.c | 214 ++++++++++++++++++++++++++++++++++ 5 files changed, 235 insertions(+), 147 deletions(-) create mode 100644 drivers/mtd/parsers/parser_imagetag.c diff --git a/drivers/mtd/Kconfig b/drivers/mtd/Kconfig index c77f537323ec..a3bd0e315990 100644 --- a/drivers/mtd/Kconfig +++ b/drivers/mtd/Kconfig @@ -143,6 +143,7 @@ config MTD_BCM63XX_PARTS tristate "BCM63XX CFE partitioning support" depends on BCM63XX || BMIPS_GENERIC || COMPILE_TEST select CRC32 + select MTD_PARSER_IMAGETAG help This provides partions parsing for BCM63xx devices with CFE bootloaders. diff --git a/drivers/mtd/bcm63xxpart.c b/drivers/mtd/bcm63xxpart.c index f639b4c960f0..b2bd04764e95 100644 --- a/drivers/mtd/bcm63xxpart.c +++ b/drivers/mtd/bcm63xxpart.c @@ -94,51 +94,19 @@ static int bcm63xx_read_nvram(struct mtd_info *master, return 0; } -static int bcm63xx_read_image_tag(struct mtd_info *master, const char *name, - loff_t tag_offset, struct bcm_tag *buf) -{ - int ret; - size_t retlen; - u32 computed_crc; - - ret = mtd_read(master, tag_offset, sizeof(*buf), &retlen, (void *)buf); - if (ret) - return ret; - - if (retlen != sizeof(*buf)) - return -EIO; - - computed_crc = crc32_le(IMAGETAG_CRC_START, (u8 *)buf, - offsetof(struct bcm_tag, header_crc)); - if (computed_crc == buf->header_crc) { - STR_NULL_TERMINATE(buf->board_id); - STR_NULL_TERMINATE(buf->tag_version); - - pr_info("%s: CFE image tag found at 0x%llx with version %s, board type %s\n", - name, tag_offset, buf->tag_version, buf->board_id); - - return 0; - } - - pr_warn("%s: CFE image tag at 0x%llx CRC invalid (expected %08x, actual %08x)\n", - name, tag_offset, buf->header_crc, computed_crc); - return 1; -} +static const char * const bcm63xx_cfe_part_types[] = { + "bcm963xx-imagetag", + NULL, +}; static int bcm63xx_parse_cfe_nor_partitions(struct mtd_info *master, const struct mtd_partition **pparts, struct bcm963xx_nvram *nvram) { - /* CFE, NVRAM and global Linux are always present */ - int nrparts = 3, curpart = 0; - struct bcm_tag *buf = NULL; struct mtd_partition *parts; - int ret; - unsigned int rootfsaddr, kerneladdr, spareaddr; - unsigned int rootfslen, kernellen, sparelen, totallen; + int nrparts = 3, curpart = 0; unsigned int cfelen, nvramlen; unsigned int cfe_erasesize; int i; - bool rootfs_first = false; cfe_erasesize = max_t(uint32_t, master->erasesize, BCM963XX_CFE_BLOCK_SIZE); @@ -147,83 +115,9 @@ static int bcm63xx_parse_cfe_nor_partitions(struct mtd_info *master, nvramlen = nvram->psi_size * SZ_1K; nvramlen = roundup(nvramlen, cfe_erasesize); - buf = vmalloc(sizeof(struct bcm_tag)); - if (!buf) - return -ENOMEM; - - /* Get the tag */ - ret = bcm63xx_read_image_tag(master, "rootfs", cfelen, buf); - if (!ret) { - STR_NULL_TERMINATE(buf->flash_image_start); - if (kstrtouint(buf->flash_image_start, 10, &rootfsaddr) || - rootfsaddr < BCM963XX_EXTENDED_SIZE) { - pr_err("invalid rootfs address: %*ph\n", - (int)sizeof(buf->flash_image_start), - buf->flash_image_start); - goto invalid_tag; - } - - STR_NULL_TERMINATE(buf->kernel_address); - if (kstrtouint(buf->kernel_address, 10, &kerneladdr) || - kerneladdr < BCM963XX_EXTENDED_SIZE) { - pr_err("invalid kernel address: %*ph\n", - (int)sizeof(buf->kernel_address), - buf->kernel_address); - goto invalid_tag; - } - - STR_NULL_TERMINATE(buf->kernel_length); - if (kstrtouint(buf->kernel_length, 10, &kernellen)) { - pr_err("invalid kernel length: %*ph\n", - (int)sizeof(buf->kernel_length), - buf->kernel_length); - goto invalid_tag; - } - - STR_NULL_TERMINATE(buf->total_length); - if (kstrtouint(buf->total_length, 10, &totallen)) { - pr_err("invalid total length: %*ph\n", - (int)sizeof(buf->total_length), - buf->total_length); - goto invalid_tag; - } - - kerneladdr = kerneladdr - BCM963XX_EXTENDED_SIZE; - rootfsaddr = rootfsaddr - BCM963XX_EXTENDED_SIZE; - spareaddr = roundup(totallen, master->erasesize) + cfelen; - - if (rootfsaddr < kerneladdr) { - /* default Broadcom layout */ - rootfslen = kerneladdr - rootfsaddr; - rootfs_first = true; - } else { - /* OpenWrt layout */ - rootfsaddr = kerneladdr + kernellen; - rootfslen = spareaddr - rootfsaddr; - } - } else if (ret > 0) { -invalid_tag: - kernellen = 0; - rootfslen = 0; - rootfsaddr = 0; - spareaddr = cfelen; - } else { - goto out; - } - sparelen = master->size - spareaddr - nvramlen; - - /* Determine number of partitions */ - if (rootfslen > 0) - nrparts++; - - if (kernellen > 0) - nrparts++; - parts = kzalloc(sizeof(*parts) * nrparts + 10 * nrparts, GFP_KERNEL); - if (!parts) { - ret = -ENOMEM; - goto out; - } + if (!parts) + return -ENOMEM; /* Start building partition list */ parts[curpart].name = "CFE"; @@ -231,30 +125,6 @@ static int bcm63xx_parse_cfe_nor_partitions(struct mtd_info *master, parts[curpart].size = cfelen; curpart++; - if (kernellen > 0) { - int kernelpart = curpart; - - if (rootfslen > 0 && rootfs_first) - kernelpart++; - parts[kernelpart].name = "kernel"; - parts[kernelpart].offset = kerneladdr; - parts[kernelpart].size = kernellen; - curpart++; - } - - if (rootfslen > 0) { - int rootfspart = curpart; - - if (kernellen > 0 && rootfs_first) - rootfspart--; - parts[rootfspart].name = "rootfs"; - parts[rootfspart].offset = rootfsaddr; - parts[rootfspart].size = rootfslen; - if (sparelen > 0 && !rootfs_first) - parts[rootfspart].size += sparelen; - curpart++; - } - parts[curpart].name = "nvram"; parts[curpart].offset = master->size - nvramlen; parts[curpart].size = nvramlen; @@ -264,22 +134,13 @@ static int bcm63xx_parse_cfe_nor_partitions(struct mtd_info *master, parts[curpart].name = "linux"; parts[curpart].offset = cfelen; parts[curpart].size = master->size - cfelen - nvramlen; + parts[curpart].types = bcm63xx_cfe_part_types; for (i = 0; i < nrparts; i++) pr_info("Partition %d is %s offset %llx and length %llx\n", i, parts[i].name, parts[i].offset, parts[i].size); - pr_info("Spare partition is offset %x and length %x\n", spareaddr, - sparelen); - *pparts = parts; - ret = 0; - -out: - vfree(buf); - - if (ret) - return ret; return nrparts; } diff --git a/drivers/mtd/parsers/Kconfig b/drivers/mtd/parsers/Kconfig index ee5ab994132f..a17d751af8da 100644 --- a/drivers/mtd/parsers/Kconfig +++ b/drivers/mtd/parsers/Kconfig @@ -1,3 +1,14 @@ +config MTD_PARSER_IMAGETAG + tristate "Parser for BCM963XX Image Tag format partitions" + depends on BCM63XX || BMIPS_GENERIC || COMPILE_TEST + select CRC32 + help + Image Tag is the firmware header used by broadcom on their xDSL line + of devices. It is used to describe the offsets and lengths of kernel + and rootfs partitions. + This driver adds support for parsing a partition with an Image Tag + header and creates up to two partitions, kernel and rootfs. + config MTD_PARSER_TRX tristate "Parser for TRX format partitions" depends on MTD && (BCM47XX || ARCH_BCM_5301X || COMPILE_TEST) diff --git a/drivers/mtd/parsers/Makefile b/drivers/mtd/parsers/Makefile index 5b1bcc3d90d9..02d7a9db8370 100644 --- a/drivers/mtd/parsers/Makefile +++ b/drivers/mtd/parsers/Makefile @@ -1,2 +1,3 @@ +obj-$(CONFIG_MTD_PARSER_IMAGETAG) += parser_imagetag.o obj-$(CONFIG_MTD_PARSER_TRX) += parser_trx.o obj-$(CONFIG_MTD_SHARPSL_PARTS) += sharpslpart.o diff --git a/drivers/mtd/parsers/parser_imagetag.c b/drivers/mtd/parsers/parser_imagetag.c new file mode 100644 index 000000000000..81e2fc70c889 --- /dev/null +++ b/drivers/mtd/parsers/parser_imagetag.c @@ -0,0 +1,214 @@ +/* + * BCM63XX CFE image tag parser + * + * Copyright © 2006-2008 Florian Fainelli + * Mike Albon + * Copyright © 2009-2010 Daniel Dickinson + * Copyright © 2011-2013 Jonas Gorski + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* Ensure strings read from flash structs are null terminated */ +#define STR_NULL_TERMINATE(x) \ + do { char *_str = (x); _str[sizeof(x) - 1] = 0; } while (0) + +static int bcm963xx_read_imagetag(struct mtd_info *master, const char *name, + loff_t tag_offset, struct bcm_tag *buf) +{ + int ret; + size_t retlen; + u32 computed_crc; + + ret = mtd_read(master, tag_offset, sizeof(*buf), &retlen, (void *)buf); + if (ret) + return ret; + + if (retlen != sizeof(*buf)) + return -EIO; + + computed_crc = crc32_le(IMAGETAG_CRC_START, (u8 *)buf, + offsetof(struct bcm_tag, header_crc)); + if (computed_crc == buf->header_crc) { + STR_NULL_TERMINATE(buf->board_id); + STR_NULL_TERMINATE(buf->tag_version); + + pr_info("%s: CFE image tag found at 0x%llx with version %s, board type %s\n", + name, tag_offset, buf->tag_version, buf->board_id); + + return 0; + } + + pr_warn("%s: CFE image tag at 0x%llx CRC invalid (expected %08x, actual %08x)\n", + name, tag_offset, buf->header_crc, computed_crc); + return -EINVAL; +} + +static int bcm963xx_parse_imagetag_partitions(struct mtd_info *master, + const struct mtd_partition **pparts, + struct mtd_part_parser_data *data) +{ + /* CFE, NVRAM and global Linux are always present */ + int nrparts = 0, curpart = 0; + struct bcm_tag *buf = NULL; + struct mtd_partition *parts; + int ret; + unsigned int rootfsaddr, kerneladdr, spareaddr, offset; + unsigned int rootfslen, kernellen, sparelen, totallen; + int i; + bool rootfs_first = false; + + buf = vmalloc(sizeof(struct bcm_tag)); + if (!buf) + return -ENOMEM; + + /* Get the tag */ + ret = bcm963xx_read_imagetag(master, "rootfs", 0, buf); + if (!ret) { + STR_NULL_TERMINATE(buf->flash_image_start); + if (kstrtouint(buf->flash_image_start, 10, &rootfsaddr) || + rootfsaddr < BCM963XX_EXTENDED_SIZE) { + pr_err("invalid rootfs address: %*ph\n", + (int)sizeof(buf->flash_image_start), + buf->flash_image_start); + goto out; + } + + STR_NULL_TERMINATE(buf->kernel_address); + if (kstrtouint(buf->kernel_address, 10, &kerneladdr) || + kerneladdr < BCM963XX_EXTENDED_SIZE) { + pr_err("invalid kernel address: %*ph\n", + (int)sizeof(buf->kernel_address), + buf->kernel_address); + goto out; + } + + STR_NULL_TERMINATE(buf->kernel_length); + if (kstrtouint(buf->kernel_length, 10, &kernellen)) { + pr_err("invalid kernel length: %*ph\n", + (int)sizeof(buf->kernel_length), + buf->kernel_length); + goto out; + } + + STR_NULL_TERMINATE(buf->total_length); + if (kstrtouint(buf->total_length, 10, &totallen)) { + pr_err("invalid total length: %*ph\n", + (int)sizeof(buf->total_length), + buf->total_length); + goto out; + } + + /* + * Addresses are flash absolute, so convert to partition + * relative addresses. Assume either kernel or rootfs will + * directly follow the image tag. + */ + if (rootfsaddr < kerneladdr) + offset = rootfsaddr - sizeof(struct bcm_tag); + else + offset = kerneladdr - sizeof(struct bcm_tag); + + kerneladdr = kerneladdr - offset; + rootfsaddr = rootfsaddr - offset; + spareaddr = roundup(totallen, master->erasesize); + + if (rootfsaddr < kerneladdr) { + /* default Broadcom layout */ + rootfslen = kerneladdr - rootfsaddr; + rootfs_first = true; + } else { + /* OpenWrt layout */ + rootfsaddr = kerneladdr + kernellen; + rootfslen = spareaddr - rootfsaddr; + } + } else { + goto out; + } + sparelen = master->size - spareaddr; + + /* Determine number of partitions */ + if (rootfslen > 0) + nrparts++; + + if (kernellen > 0) + nrparts++; + + parts = kzalloc(sizeof(*parts) * nrparts + 10 * nrparts, GFP_KERNEL); + if (!parts) { + ret = -ENOMEM; + goto out; + } + + /* Start building partition list */ + if (kernellen > 0) { + int kernelpart = curpart; + + if (rootfslen > 0 && rootfs_first) + kernelpart++; + parts[kernelpart].name = "kernel"; + parts[kernelpart].offset = kerneladdr; + parts[kernelpart].size = kernellen; + curpart++; + } + + if (rootfslen > 0) { + int rootfspart = curpart; + + if (kernellen > 0 && rootfs_first) + rootfspart--; + parts[rootfspart].name = "rootfs"; + parts[rootfspart].offset = rootfsaddr; + parts[rootfspart].size = rootfslen; + if (sparelen > 0 && !rootfs_first) + parts[rootfspart].size += sparelen; + curpart++; + } + + for (i = 0; i < nrparts; i++) + pr_info("Partition %d is %s offset %llx and length %llx\n", i, + parts[i].name, parts[i].offset, parts[i].size); + + pr_info("Spare partition is offset %x and length %x\n", spareaddr, + sparelen); + + *pparts = parts; + ret = 0; + +out: + vfree(buf); + + if (ret) + return ret; + + return nrparts; +} + +static struct mtd_part_parser bcm963xx_imagetag_parser = { + .parse_fn = bcm963xx_parse_imagetag_partitions, + .name = "bcm963xx-imagetag", +}; +module_mtd_part_parser(bcm963xx_imagetag_parser); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Daniel Dickinson "); +MODULE_AUTHOR("Florian Fainelli "); +MODULE_AUTHOR("Mike Albon "); +MODULE_AUTHOR("Jonas Gorski