From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eu1sys200aog103.obsmtp.com ([207.126.144.115]) by merlin.infradead.org with smtps (Exim 4.76 #1 (Red Hat Linux)) id 1TYaee-000544-Lm for linux-mtd@lists.infradead.org; Wed, 14 Nov 2012 10:57:14 +0000 Message-ID: <50A3797A.4040406@st.com> Date: Wed, 14 Nov 2012 10:59:06 +0000 From: Angus CLARK MIME-Version: 1.0 To: linux-mtd@lists.infradead.org Subject: Re: state of support for "external ECC hardware" References: <20121029204227.GA32300@harvey-pc.matrox.com> In-Reply-To: <20121029204227.GA32300@harvey-pc.matrox.com> Content-Type: multipart/mixed; boundary="------------060906060807000605060201" Cc: charvey@matrox.com, gerlando.falauto@keymile.com, Ivan Djelic List-Id: Linux MTD discussion mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , This is a multi-part message in MIME format. --------------060906060807000605060201 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit Hi Chris, Sorry to come to this thread late (I have been working on non-Flash related projects recently!), but I have used several Micron "on-die" ECC parts so I thought I would share my experience. I will try to collate here my comments to some of the issues raised in the thread. On 11/08/2012 04:21 PM, Christopher Harvey wrote: > We had BCH8 code running, but it wasn't enough. The main reason we > switched away from host side ECC was because we were getting bitflips > within the ECC codeword data itself. I think this point has already been dealt with by others, but just to confirm, the ECC algorithms handle bit-flips in the data or ECC code. (In fact, as part of my test procedures, I manually insert bit-errors in the data and ECC areas and check for correct fixups.) On 11/08/2012 04:37 PM, Gerlando Falauto wrote: > And BTW, wouldn't you also need to explicitly disable on-die ECC in > order to force that, anyway? Yes, to insert bit-errors your driver needs to support raw read and write operations. You can then use a combination of nandwrite and nanddump to inject 1 or more bitflips, something like: 1. Write data to Flash, generating ECC data in the process nandwrite page.bin /dev/mtd? 2. Read data + OOB in raw mode nanddump --noecc --oob --length=2048 --file=page_ecc.bin /dev/mtd? 3. Check data for no *real* bit flips 4. Inject bit-flips to 'page_ecc.bin' 5. Write corrupted data to a new page, in raw mode nandwrite --noecc --oob page_ecc_err.bin 6. Read back, using ECC nanddump --length --file=page_ecc_fix.bin 7. Check bit-flips have been corrected [I have a standalone program that implements the same procedure, testing every bit and multiple bits, although it is not really fit for public consumption I am afraid.] On 11/08/2012 05:02 PM, Christopher Harvey wrote: > I was surprised too. I was seeing about 30 bitflips per 512MB. Running > at about 1/3 of max bus speed. No error codes on write. That is probably a bit higher than we have experienced, but not significantly so. On 11/08/2012 05:02 PM, Christopher Harvey wrote: > I don't know the details of BCH, but apparently not. I asked Micron if > the OOB area was safer to write to, and they said no. Can somebody on > this list confirm this? The OOB area is the same as any other part of the page, in terms of reliability, and therefore subject to the same ECC requirements. One thing to look out for with the Micron devices is that the on-die ECC is applied to some but not all of the OOB area. For the ECC-protected OOB, it is important that any data here is written at the same time as the page data -- this has consequences when using filesystems that store meta-data in the OOB (eg YAFFS2 and JFFS2 to some extent). At the time, there was no user-space tool, or IOCTL, that could write Page+OOB in one go. To support writing YAFFS2 images, they had to invent their own IOCTL and a new tool! On 11/12/2012 05:19 PM, Gerlando Falauto wrote: > Would there be any reason *NOT* to use 4-bit ECC with parts which do not > require it? Apart from performance, of course. As long as your ECC potency matches or exceeds the reliability characteristics of the NAND device, there should be no problem (except perhaps performance.) Indeed, some have been known to use over-spec'ed ECC schemes in an attempt to improve endurance and data retention -- the qualification reports from the manufacturers tend to be a bit vague on how effective this strategy might be though. On 11/08/2012 11:02 AM, Gerlando Falauto wrote: > As for hardware-based (or on-die) ECC support, one of the application > notes from Micron (TN-29-56 Enabling On-Die ECC for OMAP3 on > Linux/Android OS The TN provides a good start, but neglects a few areas, including: * the default BBT pattern clashes with on-die ECC locations * it makes no attempt to support raw read/write operations * it does not handle the the REWRITE status flag For what it's worth, I have attached the patch we added to support the Micron on-die ECC devices -- based on a rather old 2.6.32 kernel I am afraid. We have since updated the probing code that detects on-die ECC capabilities, but it might help if you are planning to do your own support. Cheers, Angus --------------060906060807000605060201 Content-Type: text/plain; name="0001-mtd_nand-Support-for-Micron-on-die-4-bit-ECC-SLC-LP-.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename*0="0001-mtd_nand-Support-for-Micron-on-die-4-bit-ECC-SLC-LP-.pa"; filename*1="tch" RnJvbSAzMWZiMWRmODc1NzE3N2U0N2UzMzY4ZjZlNzM1NjIzNzQ4NDQ5ZWY0IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbmd1cyBDTEFSSyA8YW5ndXMuY2xhcmtAc3QuY29t PgpEYXRlOiBXZWQsIDggSnVuIDIwMTEgMTc6MzE6MjQgKzAxMDAKU3ViamVjdDogW1BBVENI IChzaC0yLjYuMzIueSldIG10ZF9uYW5kOiBTdXBwb3J0IGZvciBNaWNyb24gb24tZGllIDQt Yml0IEVDQwogU0xDIExQIE5BTkQgZGV2aWNlcwoKVGhpcyBwYXRjaCBhZGRzIHN1cHBvcnQg Zm9yIHRoZSBNaWNyb24gb24tZGllIDQtYml0IEVDQyBTTEMgTFAgZmFtaWx5IG9mCmRldmlj ZXMuICBUaGUgbWFpbiBjaGFuZ2VzIGFyZToKCiAgICAqIEFkZCBzdXBwb3J0IGZvciB0aGUg U0VUL0dFVCBGRUFUVVJFUyBOQU5EIENNRCAocmVxdWlyZWQgdG8gZW5hYmxlL2Rpc2FibGUK ICAgICAgb24tZGllIEVDQykuCgogICAgKiBCQlQgc2lnbmF0dXJlIG1vdmVkIHNvIGFzIG5v dCB0byBjbGFzaCB3aXRoIHRoZSBvbi1kaWUgRUNDIGxheW91dAoKICAgICogQ2hlY2sgU1RB VFVTIGFmdGVyIFJFQUQgb3BlcmF0aW9ucyBmb3IgY29ycmVjdGFibGUvbm9uLWNvcnJlY3Rh YmxlIEVDQwogICAgICBlcnJvcnMKCiAgICAqIEFkZCBhIG5ldyBFQ0MgbGF5b3V0IGZvciBv bi1kaWUgNC1iaXQgRUNDIGRldmljZXMuIE5vdGUsIHRoZSB1c2Ugb2Ygb24tZGllCiAgICAg IEVDQyBicmluZ3MgYSBudW1iZXIgb2YgbGltaXRhdGlvbnMgdG8gdGhlIHdheSBpbiB3aGlj aCB0aGUgT09CIGFyZWEgY2FuIGJlCiAgICAgIHVzZWQuICBJbiBwYXJ0aWN1bGFyLCBzb21l IGJ5dGVzIGluIE9PQiBhcmUgRUNDLXByb3RlY3RlZCwgYW5kIHNvbWUgYXJlCiAgICAgIG5v dC4gIFRoZSBFQ0MtcHJvdGVjdGVkIGJ5dGVzIG11c3QgYmUgd3JpdHRlbiBhdCB0aGUgc2Ft ZSB0aW1lIGFzIHRoZSBwYWdlCiAgICAgIGRhdGEuICBUaGlzIGJyZWFrcyBhIG51bWJlciBv ZiBhc3N1bXB0aW9ucyBtYWRlIGJ5IGV4aXN0aW5nIE1URCBjbGllbnRzLgogICAgICBBcyBh IHJlc3VsdCwgaXQgaXMgbm90IHBvc3NpYmxlIHRvIGRlZmluZSBhIEVDQyBsYXlvdXQgdGhh dCBpcyBjb21wYXRpYmxlCiAgICAgIHdpdGggYm90aCBKRkZTMiBhbmQgWUFGRlMyLiAgSGVy ZSB3ZSBoYXZlIGNob3NlbiB0byBzdXBwb3J0IEpGRlMyLCBzaW5jZQogICAgICBpdCBicmVh a3MgZmV3ZXIgYXNzdW1wdGlvbnMsIGFuZCByZXF1aXJlcyBmZXdlciBjaGFuZ2VzIHRvIGJl IG1hZGUKICAgICAgZWxzZXdoZXJlLiAgKFVCSS9VQklGUyBpcyBmdWxseSBzdXBwb3J0ZWQs IHNpbmNlIGl0IGRvZXMgbm90IHVzZSB0aGUgT09CCiAgICAgIGFyZWEuKQoKICAgICogRGlz YWJsZSBvbi1kaWUgRUNDIGZvciAnUkFXJyBwYWdlIHJlYWQvd3JpdGUgb3BlcmF0aW9ucwoK ICAgICogRGlzYWJsZSBvbi1kaWUgRUNDIGZvciBhbGwgT09CIHJlYWQvd3JpdGUgb3BlcmF0 aW9ucyAocHJvdmlkZXMgZ3JlYXRlc3QKICAgICAgbGV2ZWwgb2YgY29tcGF0aWJpbGl0eSB3 aXRoIGV4aXN0aW5nIE1URCB1dGlsaXRpZXMpLgoKICAgICogRXh0ZW5kIG5hbmRfZ2V0X2Zs YXNoX3R5cGUoKSB0byBjb3JyZWN0bHkgZGlzdGluZ3Vpc2ggYmV0d2VlbiAibGVnYWN5IiBh bmQKICAgICAgNC1iaXQgb24tZGllIEVDQyBNaWNyb24gZGV2aWNlcy4KClNpZ25lZC1vZmYt Ynk6IEFuZ3VzIENsYXJrIDxhbmd1cy5jbGFya0BzdC5jb20+Ci0tLQogZHJpdmVycy9tdGQv bmFuZC9uYW5kX2Jhc2UuYyAgICAgfCAgMjc3ICsrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrLS0tCiBkcml2ZXJzL210ZC9uYW5kL25hbmRfYmJ0LmMgICAgICB8ICAgMzAg KysrKy0KIGRyaXZlcnMvbXRkL25hbmQvc3RtX25hbmRfZmxleC5jIHwgICAgNyArCiBpbmNs dWRlL2xpbnV4L210ZC9uYW5kLmggICAgICAgICB8ICAgIDcgKwogNCBmaWxlcyBjaGFuZ2Vk LCAzMDIgaW5zZXJ0aW9ucygrKSwgMTkgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJp dmVycy9tdGQvbmFuZC9uYW5kX2Jhc2UuYyBiL2RyaXZlcnMvbXRkL25hbmQvbmFuZF9iYXNl LmMKaW5kZXggOTgwNjBiZS4uNDU2MzRjYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbmFu ZC9uYW5kX2Jhc2UuYworKysgYi9kcml2ZXJzL210ZC9uYW5kL25hbmRfYmFzZS5jCkBAIC0x MDMsNiArMTAzLDQwIEBAIHN0YXRpYyBzdHJ1Y3QgbmFuZF9lY2NsYXlvdXQgbmFuZF9vb2Jf MTI4ID0gewogCQkgLmxlbmd0aCA9IDc4fX0KIH07CiAKKy8qIE1pY3JvbiA0LWJpdCBvbi1k aWUgRUNDIGxheW91dAorICoKKyAqIFRoZSA2NC1ieXRlIE9PQiBpcyBkaXZpZGVkIGludG8g NCBpZGVudGljYWwgcmVjb3Jkcy4gIEVhY2ggMTYtYnl0ZSByZWNvcmQgaGFzCisgKiB0aGUg Zm9sbG93aW5nIGxheW91dDoKKyAqCTB4MDAgLSAweDAxIDogUmVzZXJ2ZWQgKGZvciBCYWQg QmxvY2sgTWFya2VycykKKyAqCTB4MDIgLSAweDAzIDogVXNlciBNZXRhZGF0YSBJSSAodW5w cm90ZWN0ZWQpCisgKgkweDA0IC0gMHgwNyA6IFVzZXIgTWV0YWRhdGEgSSAgKHByb3RlY3Rl ZCkKKyAqCTB4MDggLSAweDBmIDogRUNDIGZvciBtYWluICsgTWV0YWRhdGEgSSByZWdpb25z CisgKgorICogVGhlIHVzZSBvZiBvbi1kaWUgRUNDIGJyaW5ncyBhIG51bWJlciBvZiBsaW1p dGF0aW9ucyB0byB0aGUgd2F5IGluIHdoaWNoIHRoZQorICogT09CIGFyZWEgY2FuIGJlIHVz ZWQuICBJbiBwYXJ0aWN1bGFyLCBzb21lIGJ5dGVzIGluIE9PQiBhcmUgRUNDLXByb3RlY3Rl ZCwKKyAqIGFuZCBzb21lIGFyZSBub3QuICBUaGUgRUNDLXByb3RlY3RlZCBieXRlcyBtdXN0 IGJlIHdyaXR0ZW4gYXQgdGhlIHNhbWUgdGltZQorICogYXMgdGhlIHBhZ2UgZGF0YS4gIFRo aXMgYnJlYWtzIGEgbnVtYmVyIG9mIGFzc3VtcHRpb25zIG1hZGUgYnkgZXhpc3RpbmcgTVRE CisgKiBjbGllbnRzLiAgQXMgYSByZXN1bHQsIGl0IGlzIG5vdCBwb3NzaWJsZSB0byBkZWZp bmUgYSBFQ0MgbGF5b3V0IHRoYXQgaXMKKyAqIGNvbXBhdGlibGUgd2l0aCBib3RoIEpGRlMy IGFuZCBZQUZGUzIuICBIZXJlIHdlIGhhdmUgY2hvc2VuIHRvIHN1cHBvcnQgSkZGUzIsCisg KiBzaW5jZSBpdCBicmVha3MgZmV3ZXIgYXNzdW1wdGlvbnMsIGFuZCByZXF1aXJlcyBmZXdl ciBjaGFuZ2VzIHRvIGJlIG1hZGUKKyAqIGVsc2V3aGVyZS4gIChVQkkvVUJJRlMgaXMgZnVs bHkgc3VwcG9ydGVkLCBzaW5jZSBpdCBkb2VzIG5vdCB1c2UgdGhlIE9PQgorICogYXJlYS4p CisgKi8KK3N0YXRpYyBzdHJ1Y3QgbmFuZF9lY2NsYXlvdXQgbmFuZF9vb2JfNjRfNGJpdG9u ZGllID0geworCS5lY2NieXRlcyA9IDMyLAorCS5lY2Nwb3MgPSB7CisJCTgsIDksIDEwLCAx MSwgMTIsIDEzLCAxNCwgMTUsCisJCTI0LCAyNSwgMjYsIDI3LCAyOCwgMjksIDMwLCAzMSwK KwkJNDAsIDQxLCA0MiwgNDMsIDQ0LCA0NSwgNDYsIDQ3LAorCQk1NiwgNTcsIDU4LCA1OSwg NjAsIDYxLCA2MiwgNjMgfSwKKwkub29iZnJlZSA9IHsKKwkJey5vZmZzZXQgPSAgMiwgLmxl bmd0aCA9IDJ9LAorCQl7Lm9mZnNldCA9IDE4LCAubGVuZ3RoID0gMn0sCisJCXsub2Zmc2V0 ID0gMzQsIC5sZW5ndGggPSAyfSwKKwkJey5vZmZzZXQgPSA1MCwgLmxlbmd0aCA9IDJ9CisJ fQorfTsKKwogaW50IG5hbmRfZ2V0X2RldmljZShzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwLCBz dHJ1Y3QgbXRkX2luZm8gKm10ZCwKIAkJICAgIGludCBuZXdfc3RhdGUpOwogCkBAIC00MzYs NiArNDcwLDEwNCBAQCBzdGF0aWMgaW50IG5hbmRfYmxvY2tfY2hlY2tiYWQoc3RydWN0IG10 ZF9pbmZvICptdGQsIGxvZmZfdCBvZnMsIGludCBnZXRjaGlwLAogCXJldHVybiBuYW5kX2lz YmFkX2JidChtdGQsIG9mcywgYWxsb3diYnQpOwogfQogCisvKioKKyAqIG5hbmRfZ2V0X2Zl YXR1cmVzIC0gaXNzdWUgYSAiR0VUIEZFQVRVUkVTIiBjb21tYW5kCisgKiBAbXRkOglNVEQg ZGV2aWNlIHN0cnVjdHVyZQorICogQGZlYXR1cmU6CXRoZSBmZWF0dXJlIGFkZHJlc3MgKEZB KSB0byBiZSB1c2VkCisgKiBAcGFyYW1ldGVyczoJcmV0dXJuZWQgcGFyYW1ldGVycyAoUDEs UDIsUDMsUDQpCisgKgorICogU2VuZCBhbiBlbnRpcmUgIlNFVCBGRUFUVVJFUyIgY29tbWFu ZCB0byBOQU5EIGRldmljZS4gVGhpcyBpbmNsdWRlcworICogdGhlIGZlYXR1cmUgYWRkcmVz cyAoRkEpLCBhbmQgdGhlIHNldCBvZiA0IHBhcmFtZXRlcnMgdG8gdXNlIChQMSxQMixQMyxQ NCkuCisgKi8KK3N0YXRpYyBpbnQgbmFuZF9nZXRfZmVhdHVyZXMoc3RydWN0IG10ZF9pbmZv ICptdGQsIGludCBmZWF0dXJlLAorCQkJICAgICB1aW50OF90ICpwYXJhbWV0ZXJzKQorewor CXN0cnVjdCBuYW5kX2NoaXAgKmNoaXAgPSBtdGQtPnByaXY7CisKKwkvKiBpc3N1ZSB0aGUg YXBwcm9wcmlhdGUgY29tbWFuZCArIGFkZHJlc3MgKi8KKwljaGlwLT5jbWRmdW5jKG10ZCwg TkFORF9DTURfR0VURkVBVFVSRVMsIGZlYXR1cmUsIC0xKTsKKworCS8qIHNob3J0IGRlbGF5 ICovCisJbmRlbGF5KDEwMCk7CS8qIHRXQiA9IDEwMG5zICovCisKKwkvKiB3YWl0IHVudGls ICJHRVQgRkVBVFVSRVMiIGNvbW1hbmQgaXMgcHJvY2Vzc2VkICovCisJaWYgKCFjaGlwLT5k ZXZfcmVhZHkpCisJCXVkZWxheShjaGlwLT5jaGlwX2RlbGF5KTsKKwllbHNlCisJCXdoaWxl ICghY2hpcC0+ZGV2X3JlYWR5KG10ZCkpCisJCQk7CisKKwkvKiByZWFkIHRoZSA0IHBhcmFt ZXRlcnMgKi8KKwljaGlwLT5yZWFkX2J1ZihtdGQsIHBhcmFtZXRlcnMsIDQpOworCisJREVC VUcoTVREX0RFQlVHX0xFVkVMMCwKKwkgICAgICAiJXM6IHdpdGggRkE9MHglMDJ4LCBQMT0w eCUwMngsIFAyPTB4JTAyeCwgIgorCSAgICAgICJQMz0weCUwMngsIFA0PTB4JTAyeFxuIiwK KwkgICAgICBfX2Z1bmNfXywgZmVhdHVyZSwKKwkgICAgICBwYXJhbWV0ZXJzWzBdLCBwYXJh bWV0ZXJzWzFdLCBwYXJhbWV0ZXJzWzJdLCBwYXJhbWV0ZXJzWzNdKTsKKworCXJldHVybiAw OworfQorCisvKioKKyAqIG5hbmRfc2V0X2ZlYXR1cmVzIC0gaXNzdWUgYSAiU0VUIEZFQVRV UkVTIiBjb21tYW5kCisgKiBAbXRkOglNVEQgZGV2aWNlIHN0cnVjdHVyZQorICogQGZlYXR1 cmU6CXRoZSBmZWF0dXJlIGFkZHJlc3MgKEZBKSB0byBiZSB1c2VkCisgKiBAcGFyYW1ldGVy czoJdGhlIHNldCBvZiA0IHBhcmFtZXRlcnMgdG8gdXNlIChQMSxQMixQMyxQNCkKKyAqCisg KiBTZW5kIGFuIGVudGlyZSAiU0VUIEZFQVRVUkVTIiBjb21tYW5kIHRvIE5BTkQgZGV2aWNl LiBUaGlzIGluY2x1ZGVzCisgKiB0aGUgZmVhdHVyZSBhZGRyZXNzIChGQSksIGFuZCB0aGUg c2V0IG9mIDQgcGFyYW1ldGVycyB0byB1c2UgKFAxLFAyLFAzLFA0KS4KKyAqLworc3RhdGlj IGludCBuYW5kX3NldF9mZWF0dXJlcyhzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgaW50IGZlYXR1 cmUsCisJCQkgICAgIGNvbnN0IHVpbnQ4X3QgKnBhcmFtZXRlcnMpCit7CisJc3RydWN0IG5h bmRfY2hpcCAqY2hpcCA9IG10ZC0+cHJpdjsKKworCURFQlVHKE1URF9ERUJVR19MRVZFTDAs CisJICAgICAgIiVzOiB3aXRoIEZBPTB4JTAyeCwgUDE9MHglMDJ4LCBQMj0weCUwMngsICIK KwkgICAgICAiUDM9MHglMDJ4LCBQND0weCUwMnhcbiIsCisJICAgICAgX19mdW5jX18sIGZl YXR1cmUsCisJICAgICAgcGFyYW1ldGVyc1swXSwgcGFyYW1ldGVyc1sxXSwgcGFyYW1ldGVy c1syXSwgcGFyYW1ldGVyc1szXSk7CisKKwkvKiBpc3N1ZSB0aGUgYXBwcm9wcmlhdGUgY29t bWFuZCArIGFkZHJlc3MgKi8KKwljaGlwLT5jbWRmdW5jKG10ZCwgTkFORF9DTURfU0VURkVB VFVSRVMsIGZlYXR1cmUsIC0xKTsKKworCS8qIHdyaXRlIHRoZSA0IHBhcmFtZXRlcnMgKi8K KwljaGlwLT53cml0ZV9idWYobXRkLCBwYXJhbWV0ZXJzLCA0KTsKKworCS8qIHNob3J0IGRl bGF5ICovCisJbmRlbGF5KDEwMCk7CS8qIHRXQiA9IDEwMG5zICovCisKKwkvKiB3YWl0IHVu dGlsICJTRVQgRkVBVFVSRVMiIGNvbW1hbmQgaXMgcHJvY2Vzc2VkICovCisJaWYgKCFjaGlw LT5kZXZfcmVhZHkpCisJCXVkZWxheShjaGlwLT5jaGlwX2RlbGF5KTsKKwllbHNlCisJCXdo aWxlICghY2hpcC0+ZGV2X3JlYWR5KG10ZCkpCisJCQk7CisKKwlyZXR1cm4gMDsKK30KKwor LyoKKyAqIE1pY3JvbiA0LWJpdCBvbi1kaWUgRUNDOiBlbmFibGUvZGlzYWJsZSBFQ0MgTm90 ZSwgd2UgdXNlICdlY2MucG9zdHBhZCcgYXMgYQorICogZmxhZyB0byBpbmRpY2F0ZSB0aGF0 IG9uLWRpZSBFQ0MgaXMgY3VycmVudGx5IGVuYWJsZWQ7IHVzZWQgYnkKKyAqIG5hbmRfY29t bWFuZF9scCgpIHRvIGNoZWNrIG9uLWRpZSBFQ0Mgc3RhdHVzIGFmdGVyIGEgcmVhZCBvcGVy YXRpb24uCisgKi8KK3N0YXRpYyB2b2lkIG5hbmRfbWljcm9uXzRiaXRfb25kaWVfZWNjKHN0 cnVjdCBtdGRfaW5mbyAqbXRkLCBpbnQgZW5hYmxlKQoreworCXN0cnVjdCBuYW5kX2NoaXAg KmNoaXAgPSBtdGQtPnByaXY7CisJY29uc3QgdWludDhfdCBmcF9lY2NbMl1bNF0gID0gewor CQl7MHgwLCAweDAsIDB4MCwgMHgwfSwKKwkJezB4OCwgMHgwLCAweDAsIDB4MH0KKwl9Owor CisJQlVHX09OKGVuYWJsZSAhPSAwICYmIGVuYWJsZSAhPSAxKTsKKworCW5hbmRfc2V0X2Zl YXR1cmVzKG10ZCwgTkFORF9GRUFUVVJFX01JQ1JPTl9BUlJBWV9PUF9NT0RFLAorCQkJICBm cF9lY2NbZW5hYmxlXSk7CisJY2hpcC0+ZWNjLnBvc3RwYWQgPSBlbmFibGU7Cit9CisKIC8q CiAgKiBXYWl0IGZvciB0aGUgcmVhZHkgcGluLCBhZnRlciBhIGNvbW1hbmQKICAqIFRoZSB0 aW1lb3V0IGlzIGNhdGNoZWQgbGF0ZXIuCkBAIC01ODcsMjMgKzcxOSwzMCBAQCBzdGF0aWMg dm9pZCBuYW5kX2NvbW1hbmRfbHAoc3RydWN0IG10ZF9pbmZvICptdGQsIHVuc2lnbmVkIGlu dCBjb21tYW5kLAogCWlmIChjb2x1bW4gIT0gLTEgfHwgcGFnZV9hZGRyICE9IC0xKSB7CiAJ CWludCBjdHJsID0gTkFORF9DVFJMX0NIQU5HRSB8IE5BTkRfTkNFIHwgTkFORF9BTEU7CiAK LQkJLyogU2VyaWFsbHkgaW5wdXQgYWRkcmVzcyAqLwotCQlpZiAoY29sdW1uICE9IC0xKSB7 Ci0JCQkvKiBBZGp1c3QgY29sdW1ucyBmb3IgMTYgYml0IGJ1c3dpZHRoICovCi0JCQlpZiAo Y2hpcC0+b3B0aW9ucyAmIE5BTkRfQlVTV0lEVEhfMTYpCi0JCQkJY29sdW1uID4+PSAxOwot CQkJY2hpcC0+Y21kX2N0cmwobXRkLCBjb2x1bW4sIGN0cmwpOwotCQkJY3RybCAmPSB+TkFO RF9DVFJMX0NIQU5HRTsKLQkJCWNoaXAtPmNtZF9jdHJsKG10ZCwgY29sdW1uID4+IDgsIGN0 cmwpOwotCQl9Ci0JCWlmIChwYWdlX2FkZHIgIT0gLTEpIHsKLQkJCWNoaXAtPmNtZF9jdHJs KG10ZCwgcGFnZV9hZGRyLCBjdHJsKTsKLQkJCWNoaXAtPmNtZF9jdHJsKG10ZCwgcGFnZV9h ZGRyID4+IDgsCi0JCQkJICAgICAgIE5BTkRfTkNFIHwgTkFORF9BTEUpOwotCQkJLyogT25l IG1vcmUgYWRkcmVzcyBjeWNsZSBmb3IgZGV2aWNlcyA+IDEyOE1pQiAqLwotCQkJaWYgKGNo aXAtPmNoaXBzaXplID4gKDEyOCA8PCAyMCkpCi0JCQkJY2hpcC0+Y21kX2N0cmwobXRkLCBw YWdlX2FkZHIgPj4gMTYsCisJCWlmIChjb21tYW5kID09IE5BTkRfQ01EX1NFVEZFQVRVUkVT IHx8CisJCSAgICBjb21tYW5kID09IE5BTkRfQ01EX0dFVEZFQVRVUkVTKSB7CisJCQkvKiBX cml0ZSBGZWF0dXJlIEFkZHJlc3MgKi8KKwkJCWNoaXAtPmNtZF9jdHJsKG10ZCwgY29sdW1u ICYgMHhmZiwgY3RybCk7CisJCX0gZWxzZSB7CisJCQkvKiBTZXJpYWxseSBpbnB1dCBhZGRy ZXNzICovCisJCQlpZiAoY29sdW1uICE9IC0xKSB7CisJCQkJLyogQWRqdXN0IGNvbHVtbnMg Zm9yIDE2IGJpdCBidXN3aWR0aCAqLworCQkJCWlmIChjaGlwLT5vcHRpb25zICYgTkFORF9C VVNXSURUSF8xNikKKwkJCQkJY29sdW1uID4+PSAxOworCQkJCWNoaXAtPmNtZF9jdHJsKG10 ZCwgY29sdW1uLCBjdHJsKTsKKwkJCQljdHJsICY9IH5OQU5EX0NUUkxfQ0hBTkdFOworCQkJ CWNoaXAtPmNtZF9jdHJsKG10ZCwgY29sdW1uID4+IDgsIGN0cmwpOworCQkJfQorCQkJaWYg KHBhZ2VfYWRkciAhPSAtMSkgeworCQkJCWNoaXAtPmNtZF9jdHJsKG10ZCwgcGFnZV9hZGRy LCBjdHJsKTsKKwkJCQljaGlwLT5jbWRfY3RybChtdGQsIHBhZ2VfYWRkciA+PiA4LAogCQkJ CQkgICAgICAgTkFORF9OQ0UgfCBOQU5EX0FMRSk7CisJCQkJLyogT25lIG1vcmUgYWRkcmVz cyBjeWNsZSBmb3IgZGV2aWNlcyA+IDEyOE1pQgorCQkJCSAqLworCQkJCWlmIChjaGlwLT5j aGlwc2l6ZSA+ICgxMjggPDwgMjApKQorCQkJCQljaGlwLT5jbWRfY3RybChtdGQsIHBhZ2Vf YWRkciA+PiAxNiwKKwkJCQkJCSAgICAgICBOQU5EX05DRSB8IE5BTkRfQUxFKTsKKwkJCX0K IAkJfQogCX0KIAljaGlwLT5jbWRfY3RybChtdGQsIE5BTkRfQ01EX05PTkUsIE5BTkRfTkNF IHwgTkFORF9DVFJMX0NIQU5HRSk7CkBAIC02MjQsNiArNzYzLDEzIEBAIHN0YXRpYyB2b2lk IG5hbmRfY29tbWFuZF9scChzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgdW5zaWduZWQgaW50IGNv bW1hbmQsCiAJY2FzZSBOQU5EX0NNRF9ERVBMRVRFMToKIAkJcmV0dXJuOwogCisJY2FzZSBO QU5EX0NNRF9TRVRGRUFUVVJFUzoKKwkJbmRlbGF5KDcwKTsJLyogdEFETCA9IDcwbnMgKi8K KwkJcmV0dXJuOworCisJY2FzZSBOQU5EX0NNRF9HRVRGRUFUVVJFUzoKKwkJYnJlYWs7CisK IAkJLyoKIAkJICogcmVhZCBlcnJvciBzdGF0dXMgY29tbWFuZHMgcmVxdWlyZSBvbmx5IGEg c2hvcnQgZGVsYXkKIAkJICovCkBAIC02NjgsNiArODE0LDMwIEBAIHN0YXRpYyB2b2lkIG5h bmRfY29tbWFuZF9scChzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgdW5zaWduZWQgaW50IGNvbW1h bmQsCiAJCWNoaXAtPmNtZF9jdHJsKG10ZCwgTkFORF9DTURfTk9ORSwKIAkJCSAgICAgICBO QU5EX05DRSB8IE5BTkRfQ1RSTF9DSEFOR0UpOwogCisJCS8qIElmIHVzaW5nIDQtYml0IG9u LWRpZSBFQ0MsIGNoZWNrIHN0YXR1cyBmb3IKKwkJICogY29ycmVjdGFibGUvdW5jb3JyZWN0 YWJsZSBFQ0MgZXJyb3JzLiAoZWNjLnBvc3RwYWQgaXMgdXNlZCBhcworCQkgKiBhIGZsYWcg dG8gaW5kaWNhdGUgb24tZGllIEVDQyBpcyBjdXJyZW50bHkgZW5hYmxlZCkKKwkJICovCisJ CWlmIChjaGlwLT5lY2MubW9kZSA9PSBOQU5EX0VDQ180QklUT05ESUUgJiYgY2hpcC0+ZWNj LnBvc3RwYWQpIHsKKwkJCWludCBzdGF0dXM7CisKKwkJCXN0YXR1cyA9IGNoaXAtPndhaXRm dW5jKG10ZCwgY2hpcCk7CisKKwkJCWlmIChzdGF0dXMgJiBOQU5EX1NUQVRVU19GQUlMKQor CQkJCW10ZC0+ZWNjX3N0YXRzLmZhaWxlZCsrOworCQkJZWxzZSBpZiAoc3RhdHVzICYgTkFO RF9TVEFUVVNfRUNDUkVXUklURSkKKwkJCQltdGQtPmVjY19zdGF0cy5jb3JyZWN0ZWQrKzsK KworCQkJLyogUmUtaXNzdWUgQ01EMCBhZnRlciBTVEFUVVMgQ2hlY2sgKi8KKwkJCWNoaXAt PmNtZF9jdHJsKG10ZCwgTkFORF9DTURfUkVBRDAsCisJCQkJICAgICAgIE5BTkRfTkNFIHwg TkFORF9DTEUgfCBOQU5EX0NUUkxfQ0hBTkdFKTsKKwkJCWNoaXAtPmNtZF9jdHJsKG10ZCwg TkFORF9DTURfTk9ORSwKKwkJCQkgICAgICAgTkFORF9OQ0UgfCBOQU5EX0NUUkxfQ0hBTkdF KTsKKworCQkJLyogRGV2aWNlIG5vdyByZWFkeSBmb3IgcmVhZGluZywgcmV0dXJuIGltbWVk aWF0ZWx5ICovCisJCQlyZXR1cm47CisJCX0KKwogCQkvKiBUaGlzIGFwcGxpZXMgdG8gcmVh ZCBjb21tYW5kcyAqLwogCWRlZmF1bHQ6CiAJCS8qCkBAIC0xMTcyLDYgKzEzNDIsNyBAQCBp bnQgbmFuZF9kb19yZWFkX29wcyhzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IGZyb20s CiAJdWludDMyX3QgcmVhZGxlbiA9IG9wcy0+bGVuOwogCXVpbnQzMl90IG9vYnJlYWRsZW4g PSBvcHMtPm9vYmxlbjsKIAl1aW50OF90ICpidWZwb2ksICpvb2IsICpidWY7CisJaW50IHJl ZW5hYmxlX29uZGllX2VjYyA9IDA7CiAKIAlzdGF0cyA9IG10ZC0+ZWNjX3N0YXRzOwogCkBA IC0xMTg2LDYgKzEzNTcsMTIgQEAgaW50IG5hbmRfZG9fcmVhZF9vcHMoc3RydWN0IG10ZF9p bmZvICptdGQsIGxvZmZfdCBmcm9tLAogCWJ1ZiA9IG9wcy0+ZGF0YnVmOwogCW9vYiA9IG9w cy0+b29iYnVmOwogCisJLyogRm9yICdSQVcnIHJlYWRzLCBkaXNhYmxlIG9uLWRpZSBFQ0Mg aWYgbmVjZXNzYXJ5ICovCisJaWYgKG9wcy0+bW9kZSA9PSBNVERfT09CX1JBVyAmJiBjaGlw LT5lY2MubW9kZSA9PSBOQU5EX0VDQ180QklUT05ESUUpIHsKKwkJbmFuZF9taWNyb25fNGJp dF9vbmRpZV9lY2MobXRkLCAwKTsKKwkJcmVlbmFibGVfb25kaWVfZWNjID0gMTsKKwl9CisK IAl3aGlsZSgxKSB7CiAJCWJ5dGVzID0gbWluKG10ZC0+d3JpdGVzaXplIC0gY29sLCByZWFk bGVuKTsKIAkJYWxpZ25lZCA9IChieXRlcyA9PSBtdGQtPndyaXRlc2l6ZSk7CkBAIC0xMjgy LDYgKzE0NTksMTAgQEAgaW50IG5hbmRfZG9fcmVhZF9vcHMoc3RydWN0IG10ZF9pbmZvICpt dGQsIGxvZmZfdCBmcm9tLAogCWlmIChvb2IpCiAJCW9wcy0+b29icmV0bGVuID0gb3BzLT5v b2JsZW4gLSBvb2JyZWFkbGVuOwogCisJLyogUmUtZW5hYmxlIG9uLWRpZSBFQ0MgaWYgbmVj ZXNzYXJ5ICovCisJaWYgKHJlZW5hYmxlX29uZGllX2VjYykKKwkJbmFuZF9taWNyb25fNGJp dF9vbmRpZV9lY2MobXRkLCAxKTsKKwogCWlmIChyZXQpCiAJCXJldHVybiByZXQ7CiAKQEAg LTE0ODUsNiArMTY2Niw3IEBAIGludCBuYW5kX2RvX3JlYWRfb29iKHN0cnVjdCBtdGRfaW5m byAqbXRkLCBsb2ZmX3QgZnJvbSwKIAlpbnQgcmVhZGxlbiA9IG9wcy0+b29ibGVuOwogCWlu dCBsZW47CiAJdWludDhfdCAqYnVmID0gb3BzLT5vb2JidWY7CisJaW50IHJlZW5hYmxlX29u ZGllX2VjYyA9IDA7CiAKIAlERUJVRyhNVERfREVCVUdfTEVWRUwzLCAiJXM6IGZyb20gPSAw eCUwOEx4LCBsZW4gPSAlaVxuIiwKIAkJCV9fZnVuY19fLCAodW5zaWduZWQgbG9uZyBsb25n KWZyb20sIHJlYWRsZW4pOwpAQCAtMTUxNiw2ICsxNjk4LDEyIEBAIGludCBuYW5kX2RvX3Jl YWRfb29iKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3QgZnJvbSwKIAlyZWFscGFnZSA9 IChpbnQpKGZyb20gPj4gY2hpcC0+cGFnZV9zaGlmdCk7CiAJcGFnZSA9IHJlYWxwYWdlICYg Y2hpcC0+cGFnZW1hc2s7CiAKKwkvKiBEaXNhYmxlIG9uLWRpZSBFQ0MgaWYgbmVjZXNzYXJ5 ICovCisJaWYgKGNoaXAtPmVjYy5tb2RlID09IE5BTkRfRUNDXzRCSVRPTkRJRSkgeworCQlu YW5kX21pY3Jvbl80Yml0X29uZGllX2VjYyhtdGQsIDApOworCQlyZWVuYWJsZV9vbmRpZV9l Y2MgPSAxOworCX0KKwogCXdoaWxlKDEpIHsKIAkJc25kY21kID0gY2hpcC0+ZWNjLnJlYWRf b29iKG10ZCwgY2hpcCwgcGFnZSwgc25kY21kKTsKIApAQCAtMTU1Nyw2ICsxNzQ1LDEwIEBA IGludCBuYW5kX2RvX3JlYWRfb29iKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3QgZnJv bSwKIAkJCXNuZGNtZCA9IDE7CiAJfQogCisJLyogUmUtZW5hYmxlIG9uLWRpZSBFQ0MgaWYg bmVjZXNzYXJ5ICovCisJaWYgKHJlZW5hYmxlX29uZGllX2VjYykKKwkJbmFuZF9taWNyb25f NGJpdF9vbmRpZV9lY2MobXRkLCAxKTsKKwogCW9wcy0+b29icmV0bGVuID0gb3BzLT5vb2Js ZW47CiAJcmV0dXJuIDA7CiB9CkBAIC0xODgzLDYgKzIwNzUsNyBAQCBpbnQgbmFuZF9kb193 cml0ZV9vcHMoc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCB0bywKIAl1aW50OF90ICpv b2IgPSBvcHMtPm9vYmJ1ZjsKIAl1aW50OF90ICpidWYgPSBvcHMtPmRhdGJ1ZjsKIAlpbnQg cmV0LCBzdWJwYWdlOworCWludCByZWVuYWJsZV9vbmRpZV9lY2MgPSAwOwogCiAJb3BzLT5y ZXRsZW4gPSAwOwogCWlmICghd3JpdGVsZW4pCkBAIC0xOTIxLDYgKzIxMTQsMTIgQEAgaW50 IG5hbmRfZG9fd3JpdGVfb3BzKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3QgdG8sCiAJ aWYgKGxpa2VseSghb29iKSkKIAkJbWVtc2V0KGNoaXAtPm9vYl9wb2ksIDB4ZmYsIG10ZC0+ b29ic2l6ZSk7CiAKKwkvKiBGb3IgJ1JBVycgd3JpdGVzLCBkaXNhYmxlIG9uLWRpZSBFQ0Mg aWYgbmVjZXNzYXJ5ICovCisJaWYgKG9wcy0+bW9kZSA9PSBNVERfT09CX1JBVyAmJiBjaGlw LT5lY2MubW9kZSA9PSBOQU5EX0VDQ180QklUT05ESUUpIHsKKwkJbmFuZF9taWNyb25fNGJp dF9vbmRpZV9lY2MobXRkLCAwKTsKKwkJcmVlbmFibGVfb25kaWVfZWNjID0gMTsKKwl9CisK IAl3aGlsZSgxKSB7CiAJCWludCBieXRlcyA9IG10ZC0+d3JpdGVzaXplOwogCQlpbnQgY2Fj aGVkID0gd3JpdGVsZW4gPiBieXRlcyAmJiBwYWdlICE9IGJsb2NrbWFzazsKQEAgLTE5NjEs NiArMjE2MCwxMCBAQCBpbnQgbmFuZF9kb193cml0ZV9vcHMoc3RydWN0IG10ZF9pbmZvICpt dGQsIGxvZmZfdCB0bywKIAkJfQogCX0KIAorCS8qIFJlLWVuYWJsZSBvbi1kaWUgRUNDIGlm IG5lY2Vzc2FyeSAqLworCWlmIChyZWVuYWJsZV9vbmRpZV9lY2MpCisJCW5hbmRfbWljcm9u XzRiaXRfb25kaWVfZWNjKG10ZCwgMSk7CisKIAlvcHMtPnJldGxlbiA9IG9wcy0+bGVuIC0g d3JpdGVsZW47CiAJaWYgKHVubGlrZWx5KG9vYikpCiAJCW9wcy0+b29icmV0bGVuID0gb3Bz LT5vb2JsZW47CkBAIC0yMDE4LDYgKzIyMjEsNyBAQCBpbnQgbmFuZF9kb193cml0ZV9vb2Io c3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCB0bywKIHsKIAlpbnQgY2hpcG5yLCBwYWdl LCBzdGF0dXMsIGxlbjsKIAlzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwID0gbXRkLT5wcml2Owor CWludCByZWVuYWJsZV9vbmRpZV9lY2MgPSAwOwogCiAJREVCVUcoTVREX0RFQlVHX0xFVkVM MywgIiVzOiB0byA9IDB4JTA4eCwgbGVuID0gJWlcbiIsCiAJCQkgX19mdW5jX18sICh1bnNp Z25lZCBpbnQpdG8sIChpbnQpb3BzLT5vb2JsZW4pOwpAQCAtMjA3MiwxMSArMjI3NiwyMSBA QCBpbnQgbmFuZF9kb193cml0ZV9vb2Ioc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCB0 bywKIAlpZiAocGFnZSA9PSBjaGlwLT5wYWdlYnVmKQogCQljaGlwLT5wYWdlYnVmID0gLTE7 CiAKKwkvKiBEaXNhYmxlIG9uLWRpZSBFQ0MgKi8KKwlpZiAoY2hpcC0+ZWNjLm1vZGUgPT0g TkFORF9FQ0NfNEJJVE9ORElFKSB7CisJCW5hbmRfbWljcm9uXzRiaXRfb25kaWVfZWNjKG10 ZCwgMCk7CisJCXJlZW5hYmxlX29uZGllX2VjYyA9IDE7CisJfQorCiAJbWVtc2V0KGNoaXAt Pm9vYl9wb2ksIDB4ZmYsIG10ZC0+b29ic2l6ZSk7CiAJbmFuZF9maWxsX29vYihjaGlwLCBv cHMtPm9vYmJ1Ziwgb3BzKTsKIAlzdGF0dXMgPSBjaGlwLT5lY2Mud3JpdGVfb29iKG10ZCwg Y2hpcCwgcGFnZSAmIGNoaXAtPnBhZ2VtYXNrKTsKIAltZW1zZXQoY2hpcC0+b29iX3BvaSwg MHhmZiwgbXRkLT5vb2JzaXplKTsKIAorCS8qIFJlLWVuYWJsZSBvbi1kaWUgRUNDIGlmIG5l Y2Vzc2FyeSAqLworCWlmIChyZWVuYWJsZV9vbmRpZV9lY2MpCisJCW5hbmRfbWljcm9uXzRi aXRfb25kaWVfZWNjKG10ZCwgMSk7CisKIAlpZiAoc3RhdHVzKQogCQlyZXR1cm4gc3RhdHVz OwogCkBAIC0yNTY2LDYgKzI3ODAsMTggQEAgc3RhdGljIHN0cnVjdCBuYW5kX2ZsYXNoX2Rl diAqbmFuZF9nZXRfZmxhc2hfdHlwZShzdHJ1Y3QgbXRkX2luZm8gKm10ZCwKIAkJLyogR2V0 IGJ1c3dpZHRoIGluZm9ybWF0aW9uICovCiAJCWJ1c3cgPSAoZXh0aWQgJiAweDAxKSA/IE5B TkRfQlVTV0lEVEhfMTYgOiAwOwogCisJCS8qIE1pY3JvbiBkZXZpY2U6IGNoZWNrIGZvciA0 LWJpdCBvbi1kaWUgRUNDICovCisJCWlmICgqbWFmX2lkID09IE5BTkRfTUZSX01JQ1JPTikg eworCQkJdTggaWQ0LCBpZDU7CisJCQlpZDQgPSBjaGlwLT5yZWFkX2J5dGUobXRkKTsKKwkJ CWlkNSA9IGNoaXAtPnJlYWRfYnl0ZShtdGQpOworCisJCQkvKiBEbyB3ZSBoYXZlIGEgNS1i eXRlIElEID8gKi8KKwkJCWlmICghKGlkNCA9PSAqbWFmX2lkICYmIGlkNSA9PSBkZXZfaWQp KQorCQkJCS8qIEVDQyBsZXZlbCBpbiBpZDRbMTowXSAqLworCQkJCWlmICgoaWQ0ICYgMHgz KSA9PSAweDIpCisJCQkJCWNoaXAtPmVjYy5tb2RlID0gTkFORF9FQ0NfNEJJVE9ORElFOwor CQl9CiAJfSBlbHNlIHsKIAkJLyoKIAkJICogT2xkIGRldmljZXMgaGF2ZSBjaGlwIGRhdGEg aGFyZGNvZGVkIGluIHRoZSBkZXZpY2UgaWQgdGFibGUKQEAgLTI3MzAsNyArMjk1NiwxMCBA QCBpbnQgbmFuZF9zY2FuX3RhaWwoc3RydWN0IG10ZF9pbmZvICptdGQpCiAJCQljaGlwLT5l Y2MubGF5b3V0ID0gJm5hbmRfb29iXzE2OwogCQkJYnJlYWs7CiAJCWNhc2UgNjQ6Ci0JCQlj aGlwLT5lY2MubGF5b3V0ID0gJm5hbmRfb29iXzY0OworCQkJaWYgKGNoaXAtPmVjYy5tb2Rl ID09IE5BTkRfRUNDXzRCSVRPTkRJRSkKKwkJCQljaGlwLT5lY2MubGF5b3V0ID0gJm5hbmRf b29iXzY0XzRiaXRvbmRpZTsKKwkJCWVsc2UKKwkJCQljaGlwLT5lY2MubGF5b3V0ID0gJm5h bmRfb29iXzY0OwogCQkJYnJlYWs7CiAJCWNhc2UgMTI4OgogCQkJY2hpcC0+ZWNjLmxheW91 dCA9ICZuYW5kX29vYl8xMjg7CkBAIC0yODM3LDYgKzMwNjYsMjAgQEAgaW50IG5hbmRfc2Nh bl90YWlsKHN0cnVjdCBtdGRfaW5mbyAqbXRkKQogCQljaGlwLT5lY2MuYnl0ZXMgPSAwOwog CQlicmVhazsKIAorCWNhc2UgTkFORF9FQ0NfNEJJVE9ORElFOgorCQljaGlwLT5lY2MucmVh ZF9wYWdlID0gbmFuZF9yZWFkX3BhZ2VfcmF3OworCQljaGlwLT5lY2Mud3JpdGVfcGFnZSA9 IG5hbmRfd3JpdGVfcGFnZV9yYXc7CisJCWNoaXAtPmVjYy5yZWFkX3BhZ2VfcmF3ID0gbmFu ZF9yZWFkX3BhZ2VfcmF3OworCQljaGlwLT5lY2Mud3JpdGVfcGFnZV9yYXcgPSBuYW5kX3dy aXRlX3BhZ2VfcmF3OworCQljaGlwLT5lY2MucmVhZF9vb2IgPSBuYW5kX3JlYWRfb29iX3N0 ZDsKKwkJY2hpcC0+ZWNjLndyaXRlX29vYiA9IG5hbmRfd3JpdGVfb29iX3N0ZDsKKwkJY2hp cC0+ZWNjLnNpemUgPSA1MTI7CisJCWNoaXAtPmVjYy5ieXRlcyA9IDg7CisKKwkJLyogVHVy biBvbiBvbi1kaWUgRUNDICovCisJCW5hbmRfbWljcm9uXzRiaXRfb25kaWVfZWNjKG10ZCwg MSk7CisJCWJyZWFrOworCiAJZGVmYXVsdDoKIAkJcHJpbnRrKEtFUk5fV0FSTklORyAiSW52 YWxpZCBOQU5EX0VDQ19NT0RFICVkXG4iLAogCQkgICAgICAgY2hpcC0+ZWNjLm1vZGUpOwpk aWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvbmFuZC9uYW5kX2JidC5jIGIvZHJpdmVycy9tdGQv bmFuZC9uYW5kX2JidC5jCmluZGV4IDZiMTk0MmIuLmZlZTUxMGEgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvbXRkL25hbmQvbmFuZF9iYnQuYworKysgYi9kcml2ZXJzL210ZC9uYW5kL25hbmRf YmJ0LmMKQEAgLTExNjUsNiArMTE2NSwyNyBAQCBzdGF0aWMgc3RydWN0IG5hbmRfYmJ0X2Rl c2NyIGJidF9taXJyb3JfZGVzY3IgPSB7CiAJLnBhdHRlcm4gPSBtaXJyb3JfcGF0dGVybgog fTsKIAorLyogQkJUIGRlc2NyaXB0b3JzIGZvciAoTWljcm9uKSA0LWJpdCBvbi1kaWUgRUND ICovCitzdGF0aWMgc3RydWN0IG5hbmRfYmJ0X2Rlc2NyIGJidF9tYWluX2Rlc2NyX29kZSA9 IHsKKwkub3B0aW9ucyA9IE5BTkRfQkJUX0xBU1RCTE9DSyB8IE5BTkRfQkJUX0NSRUFURSB8 IE5BTkRfQkJUX1dSSVRFCisJfCBOQU5EX0JCVF8yQklUIHwgTkFORF9CQlRfVkVSU0lPTiB8 IE5BTkRfQkJUX1BFUkNISVAsCisJLm9mZnMgPQk4ICsgOCwJCS8qIG5lZWQgdG8gc2hpZnQg YnkgOCBkdWUgdG8gb24tZGllIEVDQyAqLworCS5sZW4gPSA0LAorCS52ZXJvZmZzID0gMTIg KyA4LAkvKiBuZWVkIHRvIHNoaWZ0IGJ5IDggZHVlIHRvIG9uLWRpZSBFQ0MgKi8KKwkubWF4 YmxvY2tzID0gNCwKKwkucGF0dGVybiA9IGJidF9wYXR0ZXJuCit9OworCitzdGF0aWMgc3Ry dWN0IG5hbmRfYmJ0X2Rlc2NyIGJidF9taXJyb3JfZGVzY3Jfb2RlID0geworCS5vcHRpb25z ID0gTkFORF9CQlRfTEFTVEJMT0NLIHwgTkFORF9CQlRfQ1JFQVRFIHwgTkFORF9CQlRfV1JJ VEUKKwkJfCBOQU5EX0JCVF8yQklUIHwgTkFORF9CQlRfVkVSU0lPTiB8IE5BTkRfQkJUX1BF UkNISVAsCisJLm9mZnMgPQk4ICsgOCwJCS8qIG5lZWQgdG8gc2hpZnQgYnkgOCBkdWUgdG8g b24tZGllIEVDQyAqLworCS5sZW4gPSA0LAorCS52ZXJvZmZzID0gMTIgKyA4LAkvKiBuZWVk IHRvIHNoaWZ0IGJ5IDggZHVlIHRvIG9uLWRpZSBFQ0MgKi8KKwkubWF4YmxvY2tzID0gNCwK KwkucGF0dGVybiA9IG1pcnJvcl9wYXR0ZXJuCit9OworCiAvKioKICAqIG5hbmRfZGVmYXVs dF9iYnQgLSBbTkFORCBJbnRlcmZhY2VdIFNlbGVjdCBhIGRlZmF1bHQgYmFkIGJsb2NrIHRh YmxlIGZvciB0aGUgZGV2aWNlCiAgKiBAbXRkOglNVEQgZGV2aWNlIHN0cnVjdHVyZQpAQCAt MTE5OCw4ICsxMjE5LDEzIEBAIGludCBuYW5kX2RlZmF1bHRfYmJ0KHN0cnVjdCBtdGRfaW5m byAqbXRkKQogCWlmICh0aGlzLT5vcHRpb25zICYgTkFORF9VU0VfRkxBU0hfQkJUKSB7CiAJ CS8qIFVzZSB0aGUgZGVmYXVsdCBwYXR0ZXJuIGRlc2NyaXB0b3JzICovCiAJCWlmICghdGhp cy0+YmJ0X3RkKSB7Ci0JCQl0aGlzLT5iYnRfdGQgPSAmYmJ0X21haW5fZGVzY3I7Ci0JCQl0 aGlzLT5iYnRfbWQgPSAmYmJ0X21pcnJvcl9kZXNjcjsKKwkJCWlmICh0aGlzLT5lY2MubW9k ZSA9PSBOQU5EX0VDQ180QklUT05ESUUpIHsKKwkJCQl0aGlzLT5iYnRfdGQgPSAmYmJ0X21h aW5fZGVzY3Jfb2RlOworCQkJCXRoaXMtPmJidF9tZCA9ICZiYnRfbWlycm9yX2Rlc2NyX29k ZTsKKwkJCX0gZWxzZSB7CisJCQkJdGhpcy0+YmJ0X3RkID0gJmJidF9tYWluX2Rlc2NyOwor CQkJCXRoaXMtPmJidF9tZCA9ICZiYnRfbWlycm9yX2Rlc2NyOworCQkJfQogCQl9CiAJCWlm ICghdGhpcy0+YmFkYmxvY2tfcGF0dGVybikgewogCQkJdGhpcy0+YmFkYmxvY2tfcGF0dGVy biA9IChtdGQtPndyaXRlc2l6ZSA+IDUxMikgPyAmbGFyZ2VwYWdlX2ZsYXNoYmFzZWQgOiAm c21hbGxwYWdlX2ZsYXNoYmFzZWQ7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L210ZC9u YW5kLmggYi9pbmNsdWRlL2xpbnV4L210ZC9uYW5kLmgKaW5kZXggMDQ3MWYwMS4uNjcxNDRi NyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tdGQvbmFuZC5oCisrKyBiL2luY2x1ZGUv bGludXgvbXRkL25hbmQuaApAQCAtODAsNiArODAsOCBAQCBleHRlcm4gdm9pZCBuYW5kX3dh aXRfcmVhZHkoc3RydWN0IG10ZF9pbmZvICptdGQpOwogI2RlZmluZSBOQU5EX0NNRF9SRUFE SUQJCTB4OTAKICNkZWZpbmUgTkFORF9DTURfRVJBU0UyCQkweGQwCiAjZGVmaW5lIE5BTkRf Q01EX1JFU0VUCQkweGZmCisjZGVmaW5lIE5BTkRfQ01EX1NFVEZFQVRVUkVTICAgIDB4ZWYK KyNkZWZpbmUgTkFORF9DTURfR0VURkVBVFVSRVMgICAgMHhlZQogCiAvKiBFeHRlbmRlZCBj b21tYW5kcyBmb3IgbGFyZ2UgcGFnZSBkZXZpY2VzICovCiAjZGVmaW5lIE5BTkRfQ01EX1JF QURTVEFSVAkweDMwCkBAIC0xMDcsMTIgKzEwOSwxNiBAQCBleHRlcm4gdm9pZCBuYW5kX3dh aXRfcmVhZHkoc3RydWN0IG10ZF9pbmZvICptdGQpOwogCiAjZGVmaW5lIE5BTkRfQ01EX05P TkUJCS0xCiAKKy8qIEZlYXR1cmUgQWRkcmVzc2VzIChmb3IgdGhlICJTRVQvR0VUIEZFQVRV UkVTIiBjb21tYW5kcykgKi8KKyNkZWZpbmUgTkFORF9GRUFUVVJFX01JQ1JPTl9BUlJBWV9P UF9NT0RFCTB4OTAKKwogLyogU3RhdHVzIGJpdHMgKi8KICNkZWZpbmUgTkFORF9TVEFUVVNf RkFJTAkweDAxCiAjZGVmaW5lIE5BTkRfU1RBVFVTX0ZBSUxfTjEJMHgwMgogI2RlZmluZSBO QU5EX1NUQVRVU19UUlVFX1JFQURZCTB4MjAKICNkZWZpbmUgTkFORF9TVEFUVVNfUkVBRFkJ MHg0MAogI2RlZmluZSBOQU5EX1NUQVRVU19XUAkJMHg4MAorI2RlZmluZSBOQU5EX1NUQVRV U19FQ0NSRVdSSVRFCTB4MDgKIAogLyoKICAqIENvbnN0YW50cyBmb3IgRUNDX01PREVTCkBA IC0xMjMsNiArMTI5LDcgQEAgdHlwZWRlZiBlbnVtIHsKIAlOQU5EX0VDQ19IVywKIAlOQU5E X0VDQ19IV19TWU5EUk9NRSwKIAlOQU5EX0VDQ19IV19PT0JfRklSU1QsCisJTkFORF9FQ0Nf NEJJVE9ORElFLAogfSBuYW5kX2VjY19tb2Rlc190OwogCiAvKgotLSAKMS43LjcKCg== --------------060906060807000605060201--