From mboxrd@z Thu Jan 1 00:00:00 1970 From: Anton Vorontsov Subject: Re: [PATCH v6] pstore/ram: Add ramoops support for the Flattened Device Tree. Date: Fri, 7 Sep 2012 22:29:10 -0700 Message-ID: <20120908052907.GA4724@lizard> References: <1347042576-17675-1-git-send-email-bfreed@chromium.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <1347042576-17675-1-git-send-email-bfreed-F7+t8E8rja9g9hUCZPvPmw@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: devicetree-discuss-bounces+gldd-devicetree-discuss=m.gmane.org-uLR06cmDAlY/bJ5BZ2RsiQ@public.gmane.org Sender: "devicetree-discuss" To: Bryan Freed Cc: Tony Luck , keescook-F7+t8E8rja9g9hUCZPvPmw@public.gmane.org, marco.stornelli-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org, gregkh-hQyY1W1yCW8ekmWlsbkhG0B+6BGkLq7r@public.gmane.org, devicetree-discuss-uLR06cmDAlY/bJ5BZ2RsiQ@public.gmane.org, sboyd-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, John Stultz , Colin Cross List-Id: devicetree@vger.kernel.org T24gRnJpLCBTZXAgMDcsIDIwMTIgYXQgMTE6Mjk6MzZBTSAtMDcwMCwgQnJ5YW4gRnJlZWQgd3Jv dGU6Cj4gV2hlbiBjYWxsZWQgd2l0aCBhIG5vbi16ZXJvIG9mX25vZGUsIGZpbGwgb3V0IGEgbmV3 IHJhbW9vcHNfcGxhdGZvcm1fZGF0YQo+IHdpdGggZGF0YSBmcm9tIHRoZSBzcGVjaWZpZWQgRmxh dHRlbmVkIERldmljZSBUcmVlIG5vZGUuCj4gVXBkYXRlIHJhbW9vcHMgZG9jdW1lbnRhdGlvbiB3 aXRoIHRoZSBuZXcgRkRUIGludGVyZmFjZS4KPiBVcGRhdGUgZGV2aWNldHJlZS9iaW5kaW5nIGRv Y3VtZW50YXRpb24gd2l0aCBwc3RvcmUvcmFtb29wcy50eHQuCgpUaGFua3MgZm9yIHlvdXIgd29y aywgQnJ5YW4hIFRoZXJlIHdlcmUgYSBmZXcgaXNzdWVzLCBJIGZpeGVkCnRoZW0gbXlzZWxmIGJ1 dCBJIG5lZWQgeW91ciBjb25maXJtYXRpb24gaWYgeW91J3JlIE9LIHcvIGFsbAp0aGUgY2hhbmdl cy4KCkZpcnN0IG9mLCB0aGUgU2lnbmVkLW9mZi1ieSB0YWcgaXMgbWlzc2luZywgYnV0IEkgc2Vl IGl0IGluIHY1LgpJIGFsc28gc2VlIHRoYXQgdjUgaGFkIGFuIEFjayBmcm9tIEtlZXMgQ29vaywg eW91IGRpZCBub3QgcHJlc2VydmUgaXQsCmJ1dCBnZW5lcmFsbHkgaXQncyBhIGdvb2QgaWRlYSB0 byBkbyBzbyAoaWYgdlggLT4gdihYKzEpIGNoYW5nZXMKYXJlbid0IGRyYXN0aWMpLgoKWy4uLl0K PiArT3B0aW9uYWwgcHJvcGVydGllczoKPiArLSByZWNvcmQtc2l6ZTogU3BlY2lmaWVzIHRoZSBz aXplIG9mIGVhY2ggcmVjb3JkIGluIHByZXNlcnZlZCBtZW1vcnkuCj4gKy0gY29uc29sZS1zaXpl OiBTcGVjaWZpZXMgdGhlIHNpemUgb2YgdGhlIGNvbnNvbGUgbG9nLgo+ICstIGZ0cmFjZS1zaXpl OiBTcGVjaWZpZXMgdGhlIHNpemUgb2YgdGhlIGZ0cmFjZSBsb2cuCj4gKy0gZWNjLXNpemU6IFNw ZWNpZmllcyB0aGUgc2l6ZSBvZiBlYWNoIHJlY29yZCdzIEVDQyBidWZmZXIuCj4gKy0gZHVtcC1v b3BzOiBTcGVjaWZpZXMgdG8gZHVtcCBvb3BzIGluIGFkZGl0aW9uIHRvIHBhbmljcy4KClBlcnNv bmFsbHksIEkgZG9uJ3Qgc2VlIGhvdyB0aGlzIGZpdHMgaW50byBkZXZpY2UgdHJlZS4gSXQgZG9l c24ndApkZXNjcmliZSBoYXJkd2FyZSwgaW5zdGVhZCBpdCdzIG1vcmUgYSBjb25maWd1cmF0aW9u IHN0dWZmLCB3aGljaAp1c3VhbGx5IHdlIHRyeSB0byBub3QgcHV0IGludG8gdGhlIGRldmljZSB0 cmVlLgoKSXQgd291bGQgYmUgYmV0dGVyIHRvIGhhdmUgYSBzYW5lIGRlZmF1bHRzIGluIHJhbW9v cHMsIGluc3RlYWQgb2YKaW50cm9kdWNpbmcgbW9yZSAidmlydHVhbCIgc3R1ZmYgaW4gdGhlIGRl dmljZSB0cmVlLiBUaGF0IGlzLCBmZWVsCmZyZWUgdG8gY2hhbmdlIGRlZmF1bHRzIGlmIHRoZXkg c2VlbSB0byBiZSBub3QgZW5vdWdoIGZvciBtb3N0IHlvdXIKc2V0dXBzLgoKVGhlIG9ubHkgcHJv cGVydHkgdGhhdCBJIHNlZSB3aGljaCBpcyB0cnVseSBoYXJkd2FyZS1zcGVjaWZpYyBpcwplY2Mt c2l6ZS4gRS5nLiBpZiB3ZSdyZSBwcmV0dHkgc3VyZSB0aGF0IGEgc3BlY2lmaWMgaHcgZG9lcyBu b3QKbmVlZCBlY2MsIGl0J3MgT0sgdG8gYXZvaWQgaXQuIEFuZCBzb21lIGh3IHNldHVwcyBtaWdo dCByZXF1aXJlCmJpZ2dlciBFQ0Mgc2l6ZXMsIHNvIGl0J3MgT0sgdG8gaGF2ZSBpdCBpbiB0aGUg ZGV2aWNlLXRyZWUuCgo+IHN0YXRpYyBzdHJ1Y3QgcmFtb29wc19wbGF0Zm9ybV9kYXRhICogX19p bml0Cj4gb2ZfcmFtb29wc19wbGF0Zm9ybV9kYXRhKHN0cnVjdCBkZXZpY2UgKmRldikKCllvdSBj YWxsIHRoaXMgZnVuY3Rpb24gZnJvbSBfX2RldmluaXQgc2VjdGlvbiwgc28gdXNpbmcgX19pbml0 CmlzIGFuIGVycm9yLgoKV0FSTklORzogZnMvcHN0b3JlL3JhbW9vcHMubyguZGV2aW5pdC50ZXh0 KzB4MzcpOiBTZWN0aW9uIG1pc21hdGNoIGluIHJlZmVyZW5jZSBmcm9tIHRoZSBmdW5jdGlvbiBy YW1vb3BzX3Byb2JlKCkgdG8gdGhlIGZ1bmN0aW9uIC5pbml0LnRleHQ6b2ZfcmFtb29wc19wbGF0 Zm9ybV9kYXRhKCkKVGhlIGZ1bmN0aW9uIF9fZGV2aW5pdCByYW1vb3BzX3Byb2JlKCkgcmVmZXJl bmNlcwoKSSBjaGFuZ2VkIHRoaXMgdG8gX19kZXZuaXQuCgpbLi4uXQo+ICsJcGRhdGEgPSBkZXZt X2t6YWxsb2MoZGV2LCBzaXplb2YoKnBkYXRhKSwgR0ZQX0tFUk5FTCk7Cj4gKwlpZiAocGRhdGEg PT0gTlVMTCkKCkkgd29uZGVyIHdoeSBwZW9wbGUgcHJlZmVyIHRvIG5vdCB3cml0ZSAhcGRhdGEs IHdoaWNoIGlzIG1vcmUKbmF0dXJhbCB3aGVuIHJlYWRpbmcgdGhlIGNvZGUuLiA6LSkKClsuLi5d Cj4gKyNlbHNlCj4gKyNkZWZpbmUgb2ZfcmFtb29wc19wbGF0Zm9ybV9kYXRhKGRldikgTlVMTAoK VXNpbmcgc3RhdGljIGlubGluZSB3b3VsZCBiZSBiZXR0ZXIsIGkuZS4gdHlwZS1zYWZlLgoKPisg ICAgICAgICAgICAgICAub2ZfbWF0Y2hfdGFibGUgPSBvZl9tYXRjaF9wdHIocmFtb29wc19vZl9t YXRjaCksCgpUaGlzIGZhaWxzIHRvIGJ1aWxkOgoKZnMvcHN0b3JlL3JhbS5jOiBBdCB0b3AgbGV2 ZWw6CmZzL3BzdG9yZS9yYW0uYzo1NDA6MjI6IGVycm9yOiDigJhyYW1vb3BzX29mX21hdGNo4oCZ IHVuZGVjbGFyZWQgaGVyZSAobm90IGluIGEgZnVuY3Rpb24pCgpGb3Igc29tZSByZWFzb24geW91 IGxvc3QgcmFtb29wc19vZl9tYXRjaCBodW5rIGZyb20gdGhlIHY1LgoKU28gSSBtYWRlIHRoZXNl IGNoYW5nZXMgb24gdG9wIG9mIHlvdXIgcGF0Y2ggKG5vdGUsIHRoZXJlJ3MgbW9yZQp0ZXh0IGF0 IHRoZSBlbmQgb2YgdGhlIGVtYWlsKToKCi0gLSAtIC0KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRp b24vZGV2aWNldHJlZS9iaW5kaW5ncy9wc3RvcmUvcmFtb29wcy50eHQgYi9Eb2N1bWVudGF0aW9u L2RldmljZXRyZWUvYmluZGluZ3MvcHN0b3JlL3JhbW9vcHMudHh0CmluZGV4IDJmZGRiYTQuLjFk NDMzMDUgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wc3Rv cmUvcmFtb29wcy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bz dG9yZS9yYW1vb3BzLnR4dApAQCAtMSwzMCArMSwxNyBAQAotUmFtb29wcyBvb3BzL3BhbmljL2Nv bnNvbGUgbG9nZ2VyCitSYW1vb3BzIG9vcHMvcGFuaWMvY29uc29sZS90cmFjZSBsb2dnZXIKIAog UmVxdWlyZWQgcHJvcGVydGllczoKIC0gY29tcGF0aWJsZTogTXVzdCBiZSAicmFtb29wcyIuCiAt IHJlZzogU3BlY2lmaWVzIHRoZSBiYXNlIHBoeXNpY2FsIGFkZHJlc3MgYW5kIHNpemUgb2YgcHJl c2VydmVkIG1lbW9yeS4KIAogT3B0aW9uYWwgcHJvcGVydGllczoKLS0gcmVjb3JkLXNpemU6IFNw ZWNpZmllcyB0aGUgc2l6ZSBvZiBlYWNoIHJlY29yZCBpbiBwcmVzZXJ2ZWQgbWVtb3J5LgotLSBj b25zb2xlLXNpemU6IFNwZWNpZmllcyB0aGUgc2l6ZSBvZiB0aGUgY29uc29sZSBsb2cuCi0tIGZ0 cmFjZS1zaXplOiBTcGVjaWZpZXMgdGhlIHNpemUgb2YgdGhlIGZ0cmFjZSBsb2cuCiAtIGVjYy1z aXplOiBTcGVjaWZpZXMgdGhlIHNpemUgb2YgZWFjaCByZWNvcmQncyBFQ0MgYnVmZmVyLgotLSBk dW1wLW9vcHM6IFNwZWNpZmllcyB0byBkdW1wIG9vcHMgaW4gYWRkaXRpb24gdG8gcGFuaWNzLgog CiBFeGFtcGxlOgogCiByYW1vb3BzIHsKIAljb21wYXRpYmxlID0gInJhbW9vcHMiOwogCXJlZyA9 IDwweDQxZjAwMDAwIDB4MDAxMDAwMDA+OwotCXJlY29yZC1zaXplID0gPDB4MDAwMjAwMDA+Owot CWZ0cmFjZS1zaXplID0gPDB4MDAwMjAwMDA+OwotCWR1bXAtb29wczsKIH07CiBUaGUgInJlZyA9 IDwweDQxZjAwMDAwIDB4MDAxMDAwMDA+IiBsaW5lIHNwZWNpZmllcyBhIHByZXNlcnZlZCBtZW1v cnkKIHNpemUgb2YgMU1CIGF0IHBoeXNpY2FsIGFkZHJlc3MgMHg0MWYwMDAwMC4KLVRoZSAicmVj b3JkLXNpemUgPSA8MHgwMDAyMDAwMD4iIGxpbmUgc3BlY2lmaWVzIGEgcmVjb3JkIHNpemUgb2Yg MTI4S0IuCi1UaGUgImZ0cmFjZS1zaXplID0gPDB4MDAwMjAwMDA+IiBsaW5lIHNwZWNpZmllcyBh biBmdHJhY2UgbG9nIHNpemUgb2YgMTI4S0IuCi1UaGUgb3B0aW9uYWwgImR1bXAtb29wcyIgbGlu ZSB0ZWxscyByYW1vb3BzIHRvIGR1bXAgb29wc2VzIGFzIHdlbGwgYXMgcGFuaWNzLgotQXQgbGVh c3Qgb25lIG9mIHJlY29yZCwgY29uc29sZSwgb3IgZnRyYWNlIHNpemUgbXVzdCBiZSBzcGVjaWZp ZWQuCi1JbiB0aGlzIGV4YW1wbGUsIDEyOEtCIGlzIGFsbG9jYXRlZCB0byB0aGUgZnRyYWNlIGxv ZywgYW5kIDg5NktCCi0oMTAyNEtCIC0gMTI4S0IpIGlzIGFsbG9jYXRlZCB0byBvb3BzIGFuZCBw YW5pYyByZWNvcmRzLgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9yYW1vb3BzLnR4dCBiL0Rv Y3VtZW50YXRpb24vcmFtb29wcy50eHQKaW5kZXggODJkODI1ZC4uYTlkMGM2YSAxMDA2NDQKLS0t IGEvRG9jdW1lbnRhdGlvbi9yYW1vb3BzLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3JhbW9vcHMu dHh0CkBAIC0zLDcgKzMsNyBAQCBSYW1vb3BzIG9vcHMvcGFuaWMgbG9nZ2VyCiAKIFNlcmdpdSBJ b3JkYWNoZSA8c2VyZ2l1QGNocm9taXVtLm9yZz4KIAotVXBkYXRlZDogNSBKdW5lIDIwMTIKK1Vw ZGF0ZWQ6IDcgU2VwdGVtYmVyIDIwMTIKIAogMC4gSW50cm9kdWN0aW9uCiAKZGlmZiAtLWdpdCBh L2ZzL3BzdG9yZS9yYW0uYyBiL2ZzL3BzdG9yZS9yYW0uYwppbmRleCBiMjcyNDczLi5jNmU0NDg1 IDEwMDY0NAotLS0gYS9mcy9wc3RvcmUvcmFtLmMKKysrIGIvZnMvcHN0b3JlL3JhbS5jCkBAIC0y NSw2ICsyNSw3IEBACiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgv ZXJyLmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvbW9kX2Rl dmljZXRhYmxlLmg+CiAjaW5jbHVkZSA8bGludXgvdmVyc2lvbi5oPgogI2luY2x1ZGUgPGxpbnV4 L3BzdG9yZS5oPgogI2luY2x1ZGUgPGxpbnV4L3RpbWUuaD4KQEAgLTM0LDYgKzM1LDcgQEAKICNp bmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvY29tcGlsZXIuaD4KICNpbmNs dWRlIDxsaW51eC9wc3RvcmVfcmFtLmg+CisjaW5jbHVkZSA8bGludXgvb2YuaD4KICNpbmNsdWRl IDxsaW51eC9vZl9hZGRyZXNzLmg+CiAKICNkZWZpbmUgUkFNT09QU19LRVJOTVNHX0hEUiAiPT09 PSIKQEAgLTM1NCw3ICszNTYsOCBAQCBzdGF0aWMgaW50IHJhbW9vcHNfaW5pdF9wcnooc3RydWN0 IGRldmljZSAqZGV2LCBzdHJ1Y3QgcmFtb29wc19jb250ZXh0ICpjeHQsCiB9CiAKICNpZmRlZiBD T05GSUdfT0YKLXN0YXRpYyBzdHJ1Y3QgcmFtb29wc19wbGF0Zm9ybV9kYXRhICogX19pbml0CisK K3N0YXRpYyBzdHJ1Y3QgcmFtb29wc19wbGF0Zm9ybV9kYXRhICogX19kZXZpbml0CiBvZl9yYW1v b3BzX3BsYXRmb3JtX2RhdGEoc3RydWN0IGRldmljZSAqZGV2KQogewogCXN0cnVjdCBkZXZpY2Vf bm9kZSAqbm9kZSA9IGRldi0+b2Zfbm9kZTsKQEAgLTM2NCwzMCArMzY3LDM2IEBAIG9mX3JhbW9v cHNfcGxhdGZvcm1fZGF0YShzdHJ1Y3QgZGV2aWNlICpkZXYpCiAJdTMyIHZhbDsKIAogCXBkYXRh ID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpwZGF0YSksIEdGUF9LRVJORUwpOwotCWlmIChw ZGF0YSA9PSBOVUxMKQorCWlmICghcGRhdGEpCiAJCXJldHVybiBOVUxMOwogCiAJYWRkcnAgPSBv Zl9nZXRfYWRkcmVzcyhub2RlLCAwLCAmc2l6ZSwgTlVMTCk7Ci0JaWYgKGFkZHJwID09IE5VTEwp CisJaWYgKCFhZGRycCkKIAkJcmV0dXJuIE5VTEw7CisKIAlwZGF0YS0+bWVtX2FkZHJlc3MgPSBv Zl90cmFuc2xhdGVfYWRkcmVzcyhub2RlLCBhZGRycCk7CiAJcGRhdGEtPm1lbV9zaXplID0gc2l6 ZTsKIAotCWlmICghb2ZfcHJvcGVydHlfcmVhZF91MzIobm9kZSwgInJlY29yZC1zaXplIiwgJnZh bCkpCi0JCXBkYXRhLT5yZWNvcmRfc2l6ZSA9IHZhbDsKLQlpZiAoIW9mX3Byb3BlcnR5X3JlYWRf dTMyKG5vZGUsICJjb25zb2xlLXNpemUiLCAmdmFsKSkKLQkJcGRhdGEtPmNvbnNvbGVfc2l6ZSA9 IHZhbDsKLQlpZiAoIW9mX3Byb3BlcnR5X3JlYWRfdTMyKG5vZGUsICJmdHJhY2Utc2l6ZSIsICZ2 YWwpKQotCQlwZGF0YS0+ZnRyYWNlX3NpemUgPSB2YWw7CisJcGRhdGEtPnJlY29yZF9zaXplID0g cmVjb3JkX3NpemU7CisJcGRhdGEtPmNvbnNvbGVfc2l6ZSA9IHJhbW9vcHNfY29uc29sZV9zaXpl OworCXBkYXRhLT5mdHJhY2Vfc2l6ZSA9IHJhbW9vcHNfZnRyYWNlX3NpemU7CisJcGRhdGEtPmR1 bXBfb29wcyA9IGR1bXBfb29wczsKKwogCWlmICghb2ZfcHJvcGVydHlfcmVhZF91MzIobm9kZSwg ImVjYy1zaXplIiwgJnZhbCkpCiAJCXBkYXRhLT5lY2Nfc2l6ZSA9IHZhbDsKLQlpZiAob2ZfZ2V0 X3Byb3BlcnR5KG5vZGUsICJkdW1wLW9vcHMiLCBOVUxMKSkKLQkJcGRhdGEtPmR1bXBfb29wcyA9 IDE7CiAKIAlyZXR1cm4gcGRhdGE7CiB9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNl X2lkIHJhbW9vcHNfb2ZfbWF0Y2hbXSA9IHsKKwl7IC5jb21wYXRpYmxlID0gInJhbW9vcHMiLCB9 LAorCXsgfSwKK307CitNT0RVTEVfREVWSUNFX1RBQkxFKG9mLCByYW1vb3BzX29mX21hdGNoKTsK KwogI2Vsc2UKLSNkZWZpbmUgb2ZfcmFtb29wc19wbGF0Zm9ybV9kYXRhKGRldikgTlVMTAorc3Rh dGljIGlubGluZSBzdHJ1Y3QgcmFtb29wc19wbGF0Zm9ybV9kYXRhICoKK29mX3JhbW9vcHNfcGxh dGZvcm1fZGF0YShzdHJ1Y3QgZGV2aWNlICpkZXYpIHsgcmV0dXJuIE5VTEw7IH0KICNlbmRpZgog CiBzdGF0aWMgaW50IF9fZGV2aW5pdCByYW1vb3BzX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZp Y2UgKnBkZXYpCi0gLSAtIC0KCgoKU28sIHRoZSByZXN1bHRpbmcgcGF0Y2ggaXMgZG93biBiZWxv dy4gQnV0IEkgaGF2ZSBub3QgcHVzaGVkCml0IG91dCB5ZXQsIEknbSB3YWl0aW5nIGZvciB5b3Vy IHNpZ24gb2ZmLiBJZiB5b3UncmUgT0sgd2l0aCB0aGUKY2hhbmdlcywgcGxlYXNlIHJlcGx5IHdp dGgKJ1NpZ25lZC1vZmYtYnk6IEJyeWFuIEZyZWVkIDxiZnJlZWRAY2hyb21pdW0ub3JnPicKClRo YW5rcyEKCi0gLSAtIC0KRnJvbTogQnJ5YW4gRnJlZWQgPGJmcmVlZEBjaHJvbWl1bS5vcmc+ClN1 YmplY3Q6IHBzdG9yZS9yYW06IEFkZCByYW1vb3BzIHN1cHBvcnQgZm9yIHRoZSBGbGF0dGVuZWQg RGV2aWNlIFRyZWUKCldoZW4gY2FsbGVkIHdpdGggYSBub24temVybyBvZl9ub2RlLCBmaWxsIG91 dCBhIG5ldyByYW1vb3BzX3BsYXRmb3JtX2RhdGEKd2l0aCBkYXRhIGZyb20gdGhlIHNwZWNpZmll ZCBGbGF0dGVuZWQgRGV2aWNlIFRyZWUgbm9kZS4KVXBkYXRlIHJhbW9vcHMgZG9jdW1lbnRhdGlv biB3aXRoIHRoZSBuZXcgRkRUIGludGVyZmFjZS4KVXBkYXRlIGRldmljZXRyZWUvYmluZGluZyBk b2N1bWVudGF0aW9uIHdpdGggcHN0b3JlL3JhbW9vcHMudHh0LgoKTm90LXlldC1zaWduZWQtb2Zm LWJ5OiBCcnlhbiBGcmVlZCA8YmZyZWVkQGNocm9taXVtLm9yZz4KQWNrZWQtYnk6IEtlZXMgQ29v ayA8a2Vlc2Nvb2tAY2hyb21pdW0ub3JnPgpTaWduZWQtb2ZmLWJ5OiBBbnRvbiBWb3JvbnRzb3Yg PGFudG9uLnZvcm9udHNvdkBsaW5hcm8ub3JnPgotLS0KIC4uLi9kZXZpY2V0cmVlL2JpbmRpbmdz L3BzdG9yZS9yYW1vb3BzLnR4dCAgICAgICAgIHwgMTcgKysrKysrKwogRG9jdW1lbnRhdGlvbi9y YW1vb3BzLnR4dCAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgNyArKy0KIGZzL3BzdG9yZS9y YW0uYyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgNTYgKysrKysrKysrKysr KysrKysrKysrKwogMyBmaWxlcyBjaGFuZ2VkLCA3OCBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9u cygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5n cy9wc3RvcmUvcmFtb29wcy50eHQKCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RldmljZXRy ZWUvYmluZGluZ3MvcHN0b3JlL3JhbW9vcHMudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVl L2JpbmRpbmdzL3BzdG9yZS9yYW1vb3BzLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwLi4xZDQzMzA1Ci0tLSAvZGV2L251bGwKKysrIGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0 cmVlL2JpbmRpbmdzL3BzdG9yZS9yYW1vb3BzLnR4dApAQCAtMCwwICsxLDE3IEBACitSYW1vb3Bz IG9vcHMvcGFuaWMvY29uc29sZS90cmFjZSBsb2dnZXIKKworUmVxdWlyZWQgcHJvcGVydGllczoK Ky0gY29tcGF0aWJsZTogTXVzdCBiZSAicmFtb29wcyIuCistIHJlZzogU3BlY2lmaWVzIHRoZSBi YXNlIHBoeXNpY2FsIGFkZHJlc3MgYW5kIHNpemUgb2YgcHJlc2VydmVkIG1lbW9yeS4KKworT3B0 aW9uYWwgcHJvcGVydGllczoKKy0gZWNjLXNpemU6IFNwZWNpZmllcyB0aGUgc2l6ZSBvZiBlYWNo IHJlY29yZCdzIEVDQyBidWZmZXIuCisKK0V4YW1wbGU6CisKK3JhbW9vcHMgeworCWNvbXBhdGli bGUgPSAicmFtb29wcyI7CisJcmVnID0gPDB4NDFmMDAwMDAgMHgwMDEwMDAwMD47Cit9OworVGhl ICJyZWcgPSA8MHg0MWYwMDAwMCAweDAwMTAwMDAwPiIgbGluZSBzcGVjaWZpZXMgYSBwcmVzZXJ2 ZWQgbWVtb3J5CitzaXplIG9mIDFNQiBhdCBwaHlzaWNhbCBhZGRyZXNzIDB4NDFmMDAwMDAuCmRp ZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3JhbW9vcHMudHh0IGIvRG9jdW1lbnRhdGlvbi9yYW1v b3BzLnR4dAppbmRleCA2OWIzY2FjLi5hOWQwYzZhIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9u L3JhbW9vcHMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vcmFtb29wcy50eHQKQEAgLTMsNyArMyw3 IEBAIFJhbW9vcHMgb29wcy9wYW5pYyBsb2dnZXIKIAogU2VyZ2l1IElvcmRhY2hlIDxzZXJnaXVA Y2hyb21pdW0ub3JnPgogCi1VcGRhdGVkOiAxNyBOb3ZlbWJlciAyMDExCitVcGRhdGVkOiA3IFNl cHRlbWJlciAyMDEyCiAKIDAuIEludHJvZHVjdGlvbgogCkBAIC0zNyw3ICszNyw3IEBAIGNvcnJ1 cHQsIGJ1dCB1c3VhbGx5IGl0IGlzIHJlc3RvcmFibGUuCiAKIDIuIFNldHRpbmcgdGhlIHBhcmFt ZXRlcnMKIAotU2V0dGluZyB0aGUgcmFtb29wcyBwYXJhbWV0ZXJzIGNhbiBiZSBkb25lIGluIDIg ZGlmZmVyZW50IG1hbm5lcnM6CitTZXR0aW5nIHRoZSByYW1vb3BzIHBhcmFtZXRlcnMgY2FuIGJl IGRvbmUgaW4gMyBkaWZmZXJlbnQgbWFubmVyczoKICAxLiBVc2UgdGhlIG1vZHVsZSBwYXJhbWV0 ZXJzICh3aGljaCBoYXZlIHRoZSBuYW1lcyBvZiB0aGUgdmFyaWFibGVzIGRlc2NyaWJlZAogIGFz IGJlZm9yZSkuCiAgRm9yIHF1aWNrIGRlYnVnZ2luZywgeW91IGNhbiBhbHNvIHJlc2VydmUgcGFy dHMgb2YgbWVtb3J5IGR1cmluZyBib290CkBAIC04NCw2ICs4NCw5IEBAIHZlcnkgZWFybHkgaW4g dGhlIGFyY2hpdGVjdHVyZSBjb2RlLCBlLmcuOgogCiBtZW1ibG9ja19yZXNlcnZlKHJhbW9vcHNf ZGF0YS5tZW1fYWRkcmVzcywgcmFtb29wc19kYXRhLm1lbV9zaXplKTsKIAorIDMuIFVzZSB0aGUg RmxhdHRlbmVkIERldmljZSBUcmVlIHRvIHNldCB0aGUgcGxhdGZvcm0gZGF0YS4KKyBUaGlzIGlz IGRlc2NyaWJlZCBpbiBkZXZpY2V0cmVlL2JpbmRpbmdzL3BzdG9yZS9yYW1vb3BzLnR4dC4KKwog My4gRHVtcCBmb3JtYXQKIAogVGhlIGRhdGEgZHVtcCBiZWdpbnMgd2l0aCBhIGhlYWRlciwgY3Vy cmVudGx5IGRlZmluZWQgYXMgIj09PT0iIGZvbGxvd2VkIGJ5IGEKZGlmZiAtLWdpdCBhL2ZzL3Bz dG9yZS9yYW0uYyBiL2ZzL3BzdG9yZS9yYW0uYwppbmRleCAxYTRmNmRhLi5jNmU0NDg1IDEwMDY0 NAotLS0gYS9mcy9wc3RvcmUvcmFtLmMKKysrIGIvZnMvcHN0b3JlL3JhbS5jCkBAIC0yNSw2ICsy NSw3IEBACiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgvZXJyLmg+ CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvbW9kX2RldmljZXRh YmxlLmg+CiAjaW5jbHVkZSA8bGludXgvdmVyc2lvbi5oPgogI2luY2x1ZGUgPGxpbnV4L3BzdG9y ZS5oPgogI2luY2x1ZGUgPGxpbnV4L3RpbWUuaD4KQEAgLTM0LDYgKzM1LDggQEAKICNpbmNsdWRl IDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvY29tcGlsZXIuaD4KICNpbmNsdWRlIDxs aW51eC9wc3RvcmVfcmFtLmg+CisjaW5jbHVkZSA8bGludXgvb2YuaD4KKyNpbmNsdWRlIDxsaW51 eC9vZl9hZGRyZXNzLmg+CiAKICNkZWZpbmUgUkFNT09QU19LRVJOTVNHX0hEUiAiPT09PSIKICNk ZWZpbmUgTUlOX01FTV9TSVpFIDQwOTZVTApAQCAtMzUyLDYgKzM1NSw1MCBAQCBzdGF0aWMgaW50 IHJhbW9vcHNfaW5pdF9wcnooc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgcmFtb29wc19jb250 ZXh0ICpjeHQsCiAJcmV0dXJuIDA7CiB9CiAKKyNpZmRlZiBDT05GSUdfT0YKKworc3RhdGljIHN0 cnVjdCByYW1vb3BzX3BsYXRmb3JtX2RhdGEgKiBfX2RldmluaXQKK29mX3JhbW9vcHNfcGxhdGZv cm1fZGF0YShzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJc3RydWN0IGRldmljZV9ub2RlICpub2Rl ID0gZGV2LT5vZl9ub2RlOworCXN0cnVjdCByYW1vb3BzX3BsYXRmb3JtX2RhdGEgKnBkYXRhOwor CWNvbnN0IF9fYmUzMiAqYWRkcnA7CisJdTY0IHNpemU7CisJdTMyIHZhbDsKKworCXBkYXRhID0g ZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpwZGF0YSksIEdGUF9LRVJORUwpOworCWlmICghcGRh dGEpCisJCXJldHVybiBOVUxMOworCisJYWRkcnAgPSBvZl9nZXRfYWRkcmVzcyhub2RlLCAwLCAm c2l6ZSwgTlVMTCk7CisJaWYgKCFhZGRycCkKKwkJcmV0dXJuIE5VTEw7CisKKwlwZGF0YS0+bWVt X2FkZHJlc3MgPSBvZl90cmFuc2xhdGVfYWRkcmVzcyhub2RlLCBhZGRycCk7CisJcGRhdGEtPm1l bV9zaXplID0gc2l6ZTsKKworCXBkYXRhLT5yZWNvcmRfc2l6ZSA9IHJlY29yZF9zaXplOworCXBk YXRhLT5jb25zb2xlX3NpemUgPSByYW1vb3BzX2NvbnNvbGVfc2l6ZTsKKwlwZGF0YS0+ZnRyYWNl X3NpemUgPSByYW1vb3BzX2Z0cmFjZV9zaXplOworCXBkYXRhLT5kdW1wX29vcHMgPSBkdW1wX29v cHM7CisKKwlpZiAoIW9mX3Byb3BlcnR5X3JlYWRfdTMyKG5vZGUsICJlY2Mtc2l6ZSIsICZ2YWwp KQorCQlwZGF0YS0+ZWNjX3NpemUgPSB2YWw7CisKKwlyZXR1cm4gcGRhdGE7Cit9CisKK3N0YXRp YyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIHJhbW9vcHNfb2ZfbWF0Y2hbXSA9IHsKKwl7IC5j b21wYXRpYmxlID0gInJhbW9vcHMiLCB9LAorCXsgfSwKK307CitNT0RVTEVfREVWSUNFX1RBQkxF KG9mLCByYW1vb3BzX29mX21hdGNoKTsKKworI2Vsc2UKK3N0YXRpYyBpbmxpbmUgc3RydWN0IHJh bW9vcHNfcGxhdGZvcm1fZGF0YSAqCitvZl9yYW1vb3BzX3BsYXRmb3JtX2RhdGEoc3RydWN0IGRl dmljZSAqZGV2KSB7IHJldHVybiBOVUxMOyB9CisjZW5kaWYKKwogc3RhdGljIGludCBfX2Rldmlu aXQgcmFtb29wc19wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogewogCXN0cnVj dCBkZXZpY2UgKmRldiA9ICZwZGV2LT5kZXY7CkBAIC0zNjcsNiArNDE0LDE0IEBAIHN0YXRpYyBp bnQgX19kZXZpbml0IHJhbW9vcHNfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikK IAlpZiAoY3h0LT5tYXhfZHVtcF9jbnQpCiAJCWdvdG8gZmFpbF9vdXQ7CiAKKwlpZiAoIXBkYXRh ICYmIHBkZXYtPmRldi5vZl9ub2RlKSB7CisJCXBkYXRhID0gb2ZfcmFtb29wc19wbGF0Zm9ybV9k YXRhKCZwZGV2LT5kZXYpOworCQlpZiAoIXBkYXRhKSB7CisJCQlwcl9lcnIoIkludmFsaWQgcmFt b29wcyBkZXZpY2UgdHJlZSBkYXRhXG4iKTsKKwkJCWdvdG8gZmFpbF9vdXQ7CisJCX0KKwl9CisK IAlpZiAoIXBkYXRhLT5tZW1fc2l6ZSB8fCAoIXBkYXRhLT5yZWNvcmRfc2l6ZSAmJiAhcGRhdGEt PmNvbnNvbGVfc2l6ZSAmJgogCQkJIXBkYXRhLT5mdHJhY2Vfc2l6ZSkpIHsKIAkJcHJfZXJyKCJU aGUgbWVtb3J5IHNpemUgYW5kIHRoZSByZWNvcmQvY29uc29sZSBzaXplIG11c3QgYmUgIgpAQCAt NDkyLDYgKzU0Nyw3IEBAIHN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIHJhbW9vcHNfZHJp dmVyID0gewogCS5kcml2ZXIJCT0gewogCQkubmFtZQk9ICJyYW1vb3BzIiwKIAkJLm93bmVyCT0g VEhJU19NT0RVTEUsCisJCS5vZl9tYXRjaF90YWJsZSA9IG9mX21hdGNoX3B0cihyYW1vb3BzX29m X21hdGNoKSwKIAl9LAogfTsKIAotLSAKMS43LjExLjUKCl9fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fCmRldmljZXRyZWUtZGlzY3VzcyBtYWlsaW5nIGxpc3QK ZGV2aWNldHJlZS1kaXNjdXNzQGxpc3RzLm96bGFicy5vcmcKaHR0cHM6Ly9saXN0cy5vemxhYnMu b3JnL2xpc3RpbmZvL2RldmljZXRyZWUtZGlzY3Vzcwo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751497Ab2IHFbt (ORCPT ); Sat, 8 Sep 2012 01:31:49 -0400 Received: from mail-pz0-f46.google.com ([209.85.210.46]:39180 "EHLO mail-pz0-f46.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750902Ab2IHFbp (ORCPT ); Sat, 8 Sep 2012 01:31:45 -0400 Date: Fri, 7 Sep 2012 22:29:10 -0700 From: Anton Vorontsov To: Bryan Freed Cc: John Stultz , linux-kernel@vger.kernel.org, keescook@chromium.org, marco.stornelli@gmail.com, sboyd@codeaurora.org, gregkh@linuxfoundation.org, Colin Cross , Tony Luck , devicetree-discuss@lists.ozlabs.org Subject: Re: [PATCH v6] pstore/ram: Add ramoops support for the Flattened Device Tree. Message-ID: <20120908052907.GA4724@lizard> References: <1347042576-17675-1-git-send-email-bfreed@chromium.org> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <1347042576-17675-1-git-send-email-bfreed@chromium.org> User-Agent: Mutt/1.5.21 (2010-09-15) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Fri, Sep 07, 2012 at 11:29:36AM -0700, Bryan Freed wrote: > When called with a non-zero of_node, fill out a new ramoops_platform_data > with data from the specified Flattened Device Tree node. > Update ramoops documentation with the new FDT interface. > Update devicetree/binding documentation with pstore/ramoops.txt. Thanks for your work, Bryan! There were a few issues, I fixed them myself but I need your confirmation if you're OK w/ all the changes. First of, the Signed-off-by tag is missing, but I see it in v5. I also see that v5 had an Ack from Kees Cook, you did not preserve it, but generally it's a good idea to do so (if vX -> v(X+1) changes aren't drastic). [...] > +Optional properties: > +- record-size: Specifies the size of each record in preserved memory. > +- console-size: Specifies the size of the console log. > +- ftrace-size: Specifies the size of the ftrace log. > +- ecc-size: Specifies the size of each record's ECC buffer. > +- dump-oops: Specifies to dump oops in addition to panics. Personally, I don't see how this fits into device tree. It doesn't describe hardware, instead it's more a configuration stuff, which usually we try to not put into the device tree. It would be better to have a sane defaults in ramoops, instead of introducing more "virtual" stuff in the device tree. That is, feel free to change defaults if they seem to be not enough for most your setups. The only property that I see which is truly hardware-specific is ecc-size. E.g. if we're pretty sure that a specific hw does not need ecc, it's OK to avoid it. And some hw setups might require bigger ECC sizes, so it's OK to have it in the device-tree. > static struct ramoops_platform_data * __init > of_ramoops_platform_data(struct device *dev) You call this function from __devinit section, so using __init is an error. WARNING: fs/pstore/ramoops.o(.devinit.text+0x37): Section mismatch in reference from the function ramoops_probe() to the function .init.text:of_ramoops_platform_data() The function __devinit ramoops_probe() references I changed this to __devnit. [...] > + pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); > + if (pdata == NULL) I wonder why people prefer to not write !pdata, which is more natural when reading the code.. :-) [...] > +#else > +#define of_ramoops_platform_data(dev) NULL Using static inline would be better, i.e. type-safe. >+ .of_match_table = of_match_ptr(ramoops_of_match), This fails to build: fs/pstore/ram.c: At top level: fs/pstore/ram.c:540:22: error: ‘ramoops_of_match’ undeclared here (not in a function) For some reason you lost ramoops_of_match hunk from the v5. So I made these changes on top of your patch (note, there's more text at the end of the email): - - - - diff --git a/Documentation/devicetree/bindings/pstore/ramoops.txt b/Documentation/devicetree/bindings/pstore/ramoops.txt index 2fddba4..1d43305 100644 --- a/Documentation/devicetree/bindings/pstore/ramoops.txt +++ b/Documentation/devicetree/bindings/pstore/ramoops.txt @@ -1,30 +1,17 @@ -Ramoops oops/panic/console logger +Ramoops oops/panic/console/trace logger Required properties: - compatible: Must be "ramoops". - reg: Specifies the base physical address and size of preserved memory. Optional properties: -- record-size: Specifies the size of each record in preserved memory. -- console-size: Specifies the size of the console log. -- ftrace-size: Specifies the size of the ftrace log. - ecc-size: Specifies the size of each record's ECC buffer. -- dump-oops: Specifies to dump oops in addition to panics. Example: ramoops { compatible = "ramoops"; reg = <0x41f00000 0x00100000>; - record-size = <0x00020000>; - ftrace-size = <0x00020000>; - dump-oops; }; The "reg = <0x41f00000 0x00100000>" line specifies a preserved memory size of 1MB at physical address 0x41f00000. -The "record-size = <0x00020000>" line specifies a record size of 128KB. -The "ftrace-size = <0x00020000>" line specifies an ftrace log size of 128KB. -The optional "dump-oops" line tells ramoops to dump oopses as well as panics. -At least one of record, console, or ftrace size must be specified. -In this example, 128KB is allocated to the ftrace log, and 896KB -(1024KB - 128KB) is allocated to oops and panic records. diff --git a/Documentation/ramoops.txt b/Documentation/ramoops.txt index 82d825d..a9d0c6a 100644 --- a/Documentation/ramoops.txt +++ b/Documentation/ramoops.txt @@ -3,7 +3,7 @@ Ramoops oops/panic logger Sergiu Iordache -Updated: 5 June 2012 +Updated: 7 September 2012 0. Introduction diff --git a/fs/pstore/ram.c b/fs/pstore/ram.c index b272473..c6e4485 100644 --- a/fs/pstore/ram.c +++ b/fs/pstore/ram.c @@ -25,6 +25,7 @@ #include #include #include +#include #include #include #include @@ -34,6 +35,7 @@ #include #include #include +#include #include #define RAMOOPS_KERNMSG_HDR "====" @@ -354,7 +356,8 @@ static int ramoops_init_prz(struct device *dev, struct ramoops_context *cxt, } #ifdef CONFIG_OF -static struct ramoops_platform_data * __init + +static struct ramoops_platform_data * __devinit of_ramoops_platform_data(struct device *dev) { struct device_node *node = dev->of_node; @@ -364,30 +367,36 @@ of_ramoops_platform_data(struct device *dev) u32 val; pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); - if (pdata == NULL) + if (!pdata) return NULL; addrp = of_get_address(node, 0, &size, NULL); - if (addrp == NULL) + if (!addrp) return NULL; + pdata->mem_address = of_translate_address(node, addrp); pdata->mem_size = size; - if (!of_property_read_u32(node, "record-size", &val)) - pdata->record_size = val; - if (!of_property_read_u32(node, "console-size", &val)) - pdata->console_size = val; - if (!of_property_read_u32(node, "ftrace-size", &val)) - pdata->ftrace_size = val; + pdata->record_size = record_size; + pdata->console_size = ramoops_console_size; + pdata->ftrace_size = ramoops_ftrace_size; + pdata->dump_oops = dump_oops; + if (!of_property_read_u32(node, "ecc-size", &val)) pdata->ecc_size = val; - if (of_get_property(node, "dump-oops", NULL)) - pdata->dump_oops = 1; return pdata; } + +static const struct of_device_id ramoops_of_match[] = { + { .compatible = "ramoops", }, + { }, +}; +MODULE_DEVICE_TABLE(of, ramoops_of_match); + #else -#define of_ramoops_platform_data(dev) NULL +static inline struct ramoops_platform_data * +of_ramoops_platform_data(struct device *dev) { return NULL; } #endif static int __devinit ramoops_probe(struct platform_device *pdev) - - - - So, the resulting patch is down below. But I have not pushed it out yet, I'm waiting for your sign off. If you're OK with the changes, please reply with 'Signed-off-by: Bryan Freed ' Thanks! - - - - From: Bryan Freed Subject: pstore/ram: Add ramoops support for the Flattened Device Tree When called with a non-zero of_node, fill out a new ramoops_platform_data with data from the specified Flattened Device Tree node. Update ramoops documentation with the new FDT interface. Update devicetree/binding documentation with pstore/ramoops.txt. Not-yet-signed-off-by: Bryan Freed Acked-by: Kees Cook Signed-off-by: Anton Vorontsov --- .../devicetree/bindings/pstore/ramoops.txt | 17 +++++++ Documentation/ramoops.txt | 7 ++- fs/pstore/ram.c | 56 ++++++++++++++++++++++ 3 files changed, 78 insertions(+), 2 deletions(-) create mode 100644 Documentation/devicetree/bindings/pstore/ramoops.txt diff --git a/Documentation/devicetree/bindings/pstore/ramoops.txt b/Documentation/devicetree/bindings/pstore/ramoops.txt new file mode 100644 index 0000000..1d43305 --- /dev/null +++ b/Documentation/devicetree/bindings/pstore/ramoops.txt @@ -0,0 +1,17 @@ +Ramoops oops/panic/console/trace logger + +Required properties: +- compatible: Must be "ramoops". +- reg: Specifies the base physical address and size of preserved memory. + +Optional properties: +- ecc-size: Specifies the size of each record's ECC buffer. + +Example: + +ramoops { + compatible = "ramoops"; + reg = <0x41f00000 0x00100000>; +}; +The "reg = <0x41f00000 0x00100000>" line specifies a preserved memory +size of 1MB at physical address 0x41f00000. diff --git a/Documentation/ramoops.txt b/Documentation/ramoops.txt index 69b3cac..a9d0c6a 100644 --- a/Documentation/ramoops.txt +++ b/Documentation/ramoops.txt @@ -3,7 +3,7 @@ Ramoops oops/panic logger Sergiu Iordache -Updated: 17 November 2011 +Updated: 7 September 2012 0. Introduction @@ -37,7 +37,7 @@ corrupt, but usually it is restorable. 2. Setting the parameters -Setting the ramoops parameters can be done in 2 different manners: +Setting the ramoops parameters can be done in 3 different manners: 1. Use the module parameters (which have the names of the variables described as before). For quick debugging, you can also reserve parts of memory during boot @@ -84,6 +84,9 @@ very early in the architecture code, e.g.: memblock_reserve(ramoops_data.mem_address, ramoops_data.mem_size); + 3. Use the Flattened Device Tree to set the platform data. + This is described in devicetree/bindings/pstore/ramoops.txt. + 3. Dump format The data dump begins with a header, currently defined as "====" followed by a diff --git a/fs/pstore/ram.c b/fs/pstore/ram.c index 1a4f6da..c6e4485 100644 --- a/fs/pstore/ram.c +++ b/fs/pstore/ram.c @@ -25,6 +25,7 @@ #include #include #include +#include #include #include #include @@ -34,6 +35,8 @@ #include #include #include +#include +#include #define RAMOOPS_KERNMSG_HDR "====" #define MIN_MEM_SIZE 4096UL @@ -352,6 +355,50 @@ static int ramoops_init_prz(struct device *dev, struct ramoops_context *cxt, return 0; } +#ifdef CONFIG_OF + +static struct ramoops_platform_data * __devinit +of_ramoops_platform_data(struct device *dev) +{ + struct device_node *node = dev->of_node; + struct ramoops_platform_data *pdata; + const __be32 *addrp; + u64 size; + u32 val; + + pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); + if (!pdata) + return NULL; + + addrp = of_get_address(node, 0, &size, NULL); + if (!addrp) + return NULL; + + pdata->mem_address = of_translate_address(node, addrp); + pdata->mem_size = size; + + pdata->record_size = record_size; + pdata->console_size = ramoops_console_size; + pdata->ftrace_size = ramoops_ftrace_size; + pdata->dump_oops = dump_oops; + + if (!of_property_read_u32(node, "ecc-size", &val)) + pdata->ecc_size = val; + + return pdata; +} + +static const struct of_device_id ramoops_of_match[] = { + { .compatible = "ramoops", }, + { }, +}; +MODULE_DEVICE_TABLE(of, ramoops_of_match); + +#else +static inline struct ramoops_platform_data * +of_ramoops_platform_data(struct device *dev) { return NULL; } +#endif + static int __devinit ramoops_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; @@ -367,6 +414,14 @@ static int __devinit ramoops_probe(struct platform_device *pdev) if (cxt->max_dump_cnt) goto fail_out; + if (!pdata && pdev->dev.of_node) { + pdata = of_ramoops_platform_data(&pdev->dev); + if (!pdata) { + pr_err("Invalid ramoops device tree data\n"); + goto fail_out; + } + } + if (!pdata->mem_size || (!pdata->record_size && !pdata->console_size && !pdata->ftrace_size)) { pr_err("The memory size and the record/console size must be " @@ -492,6 +547,7 @@ static struct platform_driver ramoops_driver = { .driver = { .name = "ramoops", .owner = THIS_MODULE, + .of_match_table = of_match_ptr(ramoops_of_match), }, }; -- 1.7.11.5