From mboxrd@z Thu Jan 1 00:00:00 1970 From: Abhishek Sahu Subject: [PATCH v4 14/15] mtd: rawnand: qcom: erased page bitflips detection Date: Wed, 20 Jun 2018 12:57:41 +0530 Message-ID: <1529479662-4026-15-git-send-email-absahu@codeaurora.org> References: <1529479662-4026-1-git-send-email-absahu@codeaurora.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1529479662-4026-1-git-send-email-absahu@codeaurora.org> 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: Boris Brezillon , Miquel Raynal Cc: Archit Taneja , linux-arm-msm@vger.kernel.org, linux-kernel@vger.kernel.org, Marek Vasut , Abhishek Sahu , linux-mtd@lists.infradead.org, Richard Weinberger , Andy Gross , Brian Norris , David Woodhouse List-Id: linux-arm-msm@vger.kernel.org TkFORCBwYXJ0cyBjYW4gaGF2ZSBiaXRmbGlwcyBpbiBhbiBlcmFzZWQgcGFnZSBkdWUgdG8gdGhl CnByb2Nlc3MgdGVjaG5vbG9neSB1c2VkLiBJbiB0aGlzIGNhc2UsIFFDT00gTkFORCBjb250cm9s bGVyCmlzIG5vdCBhYmxlIHRvIGlkZW50aWZ5IHRoYXQgcGFnZSBhcyBhbiBlcmFzZWQgcGFnZS4K Q3VycmVudGx5IHRoZSBkcml2ZXIgY2FsbHMgbmFuZF9jaGVja19lcmFzZWRfZWNjX2NodW5rKCkg Zm9yCmlkZW50aWZ5aW5nIHRoZSBlcmFzZWQgcGFnZXMgYnV0IHRoaXMgd29u4oCZdCB3b3JrIGFs d2F5cyBzaW5jZSB0aGUKY2hlY2tpbmcgaXMgYmVpbmcgd2l0aCBFQ0MgZW5naW5lIHJldHVybmVk IGRhdGEuIEluIGNhc2Ugb2YKYml0ZmxpcHMsIHRoZSBFQ0MgZW5naW5lIHRyaWVzIHRvIGNvcnJl Y3QgdGhlIGRhdGEgYW5kIHRoZW4gaXQKZ2VuZXJhdGVzIHRoZSB1bmNvcnJlY3RhYmxlIGVycm9y LiBOb3csIHRoaXMgZGF0YSBpcyBub3QgZXF1YWwgdG8Kb3JpZ2luYWwgcmF3IGRhdGEuIEZvciBl cmFzZWQgQ1cgaWRlbnRpZmljYXRpb24sIHRoZSByYXcgZGF0YQpzaG91bGQgYmUgcmVhZCBhZ2Fp biBmcm9tIE5BTkQgZGV2aWNlIGFuZCB0aGlzCm5hbmRfY2hlY2tfZXJhc2VkX2VjY19jaHVuayBm dW5jdGlvbigpIHNob3VsZCBiZSBjYWxsZWQgZm9yIHJhdwpkYXRhIG9ubHkuCgpOb3cgZm9sbG93 aW5nIGxvZ2ljIGlzIGJlaW5nIGFkZGVkIHRvIGlkZW50aWZ5IHRoZSBlcmFzZWQKY29kZXdvcmQg Yml0ZmxpcHMuCgoxLiBJbiBtb3N0IG9mIHRoZSBjYXNlcywgbm90IGFsbCB0aGUgY29kZXdvcmRz IHdpbGwgaGF2ZSBiaXRmbGlwcwogICBhbmQgb25seSBzaW5nbGUgQ1cgd2lsbCBoYXZlIGJpdGZs aXBzLiBTbywgdGhlcmUgaXMgbm8gbmVlZCB0bwogICByZWFkIHRoZSBjb21wbGV0ZSByYXcgcGFn ZSBkYXRhLiBUaGUgTkFORCByYXcgcmVhZCBjYW4gYmUKICAgc2NoZWR1bGVkIGZvciBhbnkgQ1cg aW4gcGFnZS4gVGhlIE5BTkQgY29udHJvbGxlciB3b3JrcyBvbiBDVwogICBiYXNpcyBhbmQgaXQg d2lsbCB1cGRhdGUgdGhlIHN0YXR1cyByZWdpc3RlciBhZnRlciBlYWNoIENXIHJlYWQuCiAgIE1h aW50YWluIHRoZSBiaXRtYXNrIGZvciB0aGUgQ1cgd2hpY2ggZ2VuZXJhdGVkIHRoZSB1bmNvcnJl Y3RhYmxlCiAgIGVycm9yLgoyLiBEbyByYXcgcmVhZCBmb3IgYWxsIHRoZSBDVydzIHdoaWNoIGdl bmVyYXRlZCB0aGUgdW5jb3JyZWN0YWJsZQogICBlcnJvci4KMy4gQm90aCBEQVRBIGFuZCBPT0Ig bmVlZCB0byBiZSBjaGVja2VkIGZvciBudW1iZXIgb2YgMC4gVGhlCiAgIHRvcC1sZXZlbCBBUEkg Y2FuIGJlIGNhbGxlZCB3aXRoIG9ubHkgZGF0YSBidWYgb3IgT09CIGJ1ZiBzbyB1c2UKICAgY2hp cC0+ZGF0YWJ1ZiBpZiBkYXRhIGJ1ZiBpcyBudWxsIGFuZCBjaGlwLT5vb2JfcG9pIGlmCiAgIE9P QiBidWYgaXMgbnVsbCBmb3IgY29weWluZyB0aGUgcmF3IGJ5dGVzIHRlbXBvcmFyaWx5Lgo0LiBG b3IgZWFjaCBDVywgY2hlY2sgdGhlIG51bWJlciBvZiAwIGluIGN3X2RhdGEgYW5kIHVzYWJsZQog ICBvb2IgYnl0ZXMsIFRoZSBiYm0gYW5kIHNwYXJlICh1bnVzZWQpIGJ5dGVzIGJpdCBmbGlwIHdv buKAmXQKICAgYWZmZWN0IHRoZSBFQ0Mgc28gZG9u4oCZdCBjaGVjayB0aGUgbnVtYmVyIG9mIGJp dGZsaXBzIGluIHRoaXMgYXJlYS4KClNpZ25lZC1vZmYtYnk6IEFiaGlzaGVrIFNhaHUgPGFic2Fo dUBjb2RlYXVyb3JhLm9yZz4KLS0tCiogQ2hhbmdlcyBmcm9tIHYzOgoKIDEuIE1ham9yIGNoYW5n ZXMgaW4gZXJhc2VkIGNvZGV3b3JkIGRldGVjdGlvbiBmb3IKICAgIHJhdyByZWFkIGZ1bmN0aW9u CgoqIENoYW5nZXMgZnJvbSB2MjoKICBOT05FCgoqIENoYW5nZXMgZnJvbSB2MToKIDEuIE1pbm9y IGNoYW5nZSBpbiBjb21taXQgbWVzc2FnZQogMi4gaW52YWxpZGF0ZSBwYWdlYnVmIGlmIGRhdGFi dWYgb3Igb29iX3BvaSBpcyB1c2VkCgogZHJpdmVycy9tdGQvbmFuZC9yYXcvcWNvbV9uYW5kYy5j IHwgMTI3ICsrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0tCiAxIGZpbGUgY2hh bmdlZCwgOTAgaW5zZXJ0aW9ucygrKSwgMzcgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJp dmVycy9tdGQvbmFuZC9yYXcvcWNvbV9uYW5kYy5jIGIvZHJpdmVycy9tdGQvbmFuZC9yYXcvcWNv bV9uYW5kYy5jCmluZGV4IDE2MGFjZGYuLmUzNGVkZjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRk L25hbmQvcmF3L3Fjb21fbmFuZGMuYworKysgYi9kcml2ZXJzL210ZC9uYW5kL3Jhdy9xY29tX25h bmRjLmMKQEAgLTE2NTYsMjAgKzE2NTYsOTUgQEAgc3RhdGljIGludCBjaGVja19mbGFzaF9lcnJv cnMoc3RydWN0IHFjb21fbmFuZF9ob3N0ICpob3N0LCBpbnQgY3dfY250KQogfQogCiAvKgorICog Qml0ZmxpcHMgY2FuIGhhcHBlbiBpbiBlcmFzZWQgY29kZXdvcmRzIGFsc28gc28gdGhpcyBmdW5j dGlvbiBjb3VudHMgdGhlCisgKiBudW1iZXIgb2YgMCBpbiBlYWNoIENXIGZvciB3aGljaCBFQ0Mg ZW5naW5lIHJldHVybnMgdGhlIHVuY29ycmVjdGFibGUKKyAqIGVycm9yLiBUaGUgcGFnZSB3aWxs IGJlIGFzc3VtZWQgYXMgZXJhc2VkIGlmIHRoaXMgY291bnQgaXMgbGVzcyB0aGFuIG9yCisgKiBl cXVhbCB0byB0aGUgZWNjLT5zdHJlbmd0aCBmb3IgZWFjaCBDVy4KKyAqCisgKiAxLiBCb3RoIERB VEEgYW5kIE9PQiBuZWVkIHRvIGJlIGNoZWNrZWQgZm9yIG51bWJlciBvZiAwLiBUaGUKKyAqICAg IHRvcC1sZXZlbCBBUEkgY2FuIGJlIGNhbGxlZCB3aXRoIG9ubHkgZGF0YSBidWYgb3IgT09CIGJ1 ZiBzbyB1c2UKKyAqICAgIGNoaXAtPmRhdGFfYnVmIGlmIGRhdGEgYnVmIGlzIG51bGwgYW5kIGNo aXAtPm9vYl9wb2kgaWYgb29iIGJ1ZgorICogICAgaXMgbnVsbCBmb3IgY29weWluZyB0aGUgcmF3 IGJ5dGVzLgorICogMi4gUGVyZm9ybSByYXcgcmVhZCBmb3IgYWxsIHRoZSBDVyB3aGljaCBoYXMg dW5jb3JyZWN0YWJsZSBlcnJvcnMuCisgKiAzLiBGb3IgZWFjaCBDVywgY2hlY2sgdGhlIG51bWJl ciBvZiAwIGluIGN3X2RhdGEgYW5kIHVzYWJsZSBPT0IgYnl0ZXMuCisgKiAgICBUaGUgQkJNIGFu ZCBzcGFyZSBieXRlcyBiaXQgZmxpcCB3b27igJl0IGFmZmVjdCB0aGUgRUNDIHNvIGRvbuKAmXQg Y2hlY2sKKyAqICAgIHRoZSBudW1iZXIgb2YgYml0ZmxpcHMgaW4gdGhpcyBhcmVhLgorICovCitz dGF0aWMgaW50CitjaGVja19mb3JfZXJhc2VkX3BhZ2Uoc3RydWN0IHFjb21fbmFuZF9ob3N0ICpo b3N0LCB1OCAqZGF0YV9idWYsCisJCSAgICAgIHU4ICpvb2JfYnVmLCB1bnNpZ25lZCBsb25nIHVu Y29ycmVjdGFibGVfY3dzLAorCQkgICAgICBpbnQgcGFnZSwgdW5zaWduZWQgaW50IG1heF9iaXRm bGlwcykKK3sKKwlzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwID0gJmhvc3QtPmNoaXA7CisJc3RydWN0 IG10ZF9pbmZvICptdGQgPSBuYW5kX3RvX210ZChjaGlwKTsKKwlzdHJ1Y3QgbmFuZF9lY2NfY3Ry bCAqZWNjID0gJmNoaXAtPmVjYzsKKwlpbnQgY3csIGRhdGFfc2l6ZSwgb29iX3NpemUsIHJldCA9 IDA7CisKKwlpZiAoIWRhdGFfYnVmKSB7CisJCWRhdGFfYnVmID0gY2hpcC0+ZGF0YV9idWY7CisJ CWNoaXAtPnBhZ2VidWYgPSAtMTsKKwl9CisKKwlpZiAoIW9vYl9idWYpIHsKKwkJb29iX2J1ZiA9 IGNoaXAtPm9vYl9wb2k7CisJCWNoaXAtPnBhZ2VidWYgPSAtMTsKKwl9CisKKwlmb3IgKGN3ID0g MDsgY3cgPCBlY2MtPnN0ZXBzICYmIHVuY29ycmVjdGFibGVfY3dzOyBjdysrKSB7CisJCWlmIChj dyA9PSAoZWNjLT5zdGVwcyAtIDEpKSB7CisJCQlkYXRhX3NpemUgPSBlY2MtPnNpemUgLSAoKGVj Yy0+c3RlcHMgLSAxKSAqIDQpOworCQkJb29iX3NpemUgPSAoZWNjLT5zdGVwcyAqIDQpICsgaG9z dC0+ZWNjX2J5dGVzX2h3OworCQl9IGVsc2UgeworCQkJZGF0YV9zaXplID0gaG9zdC0+Y3dfZGF0 YTsKKwkJCW9vYl9zaXplID0gaG9zdC0+ZWNjX2J5dGVzX2h3OworCQl9CisKKwkJaWYgKHVuY29y cmVjdGFibGVfY3dzICYgQklUKDApKSB7CisJCQlyZXQgPSBxY29tX25hbmRjX3JlYWRfY3dfcmF3 KG10ZCwgY2hpcCwgZGF0YV9idWYsCisJCQkJCQkgICAgIG9vYl9idWYsIHBhZ2UsIGN3KTsKKwkJ CWlmIChyZXQpCisJCQkJcmV0dXJuIHJldDsKKwkJCS8qCisJCQkgKiBtYWtlIHN1cmUgaXQgaXNu J3QgYW4gZXJhc2VkIHBhZ2UgcmVwb3J0ZWQKKwkJCSAqIGFzIG5vdC1lcmFzZWQgYnkgSFcgYmVj YXVzZSBvZiBhIGZldyBiaXRmbGlwcworCQkJICovCisJCQlyZXQgPSBuYW5kX2NoZWNrX2VyYXNl ZF9lY2NfY2h1bmsoZGF0YV9idWYsCisJCQkJZGF0YV9zaXplLCBvb2JfYnVmICsgaG9zdC0+YmJt X3NpemUsCisJCQkJb29iX3NpemUsIE5VTEwsCisJCQkJMCwgZWNjLT5zdHJlbmd0aCk7CisJCQlp ZiAocmV0IDwgMCkgeworCQkJCW10ZC0+ZWNjX3N0YXRzLmZhaWxlZCsrOworCQkJfSBlbHNlIHsK KwkJCQltdGQtPmVjY19zdGF0cy5jb3JyZWN0ZWQgKz0gcmV0OworCQkJCW1heF9iaXRmbGlwcyA9 CisJCQkJCW1heF90KHVuc2lnbmVkIGludCwgbWF4X2JpdGZsaXBzLCByZXQpOworCQkJfQorCQl9 CisKKwkJZGF0YV9idWYgKz0gZGF0YV9zaXplOworCQlvb2JfYnVmICs9IGVjYy0+Ynl0ZXM7CisJ CXVuY29ycmVjdGFibGVfY3dzID4+PSAxOworCX0KKworCXJldHVybiBtYXhfYml0ZmxpcHM7Cit9 CisKKy8qCiAgKiByZWFkcyBiYWNrIHN0YXR1cyByZWdpc3RlcnMgc2V0IGJ5IHRoZSBjb250cm9s bGVyIHRvIG5vdGlmeSBwYWdlIHJlYWQKICAqIGVycm9ycy4gdGhpcyBpcyBlcXVpdmFsZW50IHRv IHdoYXQgJ2VjYy0+Y29ycmVjdCgpJyB3b3VsZCBkby4KICAqLwogc3RhdGljIGludCBwYXJzZV9y ZWFkX2Vycm9ycyhzdHJ1Y3QgcWNvbV9uYW5kX2hvc3QgKmhvc3QsIHU4ICpkYXRhX2J1ZiwKLQkJ CSAgICAgdTggKm9vYl9idWYpCisJCQkgICAgIHU4ICpvb2JfYnVmLCBpbnQgcGFnZSkKIHsKIAlz dHJ1Y3QgbmFuZF9jaGlwICpjaGlwID0gJmhvc3QtPmNoaXA7CiAJc3RydWN0IHFjb21fbmFuZF9j b250cm9sbGVyICpuYW5kYyA9IGdldF9xY29tX25hbmRfY29udHJvbGxlcihjaGlwKTsKIAlzdHJ1 Y3QgbXRkX2luZm8gKm10ZCA9IG5hbmRfdG9fbXRkKGNoaXApOwogCXN0cnVjdCBuYW5kX2VjY19j dHJsICplY2MgPSAmY2hpcC0+ZWNjOwotCXVuc2lnbmVkIGludCBtYXhfYml0ZmxpcHMgPSAwOwor CXVuc2lnbmVkIGludCBtYXhfYml0ZmxpcHMgPSAwLCB1bmNvcnJlY3RhYmxlX2N3cyA9IDA7CiAJ c3RydWN0IHJlYWRfc3RhdHMgKmJ1ZjsKLQlib29sIGZsYXNoX29wX2VyciA9IGZhbHNlOworCWJv b2wgZmxhc2hfb3BfZXJyID0gZmFsc2UsIGVyYXNlZDsKIAlpbnQgaTsKKwl1OCAqZGF0YV9idWZf c3RhcnQgPSBkYXRhX2J1ZiwgKm9vYl9idWZfc3RhcnQgPSBvb2JfYnVmOwogCiAJYnVmID0gKHN0 cnVjdCByZWFkX3N0YXRzICopbmFuZGMtPnJlZ19yZWFkX2J1ZjsKIAluYW5kY19yZWFkX2J1ZmZl cl9zeW5jKG5hbmRjLCB0cnVlKTsKQEAgLTE2OTksMTAgKzE3NzQsNiBAQCBzdGF0aWMgaW50IHBh cnNlX3JlYWRfZXJyb3JzKHN0cnVjdCBxY29tX25hbmRfaG9zdCAqaG9zdCwgdTggKmRhdGFfYnVm LAogCQkgKiAgICBjb2Rld29yZCBkZXRlY3Rpb24gY2hlY2sgd2lsbCBiZSBkb25lLgogCQkgKi8K IAkJaWYgKChmbGFzaCAmIEZTX09QX0VSUikgJiYgKGJ1ZmZlciAmIEJTX1VOQ09SUkVDVEFCTEVf QklUKSkgewotCQkJYm9vbCBlcmFzZWQ7Ci0JCQlpbnQgcmV0LCBlY2NsZW4sIGV4dHJhb29ibGVu OwotCQkJdm9pZCAqZWNjYnVmOwotCiAJCQkvKgogCQkJICogRm9yIEJDSCBFQ0MsIGlnbm9yZSBl cmFzZWQgY29kZXdvcmQgZXJyb3JzLCBpZgogCQkJICogRVJBU0VEX0NXIGJpdHMgYXJlIHNldC4K QEAgLTE3MjMsMzEgKzE3OTQsOCBAQCBzdGF0aWMgaW50IHBhcnNlX3JlYWRfZXJyb3JzKHN0cnVj dCBxY29tX25hbmRfaG9zdCAqaG9zdCwgdTggKmRhdGFfYnVmLAogCQkJCWVyYXNlZCA9IGZhbHNl OwogCQkJfQogCi0JCQlpZiAoZXJhc2VkKSB7Ci0JCQkJZGF0YV9idWYgKz0gZGF0YV9sZW47Ci0J CQkJaWYgKG9vYl9idWYpCi0JCQkJCW9vYl9idWYgKz0gb29iX2xlbiArIGVjYy0+Ynl0ZXM7Ci0J CQkJY29udGludWU7Ci0JCQl9Ci0KLQkJCWVjY2J1ZiA9IG9vYl9idWYgPyBvb2JfYnVmICsgb29i X2xlbiA6IE5VTEw7Ci0JCQllY2NsZW4gPSBvb2JfYnVmID8gaG9zdC0+ZWNjX2J5dGVzX2h3IDog MDsKLQkJCWV4dHJhb29ibGVuID0gb29iX2J1ZiA/IG9vYl9sZW4gOiAwOwotCi0JCQkvKgotCQkJ ICogbWFrZSBzdXJlIGl0IGlzbid0IGFuIGVyYXNlZCBwYWdlIHJlcG9ydGVkCi0JCQkgKiBhcyBu b3QtZXJhc2VkIGJ5IEhXIGJlY2F1c2Ugb2YgYSBmZXcgYml0ZmxpcHMKLQkJCSAqLwotCQkJcmV0 ID0gbmFuZF9jaGVja19lcmFzZWRfZWNjX2NodW5rKGRhdGFfYnVmLAotCQkJCWRhdGFfbGVuLCBl Y2NidWYsIGVjY2xlbiwgb29iX2J1ZiwKLQkJCQlleHRyYW9vYmxlbiwgZWNjLT5zdHJlbmd0aCk7 Ci0JCQlpZiAocmV0IDwgMCkgewotCQkJCW10ZC0+ZWNjX3N0YXRzLmZhaWxlZCsrOwotCQkJfSBl bHNlIHsKLQkJCQltdGQtPmVjY19zdGF0cy5jb3JyZWN0ZWQgKz0gcmV0OwotCQkJCW1heF9iaXRm bGlwcyA9Ci0JCQkJCW1heF90KHVuc2lnbmVkIGludCwgbWF4X2JpdGZsaXBzLCByZXQpOwotCQkJ fQorCQkJaWYgKCFlcmFzZWQpCisJCQkJdW5jb3JyZWN0YWJsZV9jd3MgfD0gQklUKGkpOwogCQkv KgogCQkgKiBDaGVjayBpZiBNUFUgb3IgYW55IG90aGVyIG9wZXJhdGlvbmFsIGVycm9yICh0aW1l b3V0LAogCQkgKiBkZXZpY2UgZmFpbHVyZSwgZXRjLikgaGFwcGVuZWQgZm9yIHRoaXMgY29kZXdv cmQgYW5kCkBAIC0xNzc3LDcgKzE4MjUsMTIgQEAgc3RhdGljIGludCBwYXJzZV9yZWFkX2Vycm9y cyhzdHJ1Y3QgcWNvbV9uYW5kX2hvc3QgKmhvc3QsIHU4ICpkYXRhX2J1ZiwKIAlpZiAoZmxhc2hf b3BfZXJyKQogCQlyZXR1cm4gLUVJTzsKIAotCXJldHVybiBtYXhfYml0ZmxpcHM7CisJaWYgKCF1 bmNvcnJlY3RhYmxlX2N3cykKKwkJcmV0dXJuIG1heF9iaXRmbGlwczsKKworCXJldHVybiBjaGVj a19mb3JfZXJhc2VkX3BhZ2UoaG9zdCwgZGF0YV9idWZfc3RhcnQsIG9vYl9idWZfc3RhcnQsCisJ CQkJICAgICB1bmNvcnJlY3RhYmxlX2N3cywgcGFnZSwKKwkJCQkgICAgIG1heF9iaXRmbGlwcyk7 CiB9CiAKIC8qCkBAIC0xNzg1LDcgKzE4MzgsNyBAQCBzdGF0aWMgaW50IHBhcnNlX3JlYWRfZXJy b3JzKHN0cnVjdCBxY29tX25hbmRfaG9zdCAqaG9zdCwgdTggKmRhdGFfYnVmLAogICogZWNjLT5y ZWFkX29vYigpCiAgKi8KIHN0YXRpYyBpbnQgcmVhZF9wYWdlX2VjYyhzdHJ1Y3QgcWNvbV9uYW5k X2hvc3QgKmhvc3QsIHU4ICpkYXRhX2J1ZiwKLQkJCSB1OCAqb29iX2J1ZikKKwkJCSB1OCAqb29i X2J1ZiwgaW50IHBhZ2UpCiB7CiAJc3RydWN0IG5hbmRfY2hpcCAqY2hpcCA9ICZob3N0LT5jaGlw OwogCXN0cnVjdCBxY29tX25hbmRfY29udHJvbGxlciAqbmFuZGMgPSBnZXRfcWNvbV9uYW5kX2Nv bnRyb2xsZXIoY2hpcCk7CkBAIC0xODU4LDcgKzE5MTEsNyBAQCBzdGF0aWMgaW50IHJlYWRfcGFn ZV9lY2Moc3RydWN0IHFjb21fbmFuZF9ob3N0ICpob3N0LCB1OCAqZGF0YV9idWYsCiAJCXJldHVy biByZXQ7CiAJfQogCi0JcmV0dXJuIHBhcnNlX3JlYWRfZXJyb3JzKGhvc3QsIGRhdGFfYnVmX3N0 YXJ0LCBvb2JfYnVmX3N0YXJ0KTsKKwlyZXR1cm4gcGFyc2VfcmVhZF9lcnJvcnMoaG9zdCwgZGF0 YV9idWZfc3RhcnQsIG9vYl9idWZfc3RhcnQsIHBhZ2UpOwogfQogCiAvKgpAQCAtMTkxMCw3ICsx OTYzLDcgQEAgc3RhdGljIGludCBxY29tX25hbmRjX3JlYWRfcGFnZShzdHJ1Y3QgbXRkX2luZm8g Km10ZCwgc3RydWN0IG5hbmRfY2hpcCAqY2hpcCwKIAogCWNsZWFyX2JhbV90cmFuc2FjdGlvbihu YW5kYyk7CiAKLQlyZXR1cm4gcmVhZF9wYWdlX2VjYyhob3N0LCBkYXRhX2J1Ziwgb29iX2J1Zik7 CisJcmV0dXJuIHJlYWRfcGFnZV9lY2MoaG9zdCwgZGF0YV9idWYsIG9vYl9idWYsIHBhZ2UpOwog fQogCiAvKiBpbXBsZW1lbnRzIGVjYy0+cmVhZF9wYWdlX3JhdygpICovCkBAIC0xOTUxLDcgKzIw MDQsNyBAQCBzdGF0aWMgaW50IHFjb21fbmFuZGNfcmVhZF9vb2Ioc3RydWN0IG10ZF9pbmZvICpt dGQsIHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsCiAJc2V0X2FkZHJlc3MoaG9zdCwgMCwgcGFnZSk7 CiAJdXBkYXRlX3J3X3JlZ3MoaG9zdCwgZWNjLT5zdGVwcywgdHJ1ZSk7CiAKLQlyZXR1cm4gcmVh ZF9wYWdlX2VjYyhob3N0LCBOVUxMLCBjaGlwLT5vb2JfcG9pKTsKKwlyZXR1cm4gcmVhZF9wYWdl X2VjYyhob3N0LCBOVUxMLCBjaGlwLT5vb2JfcG9pLCBwYWdlKTsKIH0KIAogLyogaW1wbGVtZW50 cyBlY2MtPndyaXRlX3BhZ2UoKSAqLwotLSAKUVVBTENPTU0gSU5ESUEsIG9uIGJlaGFsZiBvZiBR dWFsY29tbSBJbm5vdmF0aW9uIENlbnRlciwgSW5jLgppcyBhIG1lbWJlciBvZiBDb2RlIEF1cm9y YSBGb3J1bSwgaG9zdGVkIGJ5IFRoZSBMaW51eCBGb3VuZGF0aW9uCgoKX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkxpbnV4IE1URCBkaXNjdXNz aW9uIG1haWxpbmcgbGlzdApodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2xpbnV4LW10ZC8K From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.codeaurora.org ([198.145.29.96]) by casper.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1fVXXw-0003fY-Cy for linux-mtd@lists.infradead.org; Wed, 20 Jun 2018 07:28:57 +0000 From: Abhishek Sahu To: Boris Brezillon , Miquel Raynal Cc: David Woodhouse , Brian Norris , Marek Vasut , Richard Weinberger , linux-arm-msm@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mtd@lists.infradead.org, Andy Gross , Archit Taneja , Abhishek Sahu Subject: [PATCH v4 14/15] mtd: rawnand: qcom: erased page bitflips detection Date: Wed, 20 Jun 2018 12:57:41 +0530 Message-Id: <1529479662-4026-15-git-send-email-absahu@codeaurora.org> In-Reply-To: <1529479662-4026-1-git-send-email-absahu@codeaurora.org> References: <1529479662-4026-1-git-send-email-absahu@codeaurora.org> 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: , NAND parts can have bitflips in an erased page due to the process technology used. In this case, QCOM NAND controller is not able to identify that page as an erased page. Currently the driver calls nand_check_erased_ecc_chunk() for identifying the erased pages but this won’t work always since the checking is being with ECC engine returned data. In case of bitflips, the ECC engine tries to correct the data and then it generates the uncorrectable error. Now, this data is not equal to original raw data. For erased CW identification, the raw data should be read again from NAND device and this nand_check_erased_ecc_chunk function() should be called for raw data only. Now following logic is being added to identify the erased codeword bitflips. 1. In most of the cases, not all the codewords will have bitflips and only single CW will have bitflips. So, there is no need to read the complete raw page data. The NAND raw read can be scheduled for any CW in page. The NAND controller works on CW basis and it will update the status register after each CW read. Maintain the bitmask for the CW which generated the uncorrectable error. 2. Do raw read for all the CW's which generated the uncorrectable error. 3. Both DATA and OOB need to be checked for number of 0. The top-level API can be called with only data buf or OOB buf so use chip->databuf if data buf is null and chip->oob_poi if OOB buf is null for copying the raw bytes temporarily. 4. For each CW, check the number of 0 in cw_data and usable oob bytes, The bbm and spare (unused) bytes bit flip won’t affect the ECC so don’t check the number of bitflips in this area. Signed-off-by: Abhishek Sahu --- * Changes from v3: 1. Major changes in erased codeword detection for raw read function * Changes from v2: NONE * Changes from v1: 1. Minor change in commit message 2. invalidate pagebuf if databuf or oob_poi is used drivers/mtd/nand/raw/qcom_nandc.c | 127 +++++++++++++++++++++++++++----------- 1 file changed, 90 insertions(+), 37 deletions(-) diff --git a/drivers/mtd/nand/raw/qcom_nandc.c b/drivers/mtd/nand/raw/qcom_nandc.c index 160acdf..e34edf1 100644 --- a/drivers/mtd/nand/raw/qcom_nandc.c +++ b/drivers/mtd/nand/raw/qcom_nandc.c @@ -1656,20 +1656,95 @@ static int check_flash_errors(struct qcom_nand_host *host, int cw_cnt) } /* + * Bitflips can happen in erased codewords also so this function counts the + * number of 0 in each CW for which ECC engine returns the uncorrectable + * error. The page will be assumed as erased if this count is less than or + * equal to the ecc->strength for each CW. + * + * 1. Both DATA and OOB need to be checked for number of 0. The + * top-level API can be called with only data buf or OOB buf so use + * chip->data_buf if data buf is null and chip->oob_poi if oob buf + * is null for copying the raw bytes. + * 2. Perform raw read for all the CW which has uncorrectable errors. + * 3. For each CW, check the number of 0 in cw_data and usable OOB bytes. + * The BBM and spare bytes bit flip won’t affect the ECC so don’t check + * the number of bitflips in this area. + */ +static int +check_for_erased_page(struct qcom_nand_host *host, u8 *data_buf, + u8 *oob_buf, unsigned long uncorrectable_cws, + int page, unsigned int max_bitflips) +{ + struct nand_chip *chip = &host->chip; + struct mtd_info *mtd = nand_to_mtd(chip); + struct nand_ecc_ctrl *ecc = &chip->ecc; + int cw, data_size, oob_size, ret = 0; + + if (!data_buf) { + data_buf = chip->data_buf; + chip->pagebuf = -1; + } + + if (!oob_buf) { + oob_buf = chip->oob_poi; + chip->pagebuf = -1; + } + + for (cw = 0; cw < ecc->steps && uncorrectable_cws; cw++) { + if (cw == (ecc->steps - 1)) { + data_size = ecc->size - ((ecc->steps - 1) * 4); + oob_size = (ecc->steps * 4) + host->ecc_bytes_hw; + } else { + data_size = host->cw_data; + oob_size = host->ecc_bytes_hw; + } + + if (uncorrectable_cws & BIT(0)) { + ret = qcom_nandc_read_cw_raw(mtd, chip, data_buf, + oob_buf, page, cw); + if (ret) + return ret; + /* + * make sure it isn't an erased page reported + * as not-erased by HW because of a few bitflips + */ + ret = nand_check_erased_ecc_chunk(data_buf, + data_size, oob_buf + host->bbm_size, + oob_size, NULL, + 0, ecc->strength); + if (ret < 0) { + mtd->ecc_stats.failed++; + } else { + mtd->ecc_stats.corrected += ret; + max_bitflips = + max_t(unsigned int, max_bitflips, ret); + } + } + + data_buf += data_size; + oob_buf += ecc->bytes; + uncorrectable_cws >>= 1; + } + + return max_bitflips; +} + +/* * reads back status registers set by the controller to notify page read * errors. this is equivalent to what 'ecc->correct()' would do. */ static int parse_read_errors(struct qcom_nand_host *host, u8 *data_buf, - u8 *oob_buf) + u8 *oob_buf, int page) { struct nand_chip *chip = &host->chip; struct qcom_nand_controller *nandc = get_qcom_nand_controller(chip); struct mtd_info *mtd = nand_to_mtd(chip); struct nand_ecc_ctrl *ecc = &chip->ecc; - unsigned int max_bitflips = 0; + unsigned int max_bitflips = 0, uncorrectable_cws = 0; struct read_stats *buf; - bool flash_op_err = false; + bool flash_op_err = false, erased; int i; + u8 *data_buf_start = data_buf, *oob_buf_start = oob_buf; buf = (struct read_stats *)nandc->reg_read_buf; nandc_read_buffer_sync(nandc, true); @@ -1699,10 +1774,6 @@ static int parse_read_errors(struct qcom_nand_host *host, u8 *data_buf, * codeword detection check will be done. */ if ((flash & FS_OP_ERR) && (buffer & BS_UNCORRECTABLE_BIT)) { - bool erased; - int ret, ecclen, extraooblen; - void *eccbuf; - /* * For BCH ECC, ignore erased codeword errors, if * ERASED_CW bits are set. @@ -1723,31 +1794,8 @@ static int parse_read_errors(struct qcom_nand_host *host, u8 *data_buf, erased = false; } - if (erased) { - data_buf += data_len; - if (oob_buf) - oob_buf += oob_len + ecc->bytes; - continue; - } - - eccbuf = oob_buf ? oob_buf + oob_len : NULL; - ecclen = oob_buf ? host->ecc_bytes_hw : 0; - extraooblen = oob_buf ? oob_len : 0; - - /* - * make sure it isn't an erased page reported - * as not-erased by HW because of a few bitflips - */ - ret = nand_check_erased_ecc_chunk(data_buf, - data_len, eccbuf, ecclen, oob_buf, - extraooblen, ecc->strength); - if (ret < 0) { - mtd->ecc_stats.failed++; - } else { - mtd->ecc_stats.corrected += ret; - max_bitflips = - max_t(unsigned int, max_bitflips, ret); - } + if (!erased) + uncorrectable_cws |= BIT(i); /* * Check if MPU or any other operational error (timeout, * device failure, etc.) happened for this codeword and @@ -1777,7 +1825,12 @@ static int parse_read_errors(struct qcom_nand_host *host, u8 *data_buf, if (flash_op_err) return -EIO; - return max_bitflips; + if (!uncorrectable_cws) + return max_bitflips; + + return check_for_erased_page(host, data_buf_start, oob_buf_start, + uncorrectable_cws, page, + max_bitflips); } /* @@ -1785,7 +1838,7 @@ static int parse_read_errors(struct qcom_nand_host *host, u8 *data_buf, * ecc->read_oob() */ static int read_page_ecc(struct qcom_nand_host *host, u8 *data_buf, - u8 *oob_buf) + u8 *oob_buf, int page) { struct nand_chip *chip = &host->chip; struct qcom_nand_controller *nandc = get_qcom_nand_controller(chip); @@ -1858,7 +1911,7 @@ static int read_page_ecc(struct qcom_nand_host *host, u8 *data_buf, return ret; } - return parse_read_errors(host, data_buf_start, oob_buf_start); + return parse_read_errors(host, data_buf_start, oob_buf_start, page); } /* @@ -1910,7 +1963,7 @@ static int qcom_nandc_read_page(struct mtd_info *mtd, struct nand_chip *chip, clear_bam_transaction(nandc); - return read_page_ecc(host, data_buf, oob_buf); + return read_page_ecc(host, data_buf, oob_buf, page); } /* implements ecc->read_page_raw() */ @@ -1951,7 +2004,7 @@ static int qcom_nandc_read_oob(struct mtd_info *mtd, struct nand_chip *chip, set_address(host, 0, page); update_rw_regs(host, ecc->steps, true); - return read_page_ecc(host, NULL, chip->oob_poi); + return read_page_ecc(host, NULL, chip->oob_poi, page); } /* implements ecc->write_page() */ -- QUALCOMM INDIA, on behalf of Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, hosted by The Linux Foundation