From mboxrd@z Thu Jan 1 00:00:00 1970 From: Bartlomiej Zolnierkiewicz Subject: [git pull] IDE updates part 2 Date: Fri, 2 Jan 2009 17:59:45 +0100 Message-ID: <200901021759.46260.bzolnier@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: base64 Return-path: Received: from mu-out-0910.google.com ([209.85.134.191]:53035 "EHLO mu-out-0910.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750911AbZABRAs (ORCPT ); Fri, 2 Jan 2009 12:00:48 -0500 Content-Disposition: inline Sender: linux-ide-owner@vger.kernel.org List-Id: linux-ide@vger.kernel.org To: Linus Torvalds Cc: Andrew Morton , Stephen Rothwell , linux-ide@vger.kernel.org, linux-kernel@vger.kernel.org Rmlyc3QgSURFIHVwZGF0ZXMgaW4gMjAwOSwgdGhpcyB0aW1lOgoKKiBGaXggSURFIHRvIG5vdCBw cm9jZXNzIGNvbW1hbmRzIGluIElSUS1jb250ZXh0IGFuZCB0aGFuIHN3aXRjaCB0aGUKICBzdWJz eXN0ZW0gdG8gdXNlIHBlci1kZXZpY2UgcmVxdWVzdCBxdWV1ZSBsb2NrcyBpbnN0ZWFkIG9mIChh Yil1c2luZwogIGh3Z3JvdXAgbG9ja3MgZm9yIHRoaXMgcHVycG9zZS4gIEJlc2lkZXMgYmVpbmcg b2J2aW91cyBJUlEtbGF0ZW5jeQogIGFuZCBzY2FsYWJpbGl0eSBpbXByb3ZlbWVudCB0aGlzIGRl Y3JlYXNlcyBjb21wbGV4aXR5IG9mIGNvcmUgY29kZQogIGdyZWF0bHkgKH4xMDAgTE9DIG9mIHZl cnkgdHJpY2t5IGNvZGUgZ29uZSkgYW5kIG1ha2VzIG1haW50YWluYW5jZQogIHdvcmsgbXVjaCBl YXNpZXIuCgogIFsgVGhhbmtzIHRvIEVsaWFzIE9sdG1hbm5zIGZvciBoaXMgd29yayBvbiByZXZp ZXdpbmcgdGhlc2UgY2hhbmdlcwogICAgYW5kIGNhdGNoaW5nIHNvbWUgaXNzdWVzIGVhcmx5LiBd CgoqIFNjaGVkdWxlZCByZW1vdmFsIG9mIGRlcHJlY2F0ZWQgaWRlLXNjc2kgZGV2aWNlIGRyaXZl ci4KCiAgV2UndmUgYmVlbiBkaXNjb3VyYWdpbmcgdXNpbmcgaWRlLXNjc2kgc2luY2UgZWFybHkg Mi41LnggZGF5cyBhcyB0aGUKICBkcml2ZXIgY29udGFpbnMgdW5maXhhYmxlIHByb2JsZW1zIHdp dGggZXJyb3IgaGFuZGxpbmcgYW5kIGxpZmV0aW1lcwogIG9mIElERS9TQ1NJIG9iamVjdHMuICBU aGVyZSBpcyBub3cgY29uc2Vuc3VzIGJldHdlZW4gSURFL1NDU0kgcGVvcGxlCiAgdGhhdCBib3Ro IChyZWNlbnRseSByZXdyaXR0ZW4pIG5hdGl2ZSBpZGUte2NkLGdkLHRhcGV9IGRyaXZlcnMgZnJv bQogIElERSBzaWRlIGFuZCBwcm9wZXIgQVRBLVNDU0kgZW11bGF0aW9uIChsaWJhdGEpIGZyb20g U0NTSSBzaWRlIG9mZmVyCiAgYSBiZXR0ZXIgYWx0ZXJuYXRpdmUuCgogIFRoZSBkcml2ZXIgaGFz IGJlZW4gb2ZmaWNpYWxseSBvcnBoYW5lZCBmb3IgYSB5ZWFyIGFuZCB0aGVuIHNjaGVkdWxlZAog IGZvciByZW1vdmFsIGZvciB0aGUgbGFzdCA0IG1vbnRocyBzbyB0aGlzIHNob3VsZG4ndCBjb21l IGFzIHN1cnByaXNlCiAgKEkgZGlkbid0IGdvdCBhIHNpbmdsZSB1c2VyIGNvbXBsYWludCBhYm91 dCB0aGlzIGFuZCBpZGUtc2NzaSBoYXMgZXZlbgogIGJlZW4gYnJva2VuIGJ5IHNvbWUgdW5yZWxh dGVkIGtlcm5lbCBjaGFuZ2VzIGZvciBmZXcga2VybmVsIHJlbGVhc2VzCiAgaW4gdGhlIHBhc3Qg d2l0aG91dCBhbnlib2R5IG5vdGljaW5nKS4gIAoKICAoZnJvbSBGVUpJVEEgVG9tb25vcmkgYW5k IEJvcmlzbGF2IFBldGtvdikKCiogRml4IG11bHRpcGxlIG5lc3RlZCBiaWcgc3RhY2sgdXNhZ2Ug aW4gaWRlLWZsb3BweS5jLgoKICAoZnJvbSBMaW51cyBoaW1zZWxmLCB0ZXN0aW5nL21lcmdpbmcg aGFuZGxlZCBieSBCb3Jpc2xhdikKCiogUHJlcGFyYXRpb25zIHRvIHN3aXRjaCBpZGUtY2QgZGV2 aWNlIGRyaXZlciB0byB1c2UgZ2VuZXJpYyBBVEFQSSBjb2RlCiAgd2hpY2ggd2lsbCBoYXBwZW4g aW4gdGhlIG5leHQgSURFIHVwZGF0ZXMgcHVsbCByZXF1ZXN0LgoKICAoZnJvbSBCb3Jpc2xhdikK CiogTWlzYyBmaXh1cHMvY2xlYW51cHMuCgpBbGwgYWJvdmUgY2hhbmdlcyBoYXZlIGJlZW4gaW4g bGludXgtbmV4dCBmb3Igc29tZSB0aW1lIG5vdy4uLgoKCkxpbnVzLCBwbGVhc2UgcHVsbCBmcm9t OgoKbWFzdGVyLmtlcm5lbC5vcmc6L3B1Yi9zY20vbGludXgva2VybmVsL2dpdC9iYXJ0L2lkZS0y LjYuZ2l0LwoKdG8gcmVjZWl2ZSB0aGUgZm9sbG93aW5nIHVwZGF0ZXM6CgogRG9jdW1lbnRhdGlv bi9mZWF0dXJlLXJlbW92YWwtc2NoZWR1bGUudHh0IHwgICAgOSAtCiBNQUlOVEFJTkVSUyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICA1IC0KIGRyaXZlcnMvaWRlL0tjb25maWcg ICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTggKy0KIGRyaXZlcnMvaWRlL01ha2VmaWxlICAg ICAgICAgICAgICAgICAgICAgICB8ICAgIDIgKy0KIGRyaXZlcnMvaWRlL2lkZS1hdGFwaS5jICAg ICAgICAgICAgICAgICAgICB8ICAyNDggKysrKystLS0tCiBkcml2ZXJzL2lkZS9pZGUtY2QuYyAg ICAgICAgICAgICAgICAgICAgICAgfCAgIDk5ICstLS0KIGRyaXZlcnMvaWRlL2lkZS1jZC5oICAg ICAgICAgICAgICAgICAgICAgICB8ICAgMTIgKy0KIGRyaXZlcnMvaWRlL2lkZS1mbG9wcHkuYyAg ICAgICAgICAgICAgICAgICB8ICAgMjggKy0KIGRyaXZlcnMvaWRlL2lkZS1mbG9wcHlfaW9jdGwu YyAgICAgICAgICAgICB8ICAgNTggKy0KIGRyaXZlcnMvaWRlL2lkZS1pby5jICAgICAgICAgICAg ICAgICAgICAgICB8ICAyODIgKysrLS0tLS0tLQogZHJpdmVycy9pZGUvaWRlLWlvY3Rscy5jICAg ICAgICAgICAgICAgICAgIHwgICAgMyArLQogZHJpdmVycy9pZGUvaWRlLXBhcmsuYyAgICAgICAg ICAgICAgICAgICAgIHwgICAxMyArLQogZHJpdmVycy9pZGUvaWRlLXByb2JlLmMgICAgICAgICAg ICAgICAgICAgIHwgIDIyMyArKystLS0tLQogZHJpdmVycy9pZGUvaWRlLXN5c2ZzLmMgICAgICAg ICAgICAgICAgICAgIHwgIDEyNSArKysrCiBkcml2ZXJzL2lkZS9pZGUtdGFwZS5jICAgICAgICAg ICAgICAgICAgICAgfCAgICAyICstCiBkcml2ZXJzL2lkZS9pZGUuYyAgICAgICAgICAgICAgICAg ICAgICAgICAgfCAgIDcyICstLS0KIGRyaXZlcnMvaWRlL3R4NDkzOGlkZS5jICAgICAgICAgICAg ICAgICAgICB8ICAgMTEgKy0KIGRyaXZlcnMvaWRlL3R4NDkzOWlkZS5jICAgICAgICAgICAgICAg ICAgICB8ICAgNDMgKy0KIGRyaXZlcnMvc2NzaS9LY29uZmlnICAgICAgICAgICAgICAgICAgICAg ICB8ICAgIDggKy0KIGRyaXZlcnMvc2NzaS9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgICB8 ICAgIDEgLQogZHJpdmVycy9zY3NpL2lkZS1zY3NpLmMgICAgICAgICAgICAgICAgICAgIHwgIDg0 MCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBpbmNsdWRlL2xpbnV4L2lkZS5oICAgICAg ICAgICAgICAgICAgICAgICAgfCAgMTIxICsrKy0tCiAyMiBmaWxlcyBjaGFuZ2VkLCA2MTQgaW5z ZXJ0aW9ucygrKSwgMTYwOSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJz L2lkZS9pZGUtc3lzZnMuYwogZGVsZXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvc2NzaS9pZGUtc2Nz aS5jCgoKQmFydGxvbWllaiBab2xuaWVya2lld2ljeiAoMTApOgogICAgICB0eDQ5M3g6IGZpeCBp bmRlbnRhdGlvbgogICAgICBpZGU6IHJlbW92ZSBjaGlwc2V0IHR5cGUgZml4dXAgZnJvbSBpZGVf aG9zdF9yZWdpc3RlcigpCiAgICAgIGlkZTogc21hbGwgaWRlX3JlZ2lzdGVyX3BvcnQoKSBjbGVh bnVwCiAgICAgIGlkZTogZmFjdG9yIG91dCBkZXZpY2UgdHlwZSBjbGFzc2lmeWluZyBmcm9tIGRv X2lkZW50aWZ5KCkKICAgICAgaWRlOiBtb3ZlIHN5c2ZzIHN1cHBvcnQgdG8gaWRlLXN5c2ZzLmMK ICAgICAgaWRlOiBkb24ndCBleGVjdXRlIHRoZSBuZXh0IHF1ZXVlZCBjb21tYW5kIGZyb20gdGhl IGhhcmQtSVJRIGNvbnRleHQgKHYyKQogICAgICBpZGU6IHJlbW92ZSBJREUgUE0gaGFjayBmcm9t IGRvX2lkZV9yZXF1ZXN0KCkKICAgICAgaWRlOiByZW1vdmUgInBhcmFub2lhIiBjaGVja3MgZm9y IGh3Z3JvdXAtPmJ1c3kKICAgICAgaWRlOiBhZGQgaWRlX1t1bl1sb2NrX2h3Z3JvdXAoKSBoZWxw ZXJzCiAgICAgIGlkZTogdXNlIHBlci1kZXZpY2UgcmVxdWVzdCBxdWV1ZSBsb2NrcyAodjIpCgpC b3Jpc2xhdiBQZXRrb3YgKDIwKToKICAgICAgaWRlLWNkOiBtb3ZlIGRlYnVnIGRlZmluZXMgaW50 byBoZWFkZXIKICAgICAgaWRlOiBtYWtlIElERV9BRkxBR18uLiBudW1iZXJpbmcgY29udGludW91 cyBhZ2FpbgogICAgICBpZGUtYXRhcGk6IGFkZCBhIGRldl9pc19pZGVjZC1pbmxpbmUKICAgICAg aWRlLWF0YXBpOiBjb21iaW5lIGRyaXZlLXNwZWNpZmljIGFzc2lnbm1lbnRzCiAgICAgIGlkZS1h dGFwaTogc2V0dXAgZG1hIGZvciBpZGUtY2QKICAgICAgaWRlLWF0YXBpOiBhY2NvbW9kYXRlIHRy YW5zZmVyIGxlbmd0aCBjYWxjdWxhdGlvbiBmb3IgaWRlLWNkCiAgICAgIGlkZS1hdGFwaTogdGVh Y2ggaWRlIGF0YXBpIGFib3V0IGRyaXZlLT53YWl0aW5nX2Zvcl9kbWEKICAgICAgaWRlLWNkOiBt b3ZlIGNkcm9tX3RpbWVyX2V4cGlyeSB0byBpZGUtYXRhcGkuYwogICAgICBpZGUtYXRhcGk6IHJl bW92ZSBpZGUtc2NzaSByZW1uYW50cyBmcm9tIGlkZV9pc3N1ZV9wYwogICAgICBpZGUtYXRhcGk6 IHJlbW92ZSBpZGUtc2NzaSByZW1uYW50cyBmcm9tIGlkZV90cmFuc2Zlcl9wYygpCiAgICAgIGlk ZS1hdGFwaTogcmVtb3ZlIGlkZS1zY3NpIHJlbW5hbnRzIGZyb20gaWRlX3BjX2ludHIoKQogICAg ICBpZGU6IHJlbW92ZSB0aGUgbGFzdCBpZGUtc2NzaSByZW1uYW50cwogICAgICBpZGUtYXRhcGk6 IGNvbXB1dGUgY21kX2xlbiBiYXNlZCBvbiBkZXZpY2UgdHlwZSBpbiBpZGVfdHJhbnNmZXJfcGMK ICAgICAgaWRlLWF0YXBpOiBhc3NpZ24gZXhwaXJ5IGFuZCB0aW1lb3V0IGJhc2VkIG9uIGRldmlj ZSB0eXBlCiAgICAgIGlkZS1hdGFwaTogc3BsaXQgZHJpdmUtc3BlY2lmaWMgZnVuY3Rpb25hbGl0 eSBpbiBpZGVfaXNzdWVfcGMKICAgICAgaWRlLWNkOiByZW1vdmUgeGZlcmxlbiBhcmcgdG8gY2Ry b21fc3RhcnRfcGFja2V0X2NvbW1hbmQKICAgICAgaWRlLWNkOiByZW1vdmUgaGFuZGxlciB3cmFw cGVycwogICAgICBpZGUtYXRhcGk6IHJlbW92ZSB0aW1lb3V0IGFyZyB0byBpZGVfaXNzdWVfcGMK ICAgICAgaWRlLWF0YXBpOiBwdXQgdGhlIHJlc3Qgb2Ygbm9uLWlkZS1jZCBjb2RlIGludG8gdGhl IGVsc2UtY2xhdXNlIG9mIGlkZV90cmFuc2Zlcl9wYwogICAgICBpZGUtYXRhcGk6IHN0YXJ0IGRt YSBpbiBhIGRyaXZlLXNwZWNpZmljIHdheQoKRlVKSVRBIFRvbW9ub3JpICgxKToKICAgICAgcmVt b3ZlIGlkZS1zY3NpCgpMaW51cyBUb3J2YWxkcyAoMSk6CiAgICAgIGlkZS1mbG9wcHk6IGFsbG9j YXRlIG9ubHkgdG9wbGV2ZWwgcGFja2V0IGNvbW1hbmRzCgoKZGlmZiAtLWdpdCBhL0RvY3VtZW50 YXRpb24vZmVhdHVyZS1yZW1vdmFsLXNjaGVkdWxlLnR4dCBiL0RvY3VtZW50YXRpb24vZmVhdHVy ZS1yZW1vdmFsLXNjaGVkdWxlLnR4dAppbmRleCBkYzdjNjgxLi5kZjE4ZDg3IDEwMDY0NAotLS0g YS9Eb2N1bWVudGF0aW9uL2ZlYXR1cmUtcmVtb3ZhbC1zY2hlZHVsZS50eHQKKysrIGIvRG9jdW1l bnRhdGlvbi9mZWF0dXJlLXJlbW92YWwtc2NoZWR1bGUudHh0CkBAIC0zMTAsMTUgKzMxMCw2IEBA IFdobzogIEtyenlzenRvZiBQaW90ciBPbGVkemtpIDxvbGVAYW5zLnBsPgogCiAtLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0KIAotV2hhdDogaWRlLXNjc2kgKEJMS19ERVZfSURFU0NTSSkKLVdo ZW46IDIuNi4yOQotV2h5OiAgVGhlIDIuNiBrZXJuZWwgc3VwcG9ydHMgZGlyZWN0IHdyaXRpbmcg dG8gaWRlIENEIGRyaXZlcywgd2hpY2gKLSAgICAgIGVsaW1pbmF0ZXMgdGhlIG5lZWQgZm9yIGlk ZS1zY3NpLiBUaGUgbmV3IG1ldGhvZCBpcyBtb3JlCi0gICAgICBlZmZpY2llbnQgaW4gZXZlcnkg d2F5LgotV2hvOiAgRlVKSVRBIFRvbW9ub3JpIDxmdWppdGEudG9tb25vcmlAbGFiLm50dC5jby5q cD4KLQotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0KIFdoYXQ6CWkyY19hdHRhY2hfY2xp ZW50KCksIGkyY19kZXRhY2hfY2xpZW50KCksIGkyY19kcml2ZXItPmRldGFjaF9jbGllbnQoKQog V2hlbjoJMi42LjI5IChpZGVhbGx5KSBvciAyLjYuMzAgKG1vcmUgbGlrZWx5KQogV2h5OglEZXBy ZWNhdGVkIGJ5IHRoZSBuZXcgKHN0YW5kYXJkKSBkZXZpY2UgZHJpdmVyIGJpbmRpbmcgbW9kZWwu IFVzZQpkaWZmIC0tZ2l0IGEvTUFJTlRBSU5FUlMgYi9NQUlOVEFJTkVSUwppbmRleCBjZWIzMmVl Li4xNDQ3NjZjIDEwMDY0NAotLS0gYS9NQUlOVEFJTkVSUworKysgYi9NQUlOVEFJTkVSUwpAQCAt MjE0NiwxMSArMjE0Niw2IEBAIE06CUdhZGkgT3htYW4gPGdhZGlvQG5ldHZpc2lvbi5uZXQuaWw+ CiBMOglsaW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3JnCiBTOglNYWludGFpbmVkCiAKLUlERS1T Q1NJIERSSVZFUgotTDoJbGludXgtaWRlQHZnZXIua2VybmVsLm9yZwotTDoJbGludXgtc2NzaUB2 Z2VyLmtlcm5lbC5vcmcKLVM6CU9ycGhhbgotCiBJRExFLUk3MzAwCiBQOglBbmR5IEhlbnJvaWQK IE06CWFuZHJldy5kLmhlbnJvaWRAaW50ZWwuY29tCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lkZS9L Y29uZmlnIGIvZHJpdmVycy9pZGUvS2NvbmZpZwppbmRleCBjOWYyMWUzLi40ZWU4NWZjIDEwMDY0 NAotLS0gYS9kcml2ZXJzL2lkZS9LY29uZmlnCisrKyBiL2RyaXZlcnMvaWRlL0tjb25maWcKQEAg LTEzNyw2ICsxMzcsNyBAQCBjb25maWcgQkxLX0RFVl9ERUxLSU4KIAogY29uZmlnIEJMS19ERVZf SURFQ0QKIAl0cmlzdGF0ZSAiSW5jbHVkZSBJREUvQVRBUEkgQ0RST00gc3VwcG9ydCIKKwlzZWxl Y3QgSURFX0FUQVBJCiAJLS0taGVscC0tLQogCSAgSWYgeW91IGhhdmUgYSBDRC1ST00gZHJpdmUg dXNpbmcgdGhlIEFUQVBJIHByb3RvY29sLCBzYXkgWS4gQVRBUEkgaXMKIAkgIGEgbmV3ZXIgcHJv dG9jb2wgdXNlZCBieSBJREUgQ0QtUk9NIGFuZCBUQVBFIGRyaXZlcywgc2ltaWxhciB0byB0aGUK QEAgLTE4NSwyMyArMTg2LDYgQEAgY29uZmlnIEJMS19ERVZfSURFVEFQRQogCSAgVG8gY29tcGls ZSB0aGlzIGRyaXZlciBhcyBhIG1vZHVsZSwgY2hvb3NlIE0gaGVyZTogdGhlCiAJICBtb2R1bGUg d2lsbCBiZSBjYWxsZWQgaWRlLXRhcGUuCiAKLWNvbmZpZyBCTEtfREVWX0lERVNDU0kKLQl0cmlz dGF0ZSAiU0NTSSBlbXVsYXRpb24gc3VwcG9ydCAoREVQUkVDQVRFRCkiCi0JZGVwZW5kcyBvbiBT Q1NJCi0Jc2VsZWN0IElERV9BVEFQSQotCS0tLWhlbHAtLS0KLQkgIFdBUk5JTkc6IGlkZS1zY3Np IGlzIG5vIGxvbmdlciBuZWVkZWQgZm9yIGNkIHdyaXRpbmcgYXBwbGljYXRpb25zIQotCSAgVGhl IDIuNiBrZXJuZWwgc3VwcG9ydHMgZGlyZWN0IHdyaXRpbmcgdG8gaWRlLWNkLCB3aGljaCBlbGlt aW5hdGVzCi0JICB0aGUgbmVlZCBmb3IgaWRlLXNjc2kgKyB0aGUgZW50aXJlIHNjc2kgc3RhY2sg anVzdCBmb3Igd3JpdGluZyBhCi0JICBjZC4gVGhlIG5ldyBtZXRob2QgaXMgbW9yZSBlZmZpY2ll bnQgaW4gZXZlcnkgd2F5LgotCi0JICBUaGlzIHdpbGwgcHJvdmlkZSBTQ1NJIGhvc3QgYWRhcHRl ciBlbXVsYXRpb24gZm9yIElERSBBVEFQSSBkZXZpY2VzLAotCSAgYW5kIHdpbGwgYWxsb3cgeW91 IHRvIHVzZSBhIFNDU0kgZGV2aWNlIGRyaXZlciBpbnN0ZWFkIG9mIGEgbmF0aXZlCi0JICBBVEFQ SSBkcml2ZXIuCi0KLQkgIElmIGJvdGggdGhpcyBTQ1NJIGVtdWxhdGlvbiBhbmQgbmF0aXZlIEFU QVBJIHN1cHBvcnQgYXJlIGNvbXBpbGVkCi0JICBpbnRvIHRoZSBrZXJuZWwsIHRoZSBuYXRpdmUg c3VwcG9ydCB3aWxsIGJlIHVzZWQuCi0KIGNvbmZpZyBCTEtfREVWX0lERUFDUEkKIAlib29sICJJ REUgQUNQSSBzdXBwb3J0IgogCWRlcGVuZHMgb24gQUNQSQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9p ZGUvTWFrZWZpbGUgYi9kcml2ZXJzL2lkZS9NYWtlZmlsZQppbmRleCAxNzdlM2Y4Li40MTA3Mjg5 IDEwMDY0NAotLS0gYS9kcml2ZXJzL2lkZS9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2lkZS9NYWtl ZmlsZQpAQCAtNSw3ICs1LDcgQEAKIEVYVFJBX0NGTEFHUwkJCQkrPSAtSWRyaXZlcnMvaWRlCiAK IGlkZS1jb3JlLXkgKz0gaWRlLm8gaWRlLWlvY3Rscy5vIGlkZS1pby5vIGlkZS1pb3BzLm8gaWRl LWxpYi5vIGlkZS1wcm9iZS5vIFwKLQkgICAgICBpZGUtdGFza2ZpbGUubyBpZGUtcG0ubyBpZGUt cGFyay5vIGlkZS1waW8tYmxhY2tsaXN0Lm8KKwkgICAgICBpZGUtdGFza2ZpbGUubyBpZGUtcG0u byBpZGUtcGFyay5vIGlkZS1waW8tYmxhY2tsaXN0Lm8gaWRlLXN5c2ZzLm8KIAogIyBjb3JlIElE RSBjb2RlCiBpZGUtY29yZS0kKENPTkZJR19JREVfVElNSU5HUykJCSs9IGlkZS10aW1pbmdzLm8K ZGlmZiAtLWdpdCBhL2RyaXZlcnMvaWRlL2lkZS1hdGFwaS5jIGIvZHJpdmVycy9pZGUvaWRlLWF0 YXBpLmMKaW5kZXggNGU1OGI5ZS4uZTg2ODhjMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pZGUvaWRl LWF0YXBpLmMKKysrIGIvZHJpdmVycy9pZGUvaWRlLWF0YXBpLmMKQEAgLTMsNiArMyw3IEBACiAg Ki8KIAogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2Nkcm9tLmg+ CiAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KICNpbmNsdWRlIDxsaW51eC9pZGUuaD4KICNpbmNs dWRlIDxzY3NpL3Njc2kuaD4KQEAgLTE0LDYgKzE1LDEzIEBACiAjZGVmaW5lIGRlYnVnX2xvZyhm bXQsIGFyZ3MuLi4pIGRvIHt9IHdoaWxlICgwKQogI2VuZGlmCiAKKyNkZWZpbmUgQVRBUElfTUlO X0NEQl9CWVRFUwkxMgorCitzdGF0aWMgaW5saW5lIGludCBkZXZfaXNfaWRlY2QoaWRlX2RyaXZl X3QgKmRyaXZlKQoreworCXJldHVybiBkcml2ZS0+bWVkaWEgPT0gaWRlX2Nkcm9tIHx8IGRyaXZl LT5tZWRpYSA9PSBpZGVfb3B0aWNhbDsKK30KKwogLyoKICAqIENoZWNrIHdoZXRoZXIgd2UgY2Fu IHN1cHBvcnQgYSBkZXZpY2UsCiAgKiBiYXNlZCBvbiB0aGUgQVRBUEkgSURFTlRJRlkgY29tbWFu ZCByZXN1bHRzLgpAQCAtMjMzLDE4ICsyNDEsNDkgQEAgdm9pZCBpZGVfcmV0cnlfcGMoaWRlX2Ry aXZlX3QgKmRyaXZlLCBzdHJ1Y3QgZ2VuZGlzayAqZGlzaykKIH0KIEVYUE9SVF9TWU1CT0xfR1BM KGlkZV9yZXRyeV9wYyk7CiAKLWludCBpZGVfc2NzaV9leHBpcnkoaWRlX2RyaXZlX3QgKmRyaXZl KQoraW50IGlkZV9jZF9leHBpcnkoaWRlX2RyaXZlX3QgKmRyaXZlKQogewotCXN0cnVjdCBpZGVf YXRhcGlfcGMgKnBjID0gZHJpdmUtPnBjOworCXN0cnVjdCByZXF1ZXN0ICpycSA9IEhXR1JPVVAo ZHJpdmUpLT5ycTsKKwl1bnNpZ25lZCBsb25nIHdhaXQgPSAwOwogCi0JZGVidWdfbG9nKCIlcyBj YWxsZWQgZm9yICVsdSBhdCAlbHVcbiIsIF9fZnVuY19fLAotCQkgIHBjLT5zY3NpX2NtZC0+c2Vy aWFsX251bWJlciwgamlmZmllcyk7CisJZGVidWdfbG9nKCIlczogcnEtPmNtZFswXTogMHgleFxu IiwgX19mdW5jX18sIHJxLT5jbWRbMF0pOwogCi0JcGMtPmZsYWdzIHw9IFBDX0ZMQUdfVElNRURP VVQ7CisJLyoKKwkgKiBTb21lIGNvbW1hbmRzIGFyZSAqc2xvdyogYW5kIG5vcm1hbGx5IHRha2Ug YSBsb25nIHRpbWUgdG8gY29tcGxldGUuCisJICogVXN1YWxseSB3ZSBjYW4gdXNlIHRoZSBBVEFQ SSAiZGlzY29ubmVjdCIgdG8gYnlwYXNzIHRoaXMsIGJ1dCBub3QgYWxsCisJICogY29tbWFuZHMv ZHJpdmVzIHN1cHBvcnQgdGhhdC4gTGV0IGlkZV90aW1lcl9leHBpcnkga2VlcCBwb2xsaW5nIHVz CisJICogZm9yIHRoZXNlLgorCSAqLworCXN3aXRjaCAocnEtPmNtZFswXSkgeworCWNhc2UgR1BD TURfQkxBTks6CisJY2FzZSBHUENNRF9GT1JNQVRfVU5JVDoKKwljYXNlIEdQQ01EX1JFU0VSVkVf UlpPTkVfVFJBQ0s6CisJY2FzZSBHUENNRF9DTE9TRV9UUkFDSzoKKwljYXNlIEdQQ01EX0ZMVVNI X0NBQ0hFOgorCQl3YWl0ID0gQVRBUElfV0FJVF9QQzsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJ aWYgKCEocnEtPmNtZF9mbGFncyAmIFJFUV9RVUlFVCkpCisJCQlwcmludGsoS0VSTl9JTkZPICJj bWQgMHgleCB0aW1lZCBvdXRcbiIsCisJCQkJCSBycS0+Y21kWzBdKTsKKwkJd2FpdCA9IDA7CisJ CWJyZWFrOworCX0KKwlyZXR1cm4gd2FpdDsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKGlkZV9jZF9l eHBpcnkpOwogCi0JcmV0dXJuIDA7IC8qIHdlIGRvIG5vdCB3YW50IHRoZSBJREUgc3Vic3lzdGVt IHRvIHJldHJ5ICovCitpbnQgaWRlX2NkX2dldF94ZmVybGVuKHN0cnVjdCByZXF1ZXN0ICpycSkK K3sKKwlpZiAoYmxrX2ZzX3JlcXVlc3QocnEpKQorCQlyZXR1cm4gMzI3Njg7CisJZWxzZSBpZiAo YmxrX3NlbnNlX3JlcXVlc3QocnEpIHx8IGJsa19wY19yZXF1ZXN0KHJxKSB8fAorCQkJIHJxLT5j bWRfdHlwZSA9PSBSRVFfVFlQRV9BVEFfUEMpCisJCXJldHVybiBycS0+ZGF0YV9sZW47CisJZWxz ZQorCQlyZXR1cm4gMDsKIH0KLUVYUE9SVF9TWU1CT0xfR1BMKGlkZV9zY3NpX2V4cGlyeSk7CitF WFBPUlRfU1lNQk9MX0dQTChpZGVfY2RfZ2V0X3hmZXJsZW4pOwogCiAvKgogICogVGhpcyBpcyB0 aGUgdXN1YWwgaW50ZXJydXB0IGhhbmRsZXIgd2hpY2ggd2lsbCBiZSBjYWxsZWQgZHVyaW5nIGEg cGFja2V0CkBAIC0yNTgsMjEgKzI5NywxNCBAQCBzdGF0aWMgaWRlX3N0YXJ0c3RvcF90IGlkZV9w Y19pbnRyKGlkZV9kcml2ZV90ICpkcml2ZSkKIAlzdHJ1Y3QgcmVxdWVzdCAqcnEgPSBod2lmLT5o d2dyb3VwLT5ycTsKIAljb25zdCBzdHJ1Y3QgaWRlX3RwX29wcyAqdHBfb3BzID0gaHdpZi0+dHBf b3BzOwogCXhmZXJfZnVuY190ICp4ZmVyZnVuYzsKLQlpZGVfZXhwaXJ5X3QgKmV4cGlyeTsKIAl1 bnNpZ25lZCBpbnQgdGltZW91dCwgdGVtcDsKIAl1MTYgYmNvdW50OwotCXU4IHN0YXQsIGlyZWFz b24sIHNjc2kgPSAhIShkcml2ZS0+ZGV2X2ZsYWdzICYgSURFX0RGTEFHX1NDU0kpLCBkc2MgPSAw OworCXU4IHN0YXQsIGlyZWFzb24sIGRzYyA9IDA7CiAKIAlkZWJ1Z19sb2coIkVudGVyICVzIC0g aW50ZXJydXB0IGhhbmRsZXJcbiIsIF9fZnVuY19fKTsKIAotCWlmIChzY3NpKSB7Ci0JCXRpbWVv dXQgPSBpZGVfc2NzaV9nZXRfdGltZW91dChwYyk7Ci0JCWV4cGlyeSA9IGlkZV9zY3NpX2V4cGly eTsKLQl9IGVsc2UgewotCQl0aW1lb3V0ID0gKGRyaXZlLT5tZWRpYSA9PSBpZGVfZmxvcHB5KSA/ IFdBSVRfRkxPUFBZX0NNRAotCQkJCQkJICAgICAgIDogV0FJVF9UQVBFX0NNRDsKLQkJZXhwaXJ5 ID0gTlVMTDsKLQl9CisJdGltZW91dCA9IChkcml2ZS0+bWVkaWEgPT0gaWRlX2Zsb3BweSkgPyBX QUlUX0ZMT1BQWV9DTUQKKwkJCQkJICAgICAgIDogV0FJVF9UQVBFX0NNRDsKIAogCWlmIChwYy0+ ZmxhZ3MgJiBQQ19GTEFHX1RJTUVET1VUKSB7CiAJCWRyaXZlLT5wY19jYWxsYmFjayhkcml2ZSwg MCk7CkBAIC0yODQsOCArMzE2LDggQEAgc3RhdGljIGlkZV9zdGFydHN0b3BfdCBpZGVfcGNfaW50 cihpZGVfZHJpdmVfdCAqZHJpdmUpCiAKIAlpZiAocGMtPmZsYWdzICYgUENfRkxBR19ETUFfSU5f UFJPR1JFU1MpIHsKIAkJaWYgKGh3aWYtPmRtYV9vcHMtPmRtYV9lbmQoZHJpdmUpIHx8Ci0JCSAg ICAoZHJpdmUtPm1lZGlhID09IGlkZV90YXBlICYmICFzY3NpICYmIChzdGF0ICYgQVRBX0VSUikp KSB7Ci0JCQlpZiAoZHJpdmUtPm1lZGlhID09IGlkZV9mbG9wcHkgJiYgIXNjc2kpCisJCSAgICAo ZHJpdmUtPm1lZGlhID09IGlkZV90YXBlICYmIChzdGF0ICYgQVRBX0VSUikpKSB7CisJCQlpZiAo ZHJpdmUtPm1lZGlhID09IGlkZV9mbG9wcHkpCiAJCQkJcHJpbnRrKEtFUk5fRVJSICIlczogRE1B ICVzIGVycm9yXG4iLAogCQkJCQlkcml2ZS0+bmFtZSwgcnFfZGF0YV9kaXIocGMtPnJxKQogCQkJ CQkJICAgICA/ICJ3cml0ZSIgOiAicmVhZCIpOwpAQCAtMzA3LDcgKzMzOSw3IEBAIHN0YXRpYyBp ZGVfc3RhcnRzdG9wX3QgaWRlX3BjX2ludHIoaWRlX2RyaXZlX3QgKmRyaXZlKQogCiAJCWxvY2Fs X2lycV9lbmFibGVfaW5faGFyZGlycSgpOwogCi0JCWlmIChkcml2ZS0+bWVkaWEgPT0gaWRlX3Rh cGUgJiYgIXNjc2kgJiYKKwkJaWYgKGRyaXZlLT5tZWRpYSA9PSBpZGVfdGFwZSAmJgogCQkgICAg KHN0YXQgJiBBVEFfRVJSKSAmJiBycS0+Y21kWzBdID09IFJFUVVFU1RfU0VOU0UpCiAJCQlzdGF0 ICY9IH5BVEFfRVJSOwogCkBAIC0zMTUsMTEgKzM0Nyw4IEBAIHN0YXRpYyBpZGVfc3RhcnRzdG9w X3QgaWRlX3BjX2ludHIoaWRlX2RyaXZlX3QgKmRyaXZlKQogCQkJLyogRXJyb3IgZGV0ZWN0ZWQg Ki8KIAkJCWRlYnVnX2xvZygiJXM6IEkvTyBlcnJvclxuIiwgZHJpdmUtPm5hbWUpOwogCi0JCQlp ZiAoZHJpdmUtPm1lZGlhICE9IGlkZV90YXBlIHx8IHNjc2kpIHsKKwkJCWlmIChkcml2ZS0+bWVk aWEgIT0gaWRlX3RhcGUpCiAJCQkJcGMtPnJxLT5lcnJvcnMrKzsKLQkJCQlpZiAoc2NzaSkKLQkJ CQkJZ290byBjbWRfZmluaXNoZWQ7Ci0JCQl9CiAKIAkJCWlmIChycS0+Y21kWzBdID09IFJFUVVF U1RfU0VOU0UpIHsKIAkJCQlwcmludGsoS0VSTl9FUlIgIiVzOiBJL08gZXJyb3IgaW4gcmVxdWVz dCBzZW5zZSIKQEAgLTMzNSw3ICszNjQsNiBAQCBzdGF0aWMgaWRlX3N0YXJ0c3RvcF90IGlkZV9w Y19pbnRyKGlkZV9kcml2ZV90ICpkcml2ZSkKIAkJCS8qIHF1ZXVlZCwgYnV0IG5vdCBzdGFydGVk ICovCiAJCQlyZXR1cm4gaWRlX3N0b3BwZWQ7CiAJCX0KLWNtZF9maW5pc2hlZDoKIAkJcGMtPmVy cm9yID0gMDsKIAogCQlpZiAoKHBjLT5mbGFncyAmIFBDX0ZMQUdfV0FJVF9GT1JfRFNDKSAmJiAo c3RhdCAmIEFUQV9EU0MpID09IDApCkBAIC0zODIsMjUgKzQxMCw4IEBAIGNtZF9maW5pc2hlZDoK IAkJCQkJCSJ1cyBtb3JlIGRhdGEgdGhhbiBleHBlY3RlZCAtICIKIAkJCQkJCSJkaXNjYXJkaW5n IGRhdGFcbiIsCiAJCQkJCQlkcml2ZS0+bmFtZSk7Ci0JCQkJaWYgKHNjc2kpCi0JCQkJCXRlbXAg PSBwYy0+YnVmX3NpemUgLSBwYy0+eGZlcnJlZDsKLQkJCQllbHNlCi0JCQkJCXRlbXAgPSAwOwot CQkJCWlmICh0ZW1wKSB7Ci0JCQkJCWlmIChwYy0+c2cpCi0JCQkJCQlkcml2ZS0+cGNfaW9fYnVm ZmVycyhkcml2ZSwgcGMsCi0JCQkJCQkJCSAgICAgdGVtcCwgMCk7Ci0JCQkJCWVsc2UKLQkJCQkJ CXRwX29wcy0+aW5wdXRfZGF0YShkcml2ZSwgTlVMTCwKLQkJCQkJCQlwYy0+Y3VyX3BvcywgdGVt cCk7Ci0JCQkJCXByaW50ayhLRVJOX0VSUiAiJXM6IHRyYW5zZmVycmVkICVkIG9mICIKLQkJCQkJ CQkiJWQgYnl0ZXNcbiIsCi0JCQkJCQkJZHJpdmUtPm5hbWUsCi0JCQkJCQkJdGVtcCwgYmNvdW50 KTsKLQkJCQl9Ci0JCQkJcGMtPnhmZXJyZWQgKz0gdGVtcDsKLQkJCQlwYy0+Y3VyX3BvcyArPSB0 ZW1wOwotCQkJCWlkZV9wYWRfdHJhbnNmZXIoZHJpdmUsIDAsIGJjb3VudCAtIHRlbXApOworCisJ CQkJaWRlX3BhZF90cmFuc2Zlcihkcml2ZSwgMCwgYmNvdW50KTsKIAkJCQlnb3RvIG5leHRfaXJx OwogCQkJfQogCQkJZGVidWdfbG9nKCJUaGUgZGV2aWNlIHdhbnRzIHRvIHNlbmQgdXMgbW9yZSBk YXRhIHRoYW4gIgpAQCAtNDEwLDE0ICs0MjEsMTMgQEAgY21kX2ZpbmlzaGVkOgogCX0gZWxzZQog CQl4ZmVyZnVuYyA9IHRwX29wcy0+b3V0cHV0X2RhdGE7CiAKLQlpZiAoKGRyaXZlLT5tZWRpYSA9 PSBpZGVfZmxvcHB5ICYmICFzY3NpICYmICFwYy0+YnVmKSB8fAotCSAgICAoZHJpdmUtPm1lZGlh ID09IGlkZV90YXBlICYmICFzY3NpICYmIHBjLT5iaCkgfHwKLQkgICAgKHNjc2kgJiYgcGMtPnNn KSkgeworCWlmICgoZHJpdmUtPm1lZGlhID09IGlkZV9mbG9wcHkgJiYgIXBjLT5idWYpIHx8CisJ ICAgIChkcml2ZS0+bWVkaWEgPT0gaWRlX3RhcGUgJiYgcGMtPmJoKSkgewogCQlpbnQgZG9uZSA9 IGRyaXZlLT5wY19pb19idWZmZXJzKGRyaXZlLCBwYywgYmNvdW50LAogCQkJCSAgISEocGMtPmZs YWdzICYgUENfRkxBR19XUklUSU5HKSk7CiAKIAkJLyogRklYTUU6IGRvbid0IGRvIHBhcnRpYWwg Y29tcGxldGlvbnMgKi8KLQkJaWYgKGRyaXZlLT5tZWRpYSA9PSBpZGVfZmxvcHB5ICYmICFzY3Np KQorCQlpZiAoZHJpdmUtPm1lZGlhID09IGlkZV9mbG9wcHkpCiAJCQlpZGVfZW5kX3JlcXVlc3Qo ZHJpdmUsIDEsIGRvbmUgPj4gOSk7CiAJfSBlbHNlCiAJCXhmZXJmdW5jKGRyaXZlLCBOVUxMLCBw Yy0+Y3VyX3BvcywgYmNvdW50KTsKQEAgLTQzMCw3ICs0NDAsNyBAQCBjbWRfZmluaXNoZWQ6CiAJ CSAgcnEtPmNtZFswXSwgYmNvdW50KTsKIG5leHRfaXJxOgogCS8qIEFuZCBzZXQgdGhlIGludGVy cnVwdCBoYW5kbGVyIGFnYWluICovCi0JaWRlX3NldF9oYW5kbGVyKGRyaXZlLCBpZGVfcGNfaW50 ciwgdGltZW91dCwgZXhwaXJ5KTsKKwlpZGVfc2V0X2hhbmRsZXIoZHJpdmUsIGlkZV9wY19pbnRy LCB0aW1lb3V0LCBOVUxMKTsKIAlyZXR1cm4gaWRlX3N0YXJ0ZWQ7CiB9CiAKQEAgLTQ3OSwxMSAr NDg5LDEyIEBAIHN0YXRpYyBpbnQgaWRlX2RlbGF5ZWRfdHJhbnNmZXJfcGMoaWRlX2RyaXZlX3Qg KmRyaXZlKQogCiBzdGF0aWMgaWRlX3N0YXJ0c3RvcF90IGlkZV90cmFuc2Zlcl9wYyhpZGVfZHJp dmVfdCAqZHJpdmUpCiB7Ci0Jc3RydWN0IGlkZV9hdGFwaV9wYyAqcGMgPSBkcml2ZS0+cGM7CisJ c3RydWN0IGlkZV9hdGFwaV9wYyAqdW5pbml0aWFsaXplZF92YXIocGMpOwogCWlkZV9od2lmX3Qg Kmh3aWYgPSBkcml2ZS0+aHdpZjsKIAlzdHJ1Y3QgcmVxdWVzdCAqcnEgPSBod2lmLT5od2dyb3Vw LT5ycTsKIAlpZGVfZXhwaXJ5X3QgKmV4cGlyeTsKIAl1bnNpZ25lZCBpbnQgdGltZW91dDsKKwlp bnQgY21kX2xlbjsKIAlpZGVfc3RhcnRzdG9wX3Qgc3RhcnRzdG9wOwogCXU4IGlyZWFzb247CiAK QEAgLTQ5MywxMDEgKzUwNCwxMjQgQEAgc3RhdGljIGlkZV9zdGFydHN0b3BfdCBpZGVfdHJhbnNm ZXJfcGMoaWRlX2RyaXZlX3QgKmRyaXZlKQogCQlyZXR1cm4gc3RhcnRzdG9wOwogCX0KIAotCWly ZWFzb24gPSBpZGVfcmVhZF9pcmVhc29uKGRyaXZlKTsKLQlpZiAoZHJpdmUtPm1lZGlhID09IGlk ZV90YXBlICYmCi0JICAgIChkcml2ZS0+ZGV2X2ZsYWdzICYgSURFX0RGTEFHX1NDU0kpID09IDAp Ci0JCWlyZWFzb24gPSBpZGVfd2FpdF9pcmVhc29uKGRyaXZlLCBpcmVhc29uKTsKLQotCWlmICgo aXJlYXNvbiAmIEFUQVBJX0NPRCkgPT0gMCB8fCAoaXJlYXNvbiAmIEFUQVBJX0lPKSkgewotCQlw cmludGsoS0VSTl9FUlIgIiVzOiAoSU8sQ29EKSAhPSAoMCwxKSB3aGlsZSBpc3N1aW5nICIKLQkJ CQkiYSBwYWNrZXQgY29tbWFuZFxuIiwgZHJpdmUtPm5hbWUpOwotCQlyZXR1cm4gaWRlX2RvX3Jl c2V0KGRyaXZlKTsKKwlpZiAoZHJpdmUtPmF0YXBpX2ZsYWdzICYgSURFX0FGTEFHX0RSUV9JTlRF UlJVUFQpIHsKKwkJaWYgKGRyaXZlLT5kbWEpCisJCQlkcml2ZS0+d2FpdGluZ19mb3JfZG1hID0g MTsKIAl9CiAKLQkvKgotCSAqIElmIG5lY2Vzc2FyeSBzY2hlZHVsZSB0aGUgcGFja2V0IHRyYW5z ZmVyIHRvIG9jY3VyICd0aW1lb3V0JwotCSAqIG1pbGlzZWNvbmRzIGxhdGVyIGluIGlkZV9kZWxh eWVkX3RyYW5zZmVyX3BjKCkgYWZ0ZXIgdGhlIGRldmljZQotCSAqIHNheXMgaXQncyByZWFkeSBm b3IgYSBwYWNrZXQuCi0JICovCi0JaWYgKGRyaXZlLT5hdGFwaV9mbGFncyAmIElERV9BRkxBR19a SVBfRFJJVkUpIHsKLQkJdGltZW91dCA9IGRyaXZlLT5wY19kZWxheTsKLQkJZXhwaXJ5ID0gJmlk ZV9kZWxheWVkX3RyYW5zZmVyX3BjOworCWlmIChkZXZfaXNfaWRlY2QoZHJpdmUpKSB7CisJCS8q IEFUQVBJIGNvbW1hbmRzIGdldCBwYWRkZWQgb3V0IHRvIDEyIGJ5dGVzIG1pbmltdW0gKi8KKwkJ Y21kX2xlbiA9IENPTU1BTkRfU0laRShycS0+Y21kWzBdKTsKKwkJaWYgKGNtZF9sZW4gPCBBVEFQ SV9NSU5fQ0RCX0JZVEVTKQorCQkJY21kX2xlbiA9IEFUQVBJX01JTl9DREJfQllURVM7CisKKwkJ dGltZW91dCA9IHJxLT50aW1lb3V0OworCQlleHBpcnkgID0gaWRlX2NkX2V4cGlyeTsKIAl9IGVs c2UgewotCQlpZiAoZHJpdmUtPmRldl9mbGFncyAmIElERV9ERkxBR19TQ1NJKSB7Ci0JCQl0aW1l b3V0ID0gaWRlX3Njc2lfZ2V0X3RpbWVvdXQocGMpOwotCQkJZXhwaXJ5ID0gaWRlX3Njc2lfZXhw aXJ5OworCQlwYyA9IGRyaXZlLT5wYzsKKworCQljbWRfbGVuID0gQVRBUElfTUlOX0NEQl9CWVRF UzsKKworCQkvKgorCQkgKiBJZiBuZWNlc3Nhcnkgc2NoZWR1bGUgdGhlIHBhY2tldCB0cmFuc2Zl ciB0byBvY2N1ciAndGltZW91dCcKKwkJICogbWlsaXNlY29uZHMgbGF0ZXIgaW4gaWRlX2RlbGF5 ZWRfdHJhbnNmZXJfcGMoKSBhZnRlciB0aGUKKwkJICogZGV2aWNlIHNheXMgaXQncyByZWFkeSBm b3IgYSBwYWNrZXQuCisJCSAqLworCQlpZiAoZHJpdmUtPmF0YXBpX2ZsYWdzICYgSURFX0FGTEFH X1pJUF9EUklWRSkgeworCQkJdGltZW91dCA9IGRyaXZlLT5wY19kZWxheTsKKwkJCWV4cGlyeSA9 ICZpZGVfZGVsYXllZF90cmFuc2Zlcl9wYzsKIAkJfSBlbHNlIHsKIAkJCXRpbWVvdXQgPSAoZHJp dmUtPm1lZGlhID09IGlkZV9mbG9wcHkpID8gV0FJVF9GTE9QUFlfQ01ECiAJCQkJCQkJICAgICAg IDogV0FJVF9UQVBFX0NNRDsKIAkJCWV4cGlyeSA9IE5VTEw7CiAJCX0KKworCQlpcmVhc29uID0g aWRlX3JlYWRfaXJlYXNvbihkcml2ZSk7CisJCWlmIChkcml2ZS0+bWVkaWEgPT0gaWRlX3RhcGUp CisJCQlpcmVhc29uID0gaWRlX3dhaXRfaXJlYXNvbihkcml2ZSwgaXJlYXNvbik7CisKKwkJaWYg KChpcmVhc29uICYgQVRBUElfQ09EKSA9PSAwIHx8IChpcmVhc29uICYgQVRBUElfSU8pKSB7CisJ CQlwcmludGsoS0VSTl9FUlIgIiVzOiAoSU8sQ29EKSAhPSAoMCwxKSB3aGlsZSBpc3N1aW5nICIK KwkJCQkJImEgcGFja2V0IGNvbW1hbmRcbiIsIGRyaXZlLT5uYW1lKTsKKworCQkJcmV0dXJuIGlk ZV9kb19yZXNldChkcml2ZSk7CisJCX0KIAl9CiAKIAkvKiBTZXQgdGhlIGludGVycnVwdCByb3V0 aW5lICovCiAJaWRlX3NldF9oYW5kbGVyKGRyaXZlLCBpZGVfcGNfaW50ciwgdGltZW91dCwgZXhw aXJ5KTsKIAogCS8qIEJlZ2luIERNQSwgaWYgbmVjZXNzYXJ5ICovCi0JaWYgKHBjLT5mbGFncyAm IFBDX0ZMQUdfRE1BX09LKSB7Ci0JCXBjLT5mbGFncyB8PSBQQ19GTEFHX0RNQV9JTl9QUk9HUkVT UzsKLQkJaHdpZi0+ZG1hX29wcy0+ZG1hX3N0YXJ0KGRyaXZlKTsKKwlpZiAoZGV2X2lzX2lkZWNk KGRyaXZlKSkgeworCQlpZiAoZHJpdmUtPmRtYSkKKwkJCWh3aWYtPmRtYV9vcHMtPmRtYV9zdGFy dChkcml2ZSk7CisJfSBlbHNlIHsKKwkJaWYgKHBjLT5mbGFncyAmIFBDX0ZMQUdfRE1BX09LKSB7 CisJCQlwYy0+ZmxhZ3MgfD0gUENfRkxBR19ETUFfSU5fUFJPR1JFU1M7CisJCQlod2lmLT5kbWFf b3BzLT5kbWFfc3RhcnQoZHJpdmUpOworCQl9CiAJfQogCiAJLyogU2VuZCB0aGUgYWN0dWFsIHBh Y2tldCAqLwogCWlmICgoZHJpdmUtPmF0YXBpX2ZsYWdzICYgSURFX0FGTEFHX1pJUF9EUklWRSkg PT0gMCkKLQkJaHdpZi0+dHBfb3BzLT5vdXRwdXRfZGF0YShkcml2ZSwgTlVMTCwgcnEtPmNtZCwg MTIpOworCQlod2lmLT50cF9vcHMtPm91dHB1dF9kYXRhKGRyaXZlLCBOVUxMLCBycS0+Y21kLCBj bWRfbGVuKTsKIAogCXJldHVybiBpZGVfc3RhcnRlZDsKIH0KIAotaWRlX3N0YXJ0c3RvcF90IGlk ZV9pc3N1ZV9wYyhpZGVfZHJpdmVfdCAqZHJpdmUsIHVuc2lnbmVkIGludCB0aW1lb3V0LAotCQkJ ICAgICBpZGVfZXhwaXJ5X3QgKmV4cGlyeSkKK2lkZV9zdGFydHN0b3BfdCBpZGVfaXNzdWVfcGMo aWRlX2RyaXZlX3QgKmRyaXZlKQogewotCXN0cnVjdCBpZGVfYXRhcGlfcGMgKnBjID0gZHJpdmUt PnBjOworCXN0cnVjdCBpZGVfYXRhcGlfcGMgKnBjOwogCWlkZV9od2lmX3QgKmh3aWYgPSBkcml2 ZS0+aHdpZjsKKwlpZGVfZXhwaXJ5X3QgKmV4cGlyeSA9IE5VTEw7CisJdW5zaWduZWQgaW50IHRp bWVvdXQ7CiAJdTMyIHRmX2ZsYWdzOwogCXUxNiBiY291bnQ7Ci0JdTggc2NzaSA9ICEhKGRyaXZl LT5kZXZfZmxhZ3MgJiBJREVfREZMQUdfU0NTSSk7CiAKLQkvKiBXZSBoYXZlbid0IHRyYW5zZmVy cmVkIGFueSBkYXRhIHlldCAqLwotCXBjLT54ZmVycmVkID0gMDsKLQlwYy0+Y3VyX3BvcyA9IHBj LT5idWY7CisJaWYgKGRldl9pc19pZGVjZChkcml2ZSkpIHsKKwkJdGZfZmxhZ3MgPSBJREVfVEZM QUdfT1VUX05TRUNUIHwgSURFX1RGTEFHX09VVF9MQkFMOworCQliY291bnQgPSBpZGVfY2RfZ2V0 X3hmZXJsZW4oaHdpZi0+aHdncm91cC0+cnEpOworCQlleHBpcnkgPSBpZGVfY2RfZXhwaXJ5Owor CQl0aW1lb3V0ID0gQVRBUElfV0FJVF9QQzsKIAotCS8qIFJlcXVlc3QgdG8gdHJhbnNmZXIgdGhl IGVudGlyZSBidWZmZXIgYXQgb25jZSAqLwotCWlmIChkcml2ZS0+bWVkaWEgPT0gaWRlX3RhcGUg JiYgc2NzaSA9PSAwKQotCQliY291bnQgPSBwYy0+cmVxX3hmZXI7Ci0JZWxzZQotCQliY291bnQg PSBtaW4ocGMtPnJlcV94ZmVyLCA2MyAqIDEwMjQpOworCQlpZiAoZHJpdmUtPmRtYSkKKwkJCWRy aXZlLT5kbWEgPSAhaHdpZi0+ZG1hX29wcy0+ZG1hX3NldHVwKGRyaXZlKTsKKwl9IGVsc2Ugewor CQlwYyA9IGRyaXZlLT5wYzsKIAotCWlmIChwYy0+ZmxhZ3MgJiBQQ19GTEFHX0RNQV9FUlJPUikg ewotCQlwYy0+ZmxhZ3MgJj0gflBDX0ZMQUdfRE1BX0VSUk9SOwotCQlpZGVfZG1hX29mZihkcml2 ZSk7Ci0JfQorCQkvKiBXZSBoYXZlbid0IHRyYW5zZmVycmVkIGFueSBkYXRhIHlldCAqLworCQlw Yy0+eGZlcnJlZCA9IDA7CisJCXBjLT5jdXJfcG9zID0gcGMtPmJ1ZjsKIAotCWlmICgocGMtPmZs YWdzICYgUENfRkxBR19ETUFfT0spICYmCi0JICAgIChkcml2ZS0+ZGV2X2ZsYWdzICYgSURFX0RG TEFHX1VTSU5HX0RNQSkpIHsKLQkJaWYgKHNjc2kpCi0JCQlod2lmLT5zZ19tYXBwZWQgPSAxOwot CQlkcml2ZS0+ZG1hID0gIWh3aWYtPmRtYV9vcHMtPmRtYV9zZXR1cChkcml2ZSk7Ci0JCWlmIChz Y3NpKQotCQkJaHdpZi0+c2dfbWFwcGVkID0gMDsKLQl9CisJCXRmX2ZsYWdzID0gSURFX1RGTEFH X09VVF9ERVZJQ0U7CisJCWJjb3VudCA9ICgoZHJpdmUtPm1lZGlhID09IGlkZV90YXBlKSA/CisJ CQkJcGMtPnJlcV94ZmVyIDoKKwkJCQltaW4ocGMtPnJlcV94ZmVyLCA2MyAqIDEwMjQpKTsKIAot CWlmICghZHJpdmUtPmRtYSkKLQkJcGMtPmZsYWdzICY9IH5QQ19GTEFHX0RNQV9PSzsKKwkJaWYg KHBjLT5mbGFncyAmIFBDX0ZMQUdfRE1BX0VSUk9SKSB7CisJCQlwYy0+ZmxhZ3MgJj0gflBDX0ZM QUdfRE1BX0VSUk9SOworCQkJaWRlX2RtYV9vZmYoZHJpdmUpOworCQl9CiAKLQlpZiAoc2NzaSkK LQkJdGZfZmxhZ3MgPSAwOwotCWVsc2UgaWYgKGRyaXZlLT5tZWRpYSA9PSBpZGVfY2Ryb20gfHwg ZHJpdmUtPm1lZGlhID09IGlkZV9vcHRpY2FsKQotCQl0Zl9mbGFncyA9IElERV9URkxBR19PVVRf TlNFQ1QgfCBJREVfVEZMQUdfT1VUX0xCQUw7Ci0JZWxzZQotCQl0Zl9mbGFncyA9IElERV9URkxB R19PVVRfREVWSUNFOworCQlpZiAoKHBjLT5mbGFncyAmIFBDX0ZMQUdfRE1BX09LKSAmJgorCQkg ICAgIChkcml2ZS0+ZGV2X2ZsYWdzICYgSURFX0RGTEFHX1VTSU5HX0RNQSkpCisJCQlkcml2ZS0+ ZG1hID0gIWh3aWYtPmRtYV9vcHMtPmRtYV9zZXR1cChkcml2ZSk7CisKKwkJaWYgKCFkcml2ZS0+ ZG1hKQorCQkJcGMtPmZsYWdzICY9IH5QQ19GTEFHX0RNQV9PSzsKKworCQl0aW1lb3V0ID0gKGRy aXZlLT5tZWRpYSA9PSBpZGVfZmxvcHB5KSA/IFdBSVRfRkxPUFBZX0NNRAorCQkJCQkJICAgICAg IDogV0FJVF9UQVBFX0NNRDsKKwl9CiAKIAlpZGVfcGt0Y21kX3RmX2xvYWQoZHJpdmUsIHRmX2Zs YWdzLCBiY291bnQsIGRyaXZlLT5kbWEpOwogCiAJLyogSXNzdWUgdGhlIHBhY2tldCBjb21tYW5k ICovCiAJaWYgKGRyaXZlLT5hdGFwaV9mbGFncyAmIElERV9BRkxBR19EUlFfSU5URVJSVVBUKSB7 CisJCWlmIChkcml2ZS0+ZG1hKQorCQkJZHJpdmUtPndhaXRpbmdfZm9yX2RtYSA9IDA7CiAJCWlk ZV9leGVjdXRlX2NvbW1hbmQoZHJpdmUsIEFUQV9DTURfUEFDS0VULCBpZGVfdHJhbnNmZXJfcGMs Ci0JCQkJICAgIHRpbWVvdXQsIE5VTEwpOworCQkJCSAgICB0aW1lb3V0LCBleHBpcnkpOwogCQly ZXR1cm4gaWRlX3N0YXJ0ZWQ7CiAJfSBlbHNlIHsKIAkJaWRlX2V4ZWN1dGVfcGt0X2NtZChkcml2 ZSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lkZS9pZGUtY2QuYyBiL2RyaXZlcnMvaWRlL2lkZS1j ZC5jCmluZGV4IDVkYWE0ZGQuLjFhNzQxMGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaWRlL2lkZS1j ZC5jCisrKyBiL2RyaXZlcnMvaWRlL2lkZS1jZC5jCkBAIC01MywxNCArNTMsNiBAQAogCiAjaW5j bHVkZSAiaWRlLWNkLmgiCiAKLSNkZWZpbmUgSURFQ0RfREVCVUdfTE9HCQkxCi0KLSNpZiBJREVD RF9ERUJVR19MT0cKLSNkZWZpbmUgaWRlX2RlYnVnX2xvZyhsdmwsIGZtdCwgYXJncy4uLikgX19p ZGVfZGVidWdfbG9nKGx2bCwgZm10LCBhcmdzKQotI2Vsc2UKLSNkZWZpbmUgaWRlX2RlYnVnX2xv ZyhsdmwsIGZtdCwgYXJncy4uLikgZG8ge30gd2hpbGUgKDApCi0jZW5kaWYKLQogc3RhdGljIERF RklORV9NVVRFWChpZGVjZF9yZWZfbXV0ZXgpOwogCiBzdGF0aWMgdm9pZCBpZGVfY2RfcmVsZWFz ZShzdHJ1Y3Qga3JlZiAqKTsKQEAgLTUxOSwzNyArNTExLDggQEAgZW5kX3JlcXVlc3Q6CiAJcmV0 dXJuIDE7CiB9CiAKLXN0YXRpYyBpbnQgY2Ryb21fdGltZXJfZXhwaXJ5KGlkZV9kcml2ZV90ICpk cml2ZSkKLXsKLQlzdHJ1Y3QgcmVxdWVzdCAqcnEgPSBIV0dST1VQKGRyaXZlKS0+cnE7Ci0JdW5z aWduZWQgbG9uZyB3YWl0ID0gMDsKLQotCWlkZV9kZWJ1Z19sb2coSURFX0RCR19SUSwgIkNhbGwg JXM6IHJxLT5jbWRbMF06IDB4JXhcbiIsIF9fZnVuY19fLAotCQkgICAgICBycS0+Y21kWzBdKTsK LQotCS8qCi0JICogU29tZSBjb21tYW5kcyBhcmUgKnNsb3cqIGFuZCBub3JtYWxseSB0YWtlIGEg bG9uZyB0aW1lIHRvIGNvbXBsZXRlLgotCSAqIFVzdWFsbHkgd2UgY2FuIHVzZSB0aGUgQVRBUEkg ImRpc2Nvbm5lY3QiIHRvIGJ5cGFzcyB0aGlzLCBidXQgbm90IGFsbAotCSAqIGNvbW1hbmRzL2Ry aXZlcyBzdXBwb3J0IHRoYXQuIExldCBpZGVfdGltZXJfZXhwaXJ5IGtlZXAgcG9sbGluZyB1cwot CSAqIGZvciB0aGVzZS4KLQkgKi8KLQlzd2l0Y2ggKHJxLT5jbWRbMF0pIHsKLQljYXNlIEdQQ01E X0JMQU5LOgotCWNhc2UgR1BDTURfRk9STUFUX1VOSVQ6Ci0JY2FzZSBHUENNRF9SRVNFUlZFX1Ja T05FX1RSQUNLOgotCWNhc2UgR1BDTURfQ0xPU0VfVFJBQ0s6Ci0JY2FzZSBHUENNRF9GTFVTSF9D QUNIRToKLQkJd2FpdCA9IEFUQVBJX1dBSVRfUEM7Ci0JCWJyZWFrOwotCWRlZmF1bHQ6Ci0JCWlm ICghKHJxLT5jbWRfZmxhZ3MgJiBSRVFfUVVJRVQpKQotCQkJcHJpbnRrKEtFUk5fSU5GTyBQRlgg ImNtZCAweCV4IHRpbWVkIG91dFxuIiwKLQkJCQkJIHJxLT5jbWRbMF0pOwotCQl3YWl0ID0gMDsK LQkJYnJlYWs7Ci0JfQotCXJldHVybiB3YWl0OwotfQorc3RhdGljIGlkZV9zdGFydHN0b3BfdCBj ZHJvbV90cmFuc2Zlcl9wYWNrZXRfY29tbWFuZChpZGVfZHJpdmVfdCAqKTsKK3N0YXRpYyBpZGVf c3RhcnRzdG9wX3QgY2Ryb21fbmV3cGNfaW50cihpZGVfZHJpdmVfdCAqKTsKIAogLyoKICAqIFNl dCB1cCB0aGUgZGV2aWNlIHJlZ2lzdGVycyBmb3IgdHJhbnNmZXJyaW5nIGEgcGFja2V0IGNvbW1h bmQgb24gREVWLApAQCAtNTU5LDExICs1MjIsMTMgQEAgc3RhdGljIGludCBjZHJvbV90aW1lcl9l eHBpcnkoaWRlX2RyaXZlX3QgKmRyaXZlKQogICogY2FsbGVkIHdoZW4gdGhlIGludGVycnVwdCBm cm9tIHRoZSBkcml2ZSBhcnJpdmVzLiAgT3RoZXJ3aXNlLCBIQU5ETEVSCiAgKiB3aWxsIGJlIGNh bGxlZCBpbW1lZGlhdGVseSBhZnRlciB0aGUgZHJpdmUgaXMgcHJlcGFyZWQgZm9yIHRoZSB0cmFu c2Zlci4KICAqLwotc3RhdGljIGlkZV9zdGFydHN0b3BfdCBjZHJvbV9zdGFydF9wYWNrZXRfY29t bWFuZChpZGVfZHJpdmVfdCAqZHJpdmUsCi0JCQkJCQkgIGludCB4ZmVybGVuLAotCQkJCQkJICBp ZGVfaGFuZGxlcl90ICpoYW5kbGVyKQorc3RhdGljIGlkZV9zdGFydHN0b3BfdCBjZHJvbV9zdGFy dF9wYWNrZXRfY29tbWFuZChpZGVfZHJpdmVfdCAqZHJpdmUpCiB7CiAJaWRlX2h3aWZfdCAqaHdp ZiA9IGRyaXZlLT5od2lmOworCXN0cnVjdCByZXF1ZXN0ICpycSA9IGh3aWYtPmh3Z3JvdXAtPnJx OworCWludCB4ZmVybGVuOworCisJeGZlcmxlbiA9IGlkZV9jZF9nZXRfeGZlcmxlbihycSk7CiAK IAlpZGVfZGVidWdfbG9nKElERV9EQkdfUEMsICJDYWxsICVzLCB4ZmVybGVuOiAlZFxuIiwgX19m dW5jX18sIHhmZXJsZW4pOwogCkBAIC01ODEsMTMgKzU0NiwxNCBAQCBzdGF0aWMgaWRlX3N0YXJ0 c3RvcF90IGNkcm9tX3N0YXJ0X3BhY2tldF9jb21tYW5kKGlkZV9kcml2ZV90ICpkcml2ZSwKIAkJ CWRyaXZlLT53YWl0aW5nX2Zvcl9kbWEgPSAwOwogCiAJCS8qIHBhY2tldCBjb21tYW5kICovCi0J CWlkZV9leGVjdXRlX2NvbW1hbmQoZHJpdmUsIEFUQV9DTURfUEFDS0VULCBoYW5kbGVyLAotCQkJ CSAgICBBVEFQSV9XQUlUX1BDLCBjZHJvbV90aW1lcl9leHBpcnkpOworCQlpZGVfZXhlY3V0ZV9j b21tYW5kKGRyaXZlLCBBVEFfQ01EX1BBQ0tFVCwKKwkJCQkgICAgY2Ryb21fdHJhbnNmZXJfcGFj a2V0X2NvbW1hbmQsCisJCQkJICAgIEFUQVBJX1dBSVRfUEMsIGlkZV9jZF9leHBpcnkpOwogCQly ZXR1cm4gaWRlX3N0YXJ0ZWQ7CiAJfSBlbHNlIHsKIAkJaWRlX2V4ZWN1dGVfcGt0X2NtZChkcml2 ZSk7CiAKLQkJcmV0dXJuICgqaGFuZGxlcikgKGRyaXZlKTsKKwkJcmV0dXJuIGNkcm9tX3RyYW5z ZmVyX3BhY2tldF9jb21tYW5kKGRyaXZlKTsKIAl9CiB9CiAKQEAgLTU5OCwxMSArNTY0LDEwIEBA IHN0YXRpYyBpZGVfc3RhcnRzdG9wX3QgY2Ryb21fc3RhcnRfcGFja2V0X2NvbW1hbmQoaWRlX2Ry aXZlX3QgKmRyaXZlLAogICogdGhlcmUncyBkYXRhIHJlYWR5LgogICovCiAjZGVmaW5lIEFUQVBJ X01JTl9DREJfQllURVMgMTIKLXN0YXRpYyBpZGVfc3RhcnRzdG9wX3QgY2Ryb21fdHJhbnNmZXJf cGFja2V0X2NvbW1hbmQoaWRlX2RyaXZlX3QgKmRyaXZlLAotCQkJCQkgIHN0cnVjdCByZXF1ZXN0 ICpycSwKLQkJCQkJICBpZGVfaGFuZGxlcl90ICpoYW5kbGVyKQorc3RhdGljIGlkZV9zdGFydHN0 b3BfdCBjZHJvbV90cmFuc2Zlcl9wYWNrZXRfY29tbWFuZChpZGVfZHJpdmVfdCAqZHJpdmUpCiB7 CiAJaWRlX2h3aWZfdCAqaHdpZiA9IGRyaXZlLT5od2lmOworCXN0cnVjdCByZXF1ZXN0ICpycSA9 IGh3aWYtPmh3Z3JvdXAtPnJxOwogCWludCBjbWRfbGVuOwogCWlkZV9zdGFydHN0b3BfdCBzdGFy dHN0b3A7CiAKQEAgLTYyOSw3ICs1OTQsNyBAQCBzdGF0aWMgaWRlX3N0YXJ0c3RvcF90IGNkcm9t X3RyYW5zZmVyX3BhY2tldF9jb21tYW5kKGlkZV9kcml2ZV90ICpkcml2ZSwKIAl9CiAKIAkvKiBh cm0gdGhlIGludGVycnVwdCBoYW5kbGVyICovCi0JaWRlX3NldF9oYW5kbGVyKGRyaXZlLCBoYW5k bGVyLCBycS0+dGltZW91dCwgY2Ryb21fdGltZXJfZXhwaXJ5KTsKKwlpZGVfc2V0X2hhbmRsZXIo ZHJpdmUsIGNkcm9tX25ld3BjX2ludHIsIHJxLT50aW1lb3V0LCBpZGVfY2RfZXhwaXJ5KTsKIAog CS8qIEFUQVBJIGNvbW1hbmRzIGdldCBwYWRkZWQgb3V0IHRvIDEyIGJ5dGVzIG1pbmltdW0gKi8K IAljbWRfbGVuID0gQ09NTUFORF9TSVpFKHJxLT5jbWRbMF0pOwpAQCAtNzE3LDggKzY4Miw2IEBA IHN0YXRpYyBpbnQgaWRlX2NkX2NoZWNrX3RyYW5zZmVyX3NpemUoaWRlX2RyaXZlX3QgKmRyaXZl LCBpbnQgbGVuKQogCXJldHVybiAxOwogfQogCi1zdGF0aWMgaWRlX3N0YXJ0c3RvcF90IGNkcm9t X25ld3BjX2ludHIoaWRlX2RyaXZlX3QgKik7Ci0KIHN0YXRpYyBpZGVfc3RhcnRzdG9wX3QgaWRl X2NkX3ByZXBhcmVfcndfcmVxdWVzdChpZGVfZHJpdmVfdCAqZHJpdmUsCiAJCQkJCQkgc3RydWN0 IHJlcXVlc3QgKnJxKQogewpAQCAtNzYxLDIwICs3MjQsNiBAQCBzdGF0aWMgaWRlX3N0YXJ0c3Rv cF90IGlkZV9jZF9wcmVwYXJlX3J3X3JlcXVlc3QoaWRlX2RyaXZlX3QgKmRyaXZlLAogfQogCiAv KgotICogUm91dGluZSB0byBzZW5kIGEgcmVhZC93cml0ZSBwYWNrZXQgY29tbWFuZCB0byB0aGUg ZHJpdmUuIFRoaXMgaXMgdXN1YWxseQotICogY2FsbGVkIGRpcmVjdGx5IGZyb20gY2Ryb21fc3Rh cnRfe3JlYWQsd3JpdGV9KCkuIEhvd2V2ZXIsIGZvciBkcnFfaW50ZXJydXB0Ci0gKiBkZXZpY2Vz LCBpdCBpcyBjYWxsZWQgZnJvbSBhbiBpbnRlcnJ1cHQgd2hlbiB0aGUgZHJpdmUgaXMgcmVhZHkg dG8gYWNjZXB0Ci0gKiB0aGUgY29tbWFuZC4KLSAqLwotc3RhdGljIGlkZV9zdGFydHN0b3BfdCBj ZHJvbV9zdGFydF9yd19jb250KGlkZV9kcml2ZV90ICpkcml2ZSkKLXsKLQlzdHJ1Y3QgcmVxdWVz dCAqcnEgPSBkcml2ZS0+aHdpZi0+aHdncm91cC0+cnE7Ci0KLQkvKiBzZW5kIHRoZSBjb21tYW5k IHRvIHRoZSBkcml2ZSBhbmQgcmV0dXJuICovCi0JcmV0dXJuIGNkcm9tX3RyYW5zZmVyX3BhY2tl dF9jb21tYW5kKGRyaXZlLCBycSwgY2Ryb21fbmV3cGNfaW50cik7Ci19Ci0KLS8qCiAgKiBGaXgg dXAgYSBwb3NzaWJseSBwYXJ0aWFsbHktcHJvY2Vzc2VkIHJlcXVlc3Qgc28gdGhhdCB3ZSBjYW4g c3RhcnQgaXQgb3ZlcgogICogZW50aXJlbHksIG9yIGV2ZW4gcHV0IGl0IGJhY2sgb24gdGhlIHJl cXVlc3QgcXVldWUuCiAgKi8KQEAgLTEwOTYsNyArMTA0NSw3IEBAIHN0YXRpYyBpZGVfc3RhcnRz dG9wX3QgY2Ryb21fbmV3cGNfaW50cihpZGVfZHJpdmVfdCAqZHJpdmUpCiAJfSBlbHNlIHsKIAkJ dGltZW91dCA9IEFUQVBJX1dBSVRfUEM7CiAJCWlmICghYmxrX2ZzX3JlcXVlc3QocnEpKQotCQkJ ZXhwaXJ5ID0gY2Ryb21fdGltZXJfZXhwaXJ5OworCQkJZXhwaXJ5ID0gaWRlX2NkX2V4cGlyeTsK IAl9CiAKIAlpZGVfc2V0X2hhbmRsZXIoZHJpdmUsIGNkcm9tX25ld3BjX2ludHIsIHRpbWVvdXQs IGV4cGlyeSk7CkBAIC0xMTYzLDEzICsxMTEyLDYgQEAgc3RhdGljIGlkZV9zdGFydHN0b3BfdCBj ZHJvbV9zdGFydF9ydyhpZGVfZHJpdmVfdCAqZHJpdmUsIHN0cnVjdCByZXF1ZXN0ICpycSkKIAly ZXR1cm4gaWRlX3N0YXJ0ZWQ7CiB9CiAKLXN0YXRpYyBpZGVfc3RhcnRzdG9wX3QgY2Ryb21fZG9f bmV3cGNfY29udChpZGVfZHJpdmVfdCAqZHJpdmUpCi17Ci0Jc3RydWN0IHJlcXVlc3QgKnJxID0g SFdHUk9VUChkcml2ZSktPnJxOwotCi0JcmV0dXJuIGNkcm9tX3RyYW5zZmVyX3BhY2tldF9jb21t YW5kKGRyaXZlLCBycSwgY2Ryb21fbmV3cGNfaW50cik7Ci19Ci0KIHN0YXRpYyB2b2lkIGNkcm9t X2RvX2Jsb2NrX3BjKGlkZV9kcml2ZV90ICpkcml2ZSwgc3RydWN0IHJlcXVlc3QgKnJxKQogewog CkBAIC0xMjE0LDE4ICsxMTU2LDEyIEBAIHN0YXRpYyB2b2lkIGNkcm9tX2RvX2Jsb2NrX3BjKGlk ZV9kcml2ZV90ICpkcml2ZSwgc3RydWN0IHJlcXVlc3QgKnJxKQogc3RhdGljIGlkZV9zdGFydHN0 b3BfdCBpZGVfY2RfZG9fcmVxdWVzdChpZGVfZHJpdmVfdCAqZHJpdmUsIHN0cnVjdCByZXF1ZXN0 ICpycSwKIAkJCQkJc2VjdG9yX3QgYmxvY2spCiB7Ci0JaWRlX2hhbmRsZXJfdCAqZm47Ci0JaW50 IHhmZXJsZW47Ci0KIAlpZGVfZGVidWdfbG9nKElERV9EQkdfUlEsICJDYWxsICVzLCBycS0+Y21k WzBdOiAweCV4LCAiCiAJCSAgICAgICJycS0+Y21kX3R5cGU6IDB4JXgsIGJsb2NrOiAlbGx1XG4i LAogCQkgICAgICBfX2Z1bmNfXywgcnEtPmNtZFswXSwgcnEtPmNtZF90eXBlLAogCQkgICAgICAo dW5zaWduZWQgbG9uZyBsb25nKWJsb2NrKTsKIAogCWlmIChibGtfZnNfcmVxdWVzdChycSkpIHsK LQkJeGZlcmxlbiA9IDMyNzY4OwotCQlmbiA9IGNkcm9tX3N0YXJ0X3J3X2NvbnQ7Ci0KIAkJaWYg KGNkcm9tX3N0YXJ0X3J3KGRyaXZlLCBycSkgPT0gaWRlX3N0b3BwZWQpCiAJCQlyZXR1cm4gaWRl X3N0b3BwZWQ7CiAKQEAgLTEyMzMsOSArMTE2OSw2IEBAIHN0YXRpYyBpZGVfc3RhcnRzdG9wX3Qg aWRlX2NkX2RvX3JlcXVlc3QoaWRlX2RyaXZlX3QgKmRyaXZlLCBzdHJ1Y3QgcmVxdWVzdCAqcnEs CiAJCQlyZXR1cm4gaWRlX3N0b3BwZWQ7CiAJfSBlbHNlIGlmIChibGtfc2Vuc2VfcmVxdWVzdChy cSkgfHwgYmxrX3BjX3JlcXVlc3QocnEpIHx8CiAJCSAgIHJxLT5jbWRfdHlwZSA9PSBSRVFfVFlQ RV9BVEFfUEMpIHsKLQkJeGZlcmxlbiA9IHJxLT5kYXRhX2xlbjsKLQkJZm4gPSBjZHJvbV9kb19u ZXdwY19jb250OwotCiAJCWlmICghcnEtPnRpbWVvdXQpCiAJCQlycS0+dGltZW91dCA9IEFUQVBJ X1dBSVRfUEM7CiAKQEAgLTEyNTAsNyArMTE4Myw3IEBAIHN0YXRpYyBpZGVfc3RhcnRzdG9wX3Qg aWRlX2NkX2RvX3JlcXVlc3QoaWRlX2RyaXZlX3QgKmRyaXZlLCBzdHJ1Y3QgcmVxdWVzdCAqcnEs CiAJCXJldHVybiBpZGVfc3RvcHBlZDsKIAl9CiAKLQlyZXR1cm4gY2Ryb21fc3RhcnRfcGFja2V0 X2NvbW1hbmQoZHJpdmUsIHhmZXJsZW4sIGZuKTsKKwlyZXR1cm4gY2Ryb21fc3RhcnRfcGFja2V0 X2NvbW1hbmQoZHJpdmUpOwogfQogCiAvKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pZGUvaWRlLWNk LmggYi9kcml2ZXJzL2lkZS9pZGUtY2QuaAppbmRleCBkNWNlMzM2Li5iZjY3NmIyIDEwMDY0NAot LS0gYS9kcml2ZXJzL2lkZS9pZGUtY2QuaAorKysgYi9kcml2ZXJzL2lkZS9pZGUtY2QuaApAQCAt OCwxMCArOCwxNCBAQAogI2luY2x1ZGUgPGxpbnV4L2Nkcm9tLmg+CiAjaW5jbHVkZSA8YXNtL2J5 dGVvcmRlci5oPgogCi0vKgotICogdHlwaWNhbCB0aW1lb3V0IGZvciBwYWNrZXQgY29tbWFuZAot ICovCi0jZGVmaW5lIEFUQVBJX1dBSVRfUEMJCSg2MCAqIEhaKQorI2RlZmluZSBJREVDRF9ERUJV R19MT0cJCTAKKworI2lmIElERUNEX0RFQlVHX0xPRworI2RlZmluZSBpZGVfZGVidWdfbG9nKGx2 bCwgZm10LCBhcmdzLi4uKSBfX2lkZV9kZWJ1Z19sb2cobHZsLCBmbXQsIGFyZ3MpCisjZWxzZQor I2RlZmluZSBpZGVfZGVidWdfbG9nKGx2bCwgZm10LCBhcmdzLi4uKSBkbyB7fSB3aGlsZSAoMCkK KyNlbmRpZgorCiAjZGVmaW5lIEFUQVBJX1dBSVRfV1JJVEVfQlVTWQkoMTAgKiBIWikKIAogLyoq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaWRlL2lkZS1mbG9wcHkuYyBiL2Ry aXZlcnMvaWRlL2lkZS1mbG9wcHkuYwppbmRleCBhZWIxYWQ3Li4wYTQ4ZTJkIDEwMDY0NAotLS0g YS9kcml2ZXJzL2lkZS9pZGUtZmxvcHB5LmMKKysrIGIvZHJpdmVycy9pZGUvaWRlLWZsb3BweS5j CkBAIC0xOTcsNyArMTk3LDcgQEAgc3RhdGljIGlkZV9zdGFydHN0b3BfdCBpZGVmbG9wcHlfaXNz dWVfcGMoaWRlX2RyaXZlX3QgKmRyaXZlLAogCiAJcGMtPnJldHJpZXMrKzsKIAotCXJldHVybiBp ZGVfaXNzdWVfcGMoZHJpdmUsIFdBSVRfRkxPUFBZX0NNRCwgTlVMTCk7CisJcmV0dXJuIGlkZV9p c3N1ZV9wYyhkcml2ZSk7CiB9CiAKIHZvaWQgaWRlX2Zsb3BweV9jcmVhdGVfcmVhZF9jYXBhY2l0 eV9jbWQoc3RydWN0IGlkZV9hdGFwaV9wYyAqcGMpCkBAIC0zNDIsMzggKzM0MiwzOCBAQCBzdGF0 aWMgaWRlX3N0YXJ0c3RvcF90IGlkZV9mbG9wcHlfZG9fcmVxdWVzdChpZGVfZHJpdmVfdCAqZHJp dmUsCiAgKiBMb29rIGF0IHRoZSBmbGV4aWJsZSBkaXNrIHBhZ2UgcGFyYW1ldGVycy4gV2UgaWdu b3JlIHRoZSBDSFMgY2FwYWNpdHkKICAqIHBhcmFtZXRlcnMgYW5kIHVzZSB0aGUgTEJBIHBhcmFt ZXRlcnMgaW5zdGVhZC4KICAqLwotc3RhdGljIGludCBpZGVfZmxvcHB5X2dldF9mbGV4aWJsZV9k aXNrX3BhZ2UoaWRlX2RyaXZlX3QgKmRyaXZlKQorc3RhdGljIGludCBpZGVfZmxvcHB5X2dldF9m bGV4aWJsZV9kaXNrX3BhZ2UoaWRlX2RyaXZlX3QgKmRyaXZlLAorCQkJCQkgICAgIHN0cnVjdCBp ZGVfYXRhcGlfcGMgKnBjKQogewogCXN0cnVjdCBpZGVfZGlza19vYmogKmZsb3BweSA9IGRyaXZl LT5kcml2ZXJfZGF0YTsKIAlzdHJ1Y3QgZ2VuZGlzayAqZGlzayA9IGZsb3BweS0+ZGlzazsKLQlz dHJ1Y3QgaWRlX2F0YXBpX3BjIHBjOwogCXU4ICpwYWdlOwogCWludCBjYXBhY2l0eSwgbGJhX2Nh cGFjaXR5OwogCXUxNiB0cmFuc2Zlcl9yYXRlLCBzZWN0b3Jfc2l6ZSwgY3lscywgcnBtOwogCXU4 IGhlYWRzLCBzZWN0b3JzOwogCi0JaWRlX2Zsb3BweV9jcmVhdGVfbW9kZV9zZW5zZV9jbWQoJnBj LCBJREVGTE9QUFlfRkxFWElCTEVfRElTS19QQUdFKTsKKwlpZGVfZmxvcHB5X2NyZWF0ZV9tb2Rl X3NlbnNlX2NtZChwYywgSURFRkxPUFBZX0ZMRVhJQkxFX0RJU0tfUEFHRSk7CiAKLQlpZiAoaWRl X3F1ZXVlX3BjX3RhaWwoZHJpdmUsIGRpc2ssICZwYykpIHsKKwlpZiAoaWRlX3F1ZXVlX3BjX3Rh aWwoZHJpdmUsIGRpc2ssIHBjKSkgewogCQlwcmludGsoS0VSTl9FUlIgUEZYICJDYW4ndCBnZXQg ZmxleGlibGUgZGlzayBwYWdlIHBhcmFtc1xuIik7CiAJCXJldHVybiAxOwogCX0KIAotCWlmIChw Yy5idWZbM10gJiAweDgwKQorCWlmIChwYy0+YnVmWzNdICYgMHg4MCkKIAkJZHJpdmUtPmRldl9m bGFncyB8PSBJREVfREZMQUdfV1A7CiAJZWxzZQogCQlkcml2ZS0+ZGV2X2ZsYWdzICY9IH5JREVf REZMQUdfV1A7CiAKIAlzZXRfZGlza19ybyhkaXNrLCAhIShkcml2ZS0+ZGV2X2ZsYWdzICYgSURF X0RGTEFHX1dQKSk7CiAKLQlwYWdlID0gJnBjLmJ1Zls4XTsKKwlwYWdlID0gJnBjLT5idWZbOF07 CiAKLQl0cmFuc2Zlcl9yYXRlID0gYmUxNl90b19jcHVwKChfX2JlMTYgKikmcGMuYnVmWzggKyAy XSk7Ci0Jc2VjdG9yX3NpemUgICA9IGJlMTZfdG9fY3B1cCgoX19iZTE2ICopJnBjLmJ1Zls4ICsg Nl0pOwotCWN5bHMgICAgICAgICAgPSBiZTE2X3RvX2NwdXAoKF9fYmUxNiAqKSZwYy5idWZbOCAr IDhdKTsKLQlycG0gICAgICAgICAgID0gYmUxNl90b19jcHVwKChfX2JlMTYgKikmcGMuYnVmWzgg KyAyOF0pOwotCWhlYWRzICAgICAgICAgPSBwYy5idWZbOCArIDRdOwotCXNlY3RvcnMgICAgICAg PSBwYy5idWZbOCArIDVdOworCXRyYW5zZmVyX3JhdGUgPSBiZTE2X3RvX2NwdXAoKF9fYmUxNiAq KSZwYy0+YnVmWzggKyAyXSk7CisJc2VjdG9yX3NpemUgICA9IGJlMTZfdG9fY3B1cCgoX19iZTE2 ICopJnBjLT5idWZbOCArIDZdKTsKKwljeWxzICAgICAgICAgID0gYmUxNl90b19jcHVwKChfX2Jl MTYgKikmcGMtPmJ1Zls4ICsgOF0pOworCXJwbSAgICAgICAgICAgPSBiZTE2X3RvX2NwdXAoKF9f YmUxNiAqKSZwYy0+YnVmWzggKyAyOF0pOworCWhlYWRzICAgICAgICAgPSBwYy0+YnVmWzggKyA0 XTsKKwlzZWN0b3JzICAgICAgID0gcGMtPmJ1Zls4ICsgNV07CiAKIAljYXBhY2l0eSA9IGN5bHMg KiBoZWFkcyAqIHNlY3RvcnMgKiBzZWN0b3Jfc2l6ZTsKIApAQCAtNDk5LDcgKzQ5OSw3IEBAIHN0 YXRpYyBpbnQgaWRlX2Zsb3BweV9nZXRfY2FwYWNpdHkoaWRlX2RyaXZlX3QgKmRyaXZlKQogCiAJ LyogQ2xpayEgZGlzayBkb2VzIG5vdCBzdXBwb3J0IGdldF9mbGV4aWJsZV9kaXNrX3BhZ2UgKi8K IAlpZiAoIShkcml2ZS0+YXRhcGlfZmxhZ3MgJiBJREVfQUZMQUdfQ0xJS19EUklWRSkpCi0JCSh2 b2lkKSBpZGVfZmxvcHB5X2dldF9mbGV4aWJsZV9kaXNrX3BhZ2UoZHJpdmUpOworCQkodm9pZCkg aWRlX2Zsb3BweV9nZXRfZmxleGlibGVfZGlza19wYWdlKGRyaXZlLCAmcGMpOwogCiAJcmV0dXJu IHJjOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pZGUvaWRlLWZsb3BweV9pb2N0bC5jIGIvZHJp dmVycy9pZGUvaWRlLWZsb3BweV9pb2N0bC5jCmluZGV4IDJiYzUxZmYuLjhmOGJlODUgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvaWRlL2lkZS1mbG9wcHlfaW9jdGwuYworKysgYi9kcml2ZXJzL2lkZS9p ZGUtZmxvcHB5X2lvY3RsLmMKQEAgLTMxLDEwICszMSwxMSBAQAogICogT24gZXhpdCB3ZSBzZXQg bmZvcm1hdHMgdG8gdGhlIG51bWJlciBvZiByZWNvcmRzIHdlJ3ZlIGFjdHVhbGx5IGluaXRpYWxp emVkLgogICovCiAKLXN0YXRpYyBpbnQgaWRlX2Zsb3BweV9nZXRfZm9ybWF0X2NhcGFjaXRpZXMo aWRlX2RyaXZlX3QgKmRyaXZlLCBpbnQgX191c2VyICphcmcpCitzdGF0aWMgaW50IGlkZV9mbG9w cHlfZ2V0X2Zvcm1hdF9jYXBhY2l0aWVzKGlkZV9kcml2ZV90ICpkcml2ZSwKKwkJCQkJICAgIHN0 cnVjdCBpZGVfYXRhcGlfcGMgKnBjLAorCQkJCQkgICAgaW50IF9fdXNlciAqYXJnKQogewogCXN0 cnVjdCBpZGVfZGlza19vYmogKmZsb3BweSA9IGRyaXZlLT5kcml2ZXJfZGF0YTsKLQlzdHJ1Y3Qg aWRlX2F0YXBpX3BjIHBjOwogCXU4IGhlYWRlcl9sZW4sIGRlc2NfY250OwogCWludCBpLCBibG9j a3MsIGxlbmd0aCwgdV9hcnJheV9zaXplLCB1X2luZGV4OwogCWludCBfX3VzZXIgKmFyZ3A7CkBA IC00NSwxMyArNDYsMTMgQEAgc3RhdGljIGludCBpZGVfZmxvcHB5X2dldF9mb3JtYXRfY2FwYWNp dGllcyhpZGVfZHJpdmVfdCAqZHJpdmUsIGludCBfX3VzZXIgKmFyZykKIAlpZiAodV9hcnJheV9z aXplIDw9IDApCiAJCXJldHVybiAtRUlOVkFMOwogCi0JaWRlX2Zsb3BweV9jcmVhdGVfcmVhZF9j YXBhY2l0eV9jbWQoJnBjKTsKLQlpZiAoaWRlX3F1ZXVlX3BjX3RhaWwoZHJpdmUsIGZsb3BweS0+ ZGlzaywgJnBjKSkgeworCWlkZV9mbG9wcHlfY3JlYXRlX3JlYWRfY2FwYWNpdHlfY21kKHBjKTsK KwlpZiAoaWRlX3F1ZXVlX3BjX3RhaWwoZHJpdmUsIGZsb3BweS0+ZGlzaywgcGMpKSB7CiAJCXBy aW50ayhLRVJOX0VSUiAiaWRlLWZsb3BweTogQ2FuJ3QgZ2V0IGZsb3BweSBwYXJhbWV0ZXJzXG4i KTsKIAkJcmV0dXJuIC1FSU87CiAJfQogCi0JaGVhZGVyX2xlbiA9IHBjLmJ1ZlszXTsKKwloZWFk ZXJfbGVuID0gcGMtPmJ1ZlszXTsKIAlkZXNjX2NudCA9IGhlYWRlcl9sZW4gLyA4OyAvKiBjYXBh Y2l0eSBkZXNjcmlwdG9yIG9mIDggYnl0ZXMgKi8KIAogCXVfaW5kZXggPSAwOwpAQCAtNjgsOCAr NjksOCBAQCBzdGF0aWMgaW50IGlkZV9mbG9wcHlfZ2V0X2Zvcm1hdF9jYXBhY2l0aWVzKGlkZV9k cml2ZV90ICpkcml2ZSwgaW50IF9fdXNlciAqYXJnKQogCQlpZiAodV9pbmRleCA+PSB1X2FycmF5 X3NpemUpCiAJCQlicmVhazsJLyogVXNlci1zdXBwbGllZCBidWZmZXIgdG9vIHNtYWxsICovCiAK LQkJYmxvY2tzID0gYmUzMl90b19jcHVwKChfX2JlMzIgKikmcGMuYnVmW2Rlc2Nfc3RhcnRdKTsK LQkJbGVuZ3RoID0gYmUxNl90b19jcHVwKChfX2JlMTYgKikmcGMuYnVmW2Rlc2Nfc3RhcnQgKyA2 XSk7CisJCWJsb2NrcyA9IGJlMzJfdG9fY3B1cCgoX19iZTMyICopJnBjLT5idWZbZGVzY19zdGFy dF0pOworCQlsZW5ndGggPSBiZTE2X3RvX2NwdXAoKF9fYmUxNiAqKSZwYy0+YnVmW2Rlc2Nfc3Rh cnQgKyA2XSk7CiAKIAkJaWYgKHB1dF91c2VyKGJsb2NrcywgYXJncCkpCiAJCQlyZXR1cm4gLUVG QVVMVDsKQEAgLTExMSwyOSArMTEyLDI4IEBAIHN0YXRpYyB2b2lkIGlkZV9mbG9wcHlfY3JlYXRl X2Zvcm1hdF91bml0X2NtZChzdHJ1Y3QgaWRlX2F0YXBpX3BjICpwYywgaW50IGIsCiAJcGMtPmZs YWdzIHw9IFBDX0ZMQUdfV1JJVElORzsKIH0KIAotc3RhdGljIGludCBpZGVfZmxvcHB5X2dldF9z ZnJwX2JpdChpZGVfZHJpdmVfdCAqZHJpdmUpCitzdGF0aWMgaW50IGlkZV9mbG9wcHlfZ2V0X3Nm cnBfYml0KGlkZV9kcml2ZV90ICpkcml2ZSwgc3RydWN0IGlkZV9hdGFwaV9wYyAqcGMpCiB7CiAJ c3RydWN0IGlkZV9kaXNrX29iaiAqZmxvcHB5ID0gZHJpdmUtPmRyaXZlcl9kYXRhOwotCXN0cnVj dCBpZGVfYXRhcGlfcGMgcGM7CiAKIAlkcml2ZS0+YXRhcGlfZmxhZ3MgJj0gfklERV9BRkxBR19T UkZQOwogCi0JaWRlX2Zsb3BweV9jcmVhdGVfbW9kZV9zZW5zZV9jbWQoJnBjLCBJREVGTE9QUFlf Q0FQQUJJTElUSUVTX1BBR0UpOwotCXBjLmZsYWdzIHw9IFBDX0ZMQUdfU1VQUFJFU1NfRVJST1I7 CisJaWRlX2Zsb3BweV9jcmVhdGVfbW9kZV9zZW5zZV9jbWQocGMsIElERUZMT1BQWV9DQVBBQklM SVRJRVNfUEFHRSk7CisJcGMtPmZsYWdzIHw9IFBDX0ZMQUdfU1VQUFJFU1NfRVJST1I7CiAKLQlp ZiAoaWRlX3F1ZXVlX3BjX3RhaWwoZHJpdmUsIGZsb3BweS0+ZGlzaywgJnBjKSkKKwlpZiAoaWRl X3F1ZXVlX3BjX3RhaWwoZHJpdmUsIGZsb3BweS0+ZGlzaywgcGMpKQogCQlyZXR1cm4gMTsKIAot CWlmIChwYy5idWZbOCArIDJdICYgMHg0MCkKKwlpZiAocGMtPmJ1Zls4ICsgMl0gJiAweDQwKQog CQlkcml2ZS0+YXRhcGlfZmxhZ3MgfD0gSURFX0FGTEFHX1NSRlA7CiAKIAlyZXR1cm4gMDsKIH0K IAotc3RhdGljIGludCBpZGVfZmxvcHB5X2Zvcm1hdF91bml0KGlkZV9kcml2ZV90ICpkcml2ZSwg aW50IF9fdXNlciAqYXJnKQorc3RhdGljIGludCBpZGVfZmxvcHB5X2Zvcm1hdF91bml0KGlkZV9k cml2ZV90ICpkcml2ZSwgc3RydWN0IGlkZV9hdGFwaV9wYyAqcGMsCisJCQkJICBpbnQgX191c2Vy ICphcmcpCiB7CiAJc3RydWN0IGlkZV9kaXNrX29iaiAqZmxvcHB5ID0gZHJpdmUtPmRyaXZlcl9k YXRhOwotCXN0cnVjdCBpZGVfYXRhcGlfcGMgcGM7CiAJaW50IGJsb2NrcywgbGVuZ3RoLCBmbGFn cywgZXJyID0gMDsKIAogCWlmIChmbG9wcHktPm9wZW5lcnMgPiAxKSB7CkBAIC0xNjYsMTAgKzE2 NiwxMCBAQCBzdGF0aWMgaW50IGlkZV9mbG9wcHlfZm9ybWF0X3VuaXQoaWRlX2RyaXZlX3QgKmRy aXZlLCBpbnQgX191c2VyICphcmcpCiAJCWdvdG8gb3V0OwogCX0KIAotCSh2b2lkKWlkZV9mbG9w cHlfZ2V0X3NmcnBfYml0KGRyaXZlKTsKLQlpZGVfZmxvcHB5X2NyZWF0ZV9mb3JtYXRfdW5pdF9j bWQoJnBjLCBibG9ja3MsIGxlbmd0aCwgZmxhZ3MpOworCWlkZV9mbG9wcHlfZ2V0X3NmcnBfYml0 KGRyaXZlLCBwYyk7CisJaWRlX2Zsb3BweV9jcmVhdGVfZm9ybWF0X3VuaXRfY21kKHBjLCBibG9j a3MsIGxlbmd0aCwgZmxhZ3MpOwogCi0JaWYgKGlkZV9xdWV1ZV9wY190YWlsKGRyaXZlLCBmbG9w cHktPmRpc2ssICZwYykpCisJaWYgKGlkZV9xdWV1ZV9wY190YWlsKGRyaXZlLCBmbG9wcHktPmRp c2ssIHBjKSkKIAkJZXJyID0gLUVJTzsKIAogb3V0OgpAQCAtMTg4LDE1ICsxODgsMTYgQEAgb3V0 OgogICogdGhlIGRzYyBiaXQsIGFuZCByZXR1cm4gZWl0aGVyIDAgb3IgNjU1MzYuCiAgKi8KIAot c3RhdGljIGludCBpZGVfZmxvcHB5X2dldF9mb3JtYXRfcHJvZ3Jlc3MoaWRlX2RyaXZlX3QgKmRy aXZlLCBpbnQgX191c2VyICphcmcpCitzdGF0aWMgaW50IGlkZV9mbG9wcHlfZ2V0X2Zvcm1hdF9w cm9ncmVzcyhpZGVfZHJpdmVfdCAqZHJpdmUsCisJCQkJCSAgc3RydWN0IGlkZV9hdGFwaV9wYyAq cGMsCisJCQkJCSAgaW50IF9fdXNlciAqYXJnKQogewogCXN0cnVjdCBpZGVfZGlza19vYmogKmZs b3BweSA9IGRyaXZlLT5kcml2ZXJfZGF0YTsKLQlzdHJ1Y3QgaWRlX2F0YXBpX3BjIHBjOwogCWlu dCBwcm9ncmVzc19pbmRpY2F0aW9uID0gMHgxMDAwMDsKIAogCWlmIChkcml2ZS0+YXRhcGlfZmxh Z3MgJiBJREVfQUZMQUdfU1JGUCkgewotCQlpZGVfY3JlYXRlX3JlcXVlc3Rfc2Vuc2VfY21kKGRy aXZlLCAmcGMpOwotCQlpZiAoaWRlX3F1ZXVlX3BjX3RhaWwoZHJpdmUsIGZsb3BweS0+ZGlzaywg JnBjKSkKKwkJaWRlX2NyZWF0ZV9yZXF1ZXN0X3NlbnNlX2NtZChkcml2ZSwgcGMpOworCQlpZiAo aWRlX3F1ZXVlX3BjX3RhaWwoZHJpdmUsIGZsb3BweS0+ZGlzaywgcGMpKQogCQkJcmV0dXJuIC1F SU87CiAKIAkJaWYgKGZsb3BweS0+c2Vuc2Vfa2V5ID09IDIgJiYKQEAgLTI0MSwyMCArMjQyLDIx IEBAIHN0YXRpYyBpbnQgaWRlX2Zsb3BweV9sb2NrZG9vcihpZGVfZHJpdmVfdCAqZHJpdmUsIHN0 cnVjdCBpZGVfYXRhcGlfcGMgKnBjLAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW50IGlkZV9m bG9wcHlfZm9ybWF0X2lvY3RsKGlkZV9kcml2ZV90ICpkcml2ZSwgZm1vZGVfdCBtb2RlLAotCQkJ CSAgIHVuc2lnbmVkIGludCBjbWQsIHZvaWQgX191c2VyICphcmdwKQorc3RhdGljIGludCBpZGVf ZmxvcHB5X2Zvcm1hdF9pb2N0bChpZGVfZHJpdmVfdCAqZHJpdmUsIHN0cnVjdCBpZGVfYXRhcGlf cGMgKnBjLAorCQkJCSAgIGZtb2RlX3QgbW9kZSwgdW5zaWduZWQgaW50IGNtZCwKKwkJCQkgICB2 b2lkIF9fdXNlciAqYXJncCkKIHsKIAlzd2l0Y2ggKGNtZCkgewogCWNhc2UgSURFRkxPUFBZX0lP Q1RMX0ZPUk1BVF9TVVBQT1JURUQ6CiAJCXJldHVybiAwOwogCWNhc2UgSURFRkxPUFBZX0lPQ1RM X0ZPUk1BVF9HRVRfQ0FQQUNJVFk6Ci0JCXJldHVybiBpZGVfZmxvcHB5X2dldF9mb3JtYXRfY2Fw YWNpdGllcyhkcml2ZSwgYXJncCk7CisJCXJldHVybiBpZGVfZmxvcHB5X2dldF9mb3JtYXRfY2Fw YWNpdGllcyhkcml2ZSwgcGMsIGFyZ3ApOwogCWNhc2UgSURFRkxPUFBZX0lPQ1RMX0ZPUk1BVF9T VEFSVDoKIAkJaWYgKCEobW9kZSAmIEZNT0RFX1dSSVRFKSkKIAkJCXJldHVybiAtRVBFUk07Ci0J CXJldHVybiBpZGVfZmxvcHB5X2Zvcm1hdF91bml0KGRyaXZlLCAoaW50IF9fdXNlciAqKWFyZ3Ap OworCQlyZXR1cm4gaWRlX2Zsb3BweV9mb3JtYXRfdW5pdChkcml2ZSwgcGMsIChpbnQgX191c2Vy ICopYXJncCk7CiAJY2FzZSBJREVGTE9QUFlfSU9DVExfRk9STUFUX0dFVF9QUk9HUkVTUzoKLQkJ cmV0dXJuIGlkZV9mbG9wcHlfZ2V0X2Zvcm1hdF9wcm9ncmVzcyhkcml2ZSwgYXJncCk7CisJCXJl dHVybiBpZGVfZmxvcHB5X2dldF9mb3JtYXRfcHJvZ3Jlc3MoZHJpdmUsIHBjLCBhcmdwKTsKIAlk ZWZhdWx0OgogCQlyZXR1cm4gLUVOT1RUWTsKIAl9CkBAIC0yNzAsNyArMjcyLDcgQEAgaW50IGlk ZV9mbG9wcHlfaW9jdGwoaWRlX2RyaXZlX3QgKmRyaXZlLCBzdHJ1Y3QgYmxvY2tfZGV2aWNlICpi ZGV2LAogCWlmIChjbWQgPT0gQ0RST01FSkVDVCB8fCBjbWQgPT0gQ0RST01fTE9DS0RPT1IpCiAJ CXJldHVybiBpZGVfZmxvcHB5X2xvY2tkb29yKGRyaXZlLCAmcGMsIGFyZywgY21kKTsKIAotCWVy ciA9IGlkZV9mbG9wcHlfZm9ybWF0X2lvY3RsKGRyaXZlLCBtb2RlLCBjbWQsIGFyZ3ApOworCWVy ciA9IGlkZV9mbG9wcHlfZm9ybWF0X2lvY3RsKGRyaXZlLCAmcGMsIG1vZGUsIGNtZCwgYXJncCk7 CiAJaWYgKGVyciAhPSAtRU5PVFRZKQogCQlyZXR1cm4gZXJyOwogCmRpZmYgLS1naXQgYS9kcml2 ZXJzL2lkZS9pZGUtaW8uYyBiL2RyaXZlcnMvaWRlL2lkZS1pby5jCmluZGV4IGVjYWNjMDAuLjFj MzZhOGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaWRlL2lkZS1pby5jCisrKyBiL2RyaXZlcnMvaWRl L2lkZS1pby5jCkBAIC00MjYsOSArNDI2LDYgQEAgdm9pZCBpZGVfbWFwX3NnKGlkZV9kcml2ZV90 ICpkcml2ZSwgc3RydWN0IHJlcXVlc3QgKnJxKQogCWlkZV9od2lmX3QgKmh3aWYgPSBkcml2ZS0+ aHdpZjsKIAlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnID0gaHdpZi0+c2dfdGFibGU7CiAKLQlpZiAo aHdpZi0+c2dfbWFwcGVkKQkvKiBuZWVkZWQgYnkgaWRlLXNjc2kgKi8KLQkJcmV0dXJuOwotCiAJ aWYgKHJxLT5jbWRfdHlwZSAhPSBSRVFfVFlQRV9BVEFfVEFTS0ZJTEUpIHsKIAkJaHdpZi0+c2df bmVudHMgPSBibGtfcnFfbWFwX3NnKGRyaXZlLT5xdWV1ZSwgcnEsIHNnKTsKIAl9IGVsc2UgewpA QCAtNjY3LDg1ICs2NjQsMTAgQEAgdm9pZCBpZGVfc3RhbGxfcXVldWUgKGlkZV9kcml2ZV90ICpk cml2ZSwgdW5zaWduZWQgbG9uZyB0aW1lb3V0KQogCWRyaXZlLT5zbGVlcCA9IHRpbWVvdXQgKyBq aWZmaWVzOwogCWRyaXZlLT5kZXZfZmxhZ3MgfD0gSURFX0RGTEFHX1NMRUVQSU5HOwogfQotCiBF WFBPUlRfU1lNQk9MKGlkZV9zdGFsbF9xdWV1ZSk7CiAKLSNkZWZpbmUgV0FLRVVQKGRyaXZlKQko KGRyaXZlKS0+c2VydmljZV9zdGFydCArIDIgKiAoZHJpdmUpLT5zZXJ2aWNlX3RpbWUpCi0KLS8q KgotICoJY2hvb3NlX2RyaXZlCQktCXNlbGVjdCBhIGRyaXZlIHRvIHNlcnZpY2UKLSAqCUBod2dy b3VwOiBoYXJkd2FyZSBncm91cCB0byBzZWxlY3Qgb24KLSAqCi0gKgljaG9vc2VfZHJpdmUoKSBz ZWxlY3RzIHRoZSBuZXh0IGRyaXZlIHdoaWNoIHdpbGwgYmUgc2VydmljZWQuCi0gKglUaGlzIGlz IG5lY2Vzc2FyeSBiZWNhdXNlIHRoZSBJREUgbGF5ZXIgY2FuJ3QgaXNzdWUgY29tbWFuZHMKLSAq CXRvIGJvdGggZHJpdmVzIG9uIHRoZSBzYW1lIGNhYmxlLCB1bmxpa2UgU0NTSS4KLSAqLwotIAot c3RhdGljIGlubGluZSBpZGVfZHJpdmVfdCAqY2hvb3NlX2RyaXZlIChpZGVfaHdncm91cF90ICpo d2dyb3VwKQotewotCWlkZV9kcml2ZV90ICpkcml2ZSwgKmJlc3Q7Ci0KLXJlcGVhdDoJCi0JYmVz dCA9IE5VTEw7Ci0JZHJpdmUgPSBod2dyb3VwLT5kcml2ZTsKLQotCS8qCi0JICogZHJpdmUgaXMg ZG9pbmcgcHJlLWZsdXNoLCBvcmRlcmVkIHdyaXRlLCBwb3N0LWZsdXNoIHNlcXVlbmNlLiBldmVu Ci0JICogdGhvdWdoIHRoYXQgaXMgMyByZXF1ZXN0cywgaXQgbXVzdCBiZSBzZWVuIGFzIGEgc2lu Z2xlIHRyYW5zYWN0aW9uLgotCSAqIHdlIG11c3Qgbm90IHByZWVtcHQgdGhpcyBkcml2ZSB1bnRp bCB0aGF0IGlzIGNvbXBsZXRlCi0JICovCi0JaWYgKGJsa19xdWV1ZV9mbHVzaGluZyhkcml2ZS0+ cXVldWUpKSB7Ci0JCS8qCi0JCSAqIHNtYWxsIHJhY2Ugd2hlcmUgcXVldWUgY291bGQgZ2V0IHJl cGx1Z2dlZCBkdXJpbmcKLQkJICogdGhlIDMtcmVxdWVzdCBmbHVzaCBjeWNsZSwganVzdCB5YW5r IHRoZSBwbHVnIHNpbmNlCi0JCSAqIHdlIHdhbnQgaXQgdG8gZmluaXNoIGFzYXAKLQkJICovCi0J CWJsa19yZW1vdmVfcGx1Zyhkcml2ZS0+cXVldWUpOwotCQlyZXR1cm4gZHJpdmU7Ci0JfQotCi0J ZG8gewotCQl1OCBkZXZfcyA9ICEhKGRyaXZlLT5kZXZfZmxhZ3MgJiBJREVfREZMQUdfU0xFRVBJ TkcpOwotCQl1OCBiZXN0X3MgPSAoYmVzdCAmJiAhIShiZXN0LT5kZXZfZmxhZ3MgJiBJREVfREZM QUdfU0xFRVBJTkcpKTsKLQotCQlpZiAoKGRldl9zID09IDAgfHwgdGltZV9hZnRlcl9lcShqaWZm aWVzLCBkcml2ZS0+c2xlZXApKSAmJgotCQkgICAgIWVsdl9xdWV1ZV9lbXB0eShkcml2ZS0+cXVl dWUpKSB7Ci0JCQlpZiAoYmVzdCA9PSBOVUxMIHx8Ci0JCQkgICAgKGRldl9zICYmIChiZXN0X3Mg PT0gMCB8fCB0aW1lX2JlZm9yZShkcml2ZS0+c2xlZXAsIGJlc3QtPnNsZWVwKSkpIHx8Ci0JCQkg ICAgKGJlc3RfcyA9PSAwICYmIHRpbWVfYmVmb3JlKFdBS0VVUChkcml2ZSksIFdBS0VVUChiZXN0 KSkpKSB7Ci0JCQkJaWYgKCFibGtfcXVldWVfcGx1Z2dlZChkcml2ZS0+cXVldWUpKQotCQkJCQli ZXN0ID0gZHJpdmU7Ci0JCQl9Ci0JCX0KLQl9IHdoaWxlICgoZHJpdmUgPSBkcml2ZS0+bmV4dCkg IT0gaHdncm91cC0+ZHJpdmUpOwotCi0JaWYgKGJlc3QgJiYgKGJlc3QtPmRldl9mbGFncyAmIElE RV9ERkxBR19OSUNFMSkgJiYKLQkgICAgKGJlc3QtPmRldl9mbGFncyAmIElERV9ERkxBR19TTEVF UElORykgPT0gMCAmJgotCSAgICBiZXN0ICE9IGh3Z3JvdXAtPmRyaXZlICYmIGJlc3QtPnNlcnZp Y2VfdGltZSA+IFdBSVRfTUlOX1NMRUVQKSB7Ci0JCWxvbmcgdCA9IChzaWduZWQgbG9uZykoV0FL RVVQKGJlc3QpIC0gamlmZmllcyk7Ci0JCWlmICh0ID49IFdBSVRfTUlOX1NMRUVQKSB7Ci0JCS8q Ci0JCSAqIFdlICptYXkqIGhhdmUgc29tZSB0aW1lIHRvIHNwYXJlLCBidXQgZmlyc3QgbGV0J3Mg c2VlIGlmCi0JCSAqIHNvbWVvbmUgY2FuIHBvdGVudGlhbGx5IGJlbmVmaXQgZnJvbSBvdXIgbmlj ZSBtb29kIHRvZGF5Li4KLQkJICovCi0JCQlkcml2ZSA9IGJlc3QtPm5leHQ7Ci0JCQlkbyB7Ci0J CQkJaWYgKChkcml2ZS0+ZGV2X2ZsYWdzICYgSURFX0RGTEFHX1NMRUVQSU5HKSA9PSAwCi0JCQkJ ICYmIHRpbWVfYmVmb3JlKGppZmZpZXMgLSBiZXN0LT5zZXJ2aWNlX3RpbWUsIFdBS0VVUChkcml2 ZSkpCi0JCQkJICYmIHRpbWVfYmVmb3JlKFdBS0VVUChkcml2ZSksIGppZmZpZXMgKyB0KSkKLQkJ CQl7Ci0JCQkJCWlkZV9zdGFsbF9xdWV1ZShiZXN0LCBtaW5fdChsb25nLCB0LCAxMCAqIFdBSVRf TUlOX1NMRUVQKSk7Ci0JCQkJCWdvdG8gcmVwZWF0OwotCQkJCX0KLQkJCX0gd2hpbGUgKChkcml2 ZSA9IGRyaXZlLT5uZXh0KSAhPSBiZXN0KTsKLQkJfQotCX0KLQlyZXR1cm4gYmVzdDsKLX0KLQog LyoKICAqIElzc3VlIGEgbmV3IHJlcXVlc3QgdG8gYSBkcml2ZSBmcm9tIGh3Z3JvdXAKLSAqIENh bGxlciBtdXN0IGhhdmUgYWxyZWFkeSBkb25lIHNwaW5fbG9ja19pcnFzYXZlKCZod2dyb3VwLT5s b2NrLCAuLik7CiAgKgogICogQSBod2dyb3VwIGlzIGEgc2VyaWFsaXplZCBncm91cCBvZiBJREUg aW50ZXJmYWNlcy4gIFVzdWFsbHkgdGhlcmUgaXMKICAqIGV4YWN0bHkgb25lIGh3aWYgKGludGVy ZmFjZSkgcGVyIGh3Z3JvdXAsIGJ1dCBidWdneSBjb250cm9sbGVycyAoZWcuIENNRDY0MCkKQEAg LTc1Nyw4ICs2NzksNyBAQCByZXBlYXQ6CiAgKiBwb3NzaWJseSBhbG9uZyB3aXRoIG1hbnkgb3Ro ZXIgZGV2aWNlcy4gIFRoaXMgaXMgZXNwZWNpYWxseSBjb21tb24gaW4KICAqIFBDSS1iYXNlZCBz eXN0ZW1zIHdpdGggb2ZmLWJvYXJkIElERSBjb250cm9sbGVyIGNhcmRzLgogICoKLSAqIFRoZSBJ REUgZHJpdmVyIHVzZXMgYSBwZXItaHdncm91cCBzcGlubG9jayB0byBwcm90ZWN0Ci0gKiBhY2Nl c3MgdG8gdGhlIHJlcXVlc3QgcXVldWVzLCBhbmQgdG8gcHJvdGVjdCB0aGUgaHdncm91cC0+YnVz eSBmbGFnLgorICogVGhlIElERSBkcml2ZXIgdXNlcyBhIHBlci1od2dyb3VwIGxvY2sgdG8gcHJv dGVjdCB0aGUgaHdncm91cC0+YnVzeSBmbGFnLgogICoKICAqIFRoZSBmaXJzdCB0aHJlYWQgaW50 byB0aGUgZHJpdmVyIGZvciBhIHBhcnRpY3VsYXIgaHdncm91cCBzZXRzIHRoZQogICogaHdncm91 cC0+YnVzeSBmbGFnIHRvIGluZGljYXRlIHRoYXQgdGhpcyBod2dyb3VwIGlzIG5vdyBhY3RpdmUs CkBAIC03NzgsNjkgKzY5OSw0MSBAQCByZXBlYXQ6CiAgKiB0aGUgZHJpdmVyLiAgVGhpcyBtYWtl cyB0aGUgZHJpdmVyIG11Y2ggbW9yZSBmcmllbmRsaWVyIHRvIHNoYXJlZCBJUlFzCiAgKiB0aGFu IHByZXZpb3VzIGRlc2lnbnMsIHdoaWxlIHJlbWFpbmluZyAxMDAlICg/KSBTTVAgc2FmZSBhbmQg Y2FwYWJsZS4KICAqLwotc3RhdGljIHZvaWQgaWRlX2RvX3JlcXVlc3QgKGlkZV9od2dyb3VwX3Qg Kmh3Z3JvdXAsIGludCBtYXNrZWRfaXJxKQordm9pZCBkb19pZGVfcmVxdWVzdChzdHJ1Y3QgcmVx dWVzdF9xdWV1ZSAqcSkKIHsKLQlpZGVfZHJpdmVfdAkqZHJpdmU7Ci0JaWRlX2h3aWZfdAkqaHdp ZjsKKwlpZGVfZHJpdmVfdAkqZHJpdmUgPSBxLT5xdWV1ZWRhdGE7CisJaWRlX2h3aWZfdAkqaHdp ZiA9IGRyaXZlLT5od2lmOworCWlkZV9od2dyb3VwX3QJKmh3Z3JvdXAgPSBod2lmLT5od2dyb3Vw OwogCXN0cnVjdCByZXF1ZXN0CSpycTsKIAlpZGVfc3RhcnRzdG9wX3QJc3RhcnRzdG9wOwotCWlu dCAgICAgICAgICAgICBsb29wcyA9IDA7Ci0KLQkvKiBjYWxsZXIgbXVzdCBvd24gaHdncm91cC0+ bG9jayAqLwotCUJVR19PTighaXJxc19kaXNhYmxlZCgpKTsKLQotCXdoaWxlICghaHdncm91cC0+ YnVzeSkgewotCQlod2dyb3VwLT5idXN5ID0gMTsKLQkJLyogZm9yIGF0YXJpIG9ubHkgKi8KLQkJ aWRlX2dldF9sb2NrKGlkZV9pbnRyLCBod2dyb3VwKTsKLQkJZHJpdmUgPSBjaG9vc2VfZHJpdmUo aHdncm91cCk7Ci0JCWlmIChkcml2ZSA9PSBOVUxMKSB7Ci0JCQlpbnQgc2xlZXBpbmcgPSAwOwot CQkJdW5zaWduZWQgbG9uZyBzbGVlcCA9IDA7IC8qIHNodXQgdXAsIGdjYyAqLwotCQkJaHdncm91 cC0+cnEgPSBOVUxMOwotCQkJZHJpdmUgPSBod2dyb3VwLT5kcml2ZTsKLQkJCWRvIHsKLQkJCQlp ZiAoKGRyaXZlLT5kZXZfZmxhZ3MgJiBJREVfREZMQUdfU0xFRVBJTkcpICYmCi0JCQkJICAgIChz bGVlcGluZyA9PSAwIHx8Ci0JCQkJICAgICB0aW1lX2JlZm9yZShkcml2ZS0+c2xlZXAsIHNsZWVw KSkpIHsKLQkJCQkJc2xlZXBpbmcgPSAxOwotCQkJCQlzbGVlcCA9IGRyaXZlLT5zbGVlcDsKLQkJ CQl9Ci0JCQl9IHdoaWxlICgoZHJpdmUgPSBkcml2ZS0+bmV4dCkgIT0gaHdncm91cC0+ZHJpdmUp OwotCQkJaWYgKHNsZWVwaW5nKSB7CisKKwkvKgorCSAqIGRyaXZlIGlzIGRvaW5nIHByZS1mbHVz aCwgb3JkZXJlZCB3cml0ZSwgcG9zdC1mbHVzaCBzZXF1ZW5jZS4gZXZlbgorCSAqIHRob3VnaCB0 aGF0IGlzIDMgcmVxdWVzdHMsIGl0IG11c3QgYmUgc2VlbiBhcyBhIHNpbmdsZSB0cmFuc2FjdGlv bi4KKwkgKiB3ZSBtdXN0IG5vdCBwcmVlbXB0IHRoaXMgZHJpdmUgdW50aWwgdGhhdCBpcyBjb21w bGV0ZQorCSAqLworCWlmIChibGtfcXVldWVfZmx1c2hpbmcocSkpCiAJCS8qCi0JCSAqIFRha2Ug YSBzaG9ydCBzbm9vemUsIGFuZCB0aGVuIHdha2UgdXAgdGhpcyBod2dyb3VwIGFnYWluLgotCQkg KiBUaGlzIGdpdmVzIG90aGVyIGh3Z3JvdXBzIG9uIHRoZSBzYW1lIGEgY2hhbmNlIHRvCi0JCSAq IHBsYXkgZmFpcmx5IHdpdGggdXMsIGp1c3QgaW4gY2FzZSB0aGVyZSBhcmUgYmlnIGRpZmZlcmVu Y2VzCi0JCSAqIGluIHJlbGF0aXZlIHRocm91Z2hwdXRzLi4gZG9uJ3Qgd2FudCB0byBob2cgdGhl IGNwdSB0b28gbXVjaC4KKwkJICogc21hbGwgcmFjZSB3aGVyZSBxdWV1ZSBjb3VsZCBnZXQgcmVw bHVnZ2VkIGR1cmluZworCQkgKiB0aGUgMy1yZXF1ZXN0IGZsdXNoIGN5Y2xlLCBqdXN0IHlhbmsg dGhlIHBsdWcgc2luY2UKKwkJICogd2Ugd2FudCBpdCB0byBmaW5pc2ggYXNhcAogCQkgKi8KLQkJ CQlpZiAodGltZV9iZWZvcmUoc2xlZXAsIGppZmZpZXMgKyBXQUlUX01JTl9TTEVFUCkpCi0JCQkJ CXNsZWVwID0gamlmZmllcyArIFdBSVRfTUlOX1NMRUVQOwotI2lmIDEKLQkJCQlpZiAodGltZXJf cGVuZGluZygmaHdncm91cC0+dGltZXIpKQotCQkJCQlwcmludGsoS0VSTl9DUklUICJpZGVfc2V0 X2hhbmRsZXI6IHRpbWVyIGFscmVhZHkgYWN0aXZlXG4iKTsKLSNlbmRpZgotCQkJCS8qIHNvIHRo YXQgaWRlX3RpbWVyX2V4cGlyeSBrbm93cyB3aGF0IHRvIGRvICovCi0JCQkJaHdncm91cC0+c2xl ZXBpbmcgPSAxOwotCQkJCWh3Z3JvdXAtPnJlcV9nZW5fdGltZXIgPSBod2dyb3VwLT5yZXFfZ2Vu OwotCQkJCW1vZF90aW1lcigmaHdncm91cC0+dGltZXIsIHNsZWVwKTsKLQkJCQkvKiB3ZSBwdXJw b3NlbHkgbGVhdmUgaHdncm91cC0+YnVzeT09MQotCQkJCSAqIHdoaWxlIHNsZWVwaW5nICovCi0J CQl9IGVsc2UgewotCQkJCS8qIFVnbHksIGJ1dCBob3cgY2FuIHdlIHNsZWVwIGZvciB0aGUgbG9j awotCQkJCSAqIG90aGVyd2lzZT8gcGVyaGFwcyBmcm9tIHRxX2Rpc2s/Ci0JCQkJICovCisJCWJs a19yZW1vdmVfcGx1ZyhxKTsKIAotCQkJCS8qIGZvciBhdGFyaSBvbmx5ICovCi0JCQkJaWRlX3Jl bGVhc2VfbG9jaygpOwotCQkJCWh3Z3JvdXAtPmJ1c3kgPSAwOwotCQkJfQorCXNwaW5fdW5sb2Nr X2lycShxLT5xdWV1ZV9sb2NrKTsKKwlzcGluX2xvY2tfaXJxKCZod2dyb3VwLT5sb2NrKTsKKwor CWlmICghaWRlX2xvY2tfaHdncm91cChod2dyb3VwKSkgeworcmVwZWF0OgorCQlod2dyb3VwLT5y cSA9IE5VTEw7CiAKLQkJCS8qIG5vIG1vcmUgd29yayBmb3IgdGhpcyBod2dyb3VwIChmb3Igbm93 KSAqLwotCQkJcmV0dXJuOworCQlpZiAoZHJpdmUtPmRldl9mbGFncyAmIElERV9ERkxBR19TTEVF UElORykgeworCQkJaWYgKHRpbWVfYmVmb3JlKGRyaXZlLT5zbGVlcCwgamlmZmllcykpIHsKKwkJ CQlpZGVfdW5sb2NrX2h3Z3JvdXAoaHdncm91cCk7CisJCQkJZ290byBwbHVnX2RldmljZTsKKwkJ CX0KIAkJfQotCWFnYWluOgotCQlod2lmID0gSFdJRihkcml2ZSk7CisKIAkJaWYgKGh3aWYgIT0g aHdncm91cC0+aHdpZikgewogCQkJLyoKIAkJCSAqIHNldCBuSUVOIGZvciBwcmV2aW91cyBod2lm LCBkcml2ZXMgaW4gdGhlCkBAIC04NTIsMTYgKzc0NSwyMCBAQCBzdGF0aWMgdm9pZCBpZGVfZG9f cmVxdWVzdCAoaWRlX2h3Z3JvdXBfdCAqaHdncm91cCwgaW50IG1hc2tlZF9pcnEpCiAJCWh3Z3Jv dXAtPmh3aWYgPSBod2lmOwogCQlod2dyb3VwLT5kcml2ZSA9IGRyaXZlOwogCQlkcml2ZS0+ZGV2 X2ZsYWdzICY9IH4oSURFX0RGTEFHX1NMRUVQSU5HIHwgSURFX0RGTEFHX1BBUktFRCk7Ci0JCWRy aXZlLT5zZXJ2aWNlX3N0YXJ0ID0gamlmZmllczsKIAorCQlzcGluX3VubG9ja19pcnEoJmh3Z3Jv dXAtPmxvY2spOworCQlzcGluX2xvY2tfaXJxKHEtPnF1ZXVlX2xvY2spOwogCQkvKgogCQkgKiB3 ZSBrbm93IHRoYXQgdGhlIHF1ZXVlIGlzbid0IGVtcHR5LCBidXQgdGhpcyBjYW4gaGFwcGVuCiAJ CSAqIGlmIHRoZSBxLT5wcmVwX3JxX2ZuKCkgZGVjaWRlcyB0byBraWxsIGEgcmVxdWVzdAogCQkg Ki8KIAkJcnEgPSBlbHZfbmV4dF9yZXF1ZXN0KGRyaXZlLT5xdWV1ZSk7CisJCXNwaW5fdW5sb2Nr X2lycShxLT5xdWV1ZV9sb2NrKTsKKwkJc3Bpbl9sb2NrX2lycSgmaHdncm91cC0+bG9jayk7CisK IAkJaWYgKCFycSkgewotCQkJaHdncm91cC0+YnVzeSA9IDA7Ci0JCQlicmVhazsKKwkJCWlkZV91 bmxvY2tfaHdncm91cChod2dyb3VwKTsKKwkJCWdvdG8gb3V0OwogCQl9CiAKIAkJLyoKQEAgLTg3 Niw1MyArNzczLDM2IEBAIHN0YXRpYyB2b2lkIGlkZV9kb19yZXF1ZXN0IChpZGVfaHdncm91cF90 ICpod2dyb3VwLCBpbnQgbWFza2VkX2lycSkKIAkJICogdGhvdWdoLiBJIGhvcGUgdGhhdCBkb2Vz bid0IGhhcHBlbiB0b28gbXVjaCwgaG9wZWZ1bGx5IG5vdAogCQkgKiB1bmxlc3MgdGhlIHN1YmRy aXZlciB0cmlnZ2VycyBzdWNoIGEgdGhpbmcgaW4gaXRzIG93biBQTQogCQkgKiBzdGF0ZSBtYWNo aW5lLgotCQkgKgotCQkgKiBXZSBjb3VudCBob3cgbWFueSB0aW1lcyB3ZSBsb29wIGhlcmUgdG8g bWFrZSBzdXJlIHdlIHNlcnZpY2UKLQkJICogYWxsIGRyaXZlcyBpbiB0aGUgaHdncm91cCB3aXRo b3V0IGxvb3BpbmcgZm9yIGV2ZXIKIAkJICovCiAJCWlmICgoZHJpdmUtPmRldl9mbGFncyAmIElE RV9ERkxBR19CTE9DS0VEKSAmJgogCQkgICAgYmxrX3BtX3JlcXVlc3QocnEpID09IDAgJiYKIAkJ ICAgIChycS0+Y21kX2ZsYWdzICYgUkVRX1BSRUVNUFQpID09IDApIHsKLQkJCWRyaXZlID0gZHJp dmUtPm5leHQgPyBkcml2ZS0+bmV4dCA6IGh3Z3JvdXAtPmRyaXZlOwotCQkJaWYgKGxvb3BzKysg PCA0ICYmICFibGtfcXVldWVfcGx1Z2dlZChkcml2ZS0+cXVldWUpKQotCQkJCWdvdG8gYWdhaW47 Ci0JCQkvKiBXZSBjbGVhciBidXN5LCB0aGVyZSBzaG91bGQgYmUgbm8gcGVuZGluZyBBVEEgY29t bWFuZCBhdCB0aGlzIHBvaW50LiAqLwotCQkJaHdncm91cC0+YnVzeSA9IDA7Ci0JCQlicmVhazsK KwkJCS8qIHRoZXJlIHNob3VsZCBiZSBubyBwZW5kaW5nIGNvbW1hbmQgYXQgdGhpcyBwb2ludCAq LworCQkJaWRlX3VubG9ja19od2dyb3VwKGh3Z3JvdXApOworCQkJZ290byBwbHVnX2RldmljZTsK IAkJfQogCiAJCWh3Z3JvdXAtPnJxID0gcnE7CiAKLQkJLyoKLQkJICogU29tZSBzeXN0ZW1zIGhh dmUgdHJvdWJsZSB3aXRoIElERSBJUlFzIGFycml2aW5nIHdoaWxlCi0JCSAqIHRoZSBkcml2ZXIg aXMgc3RpbGwgc2V0dGluZyB0aGluZ3MgdXAuICBTbywgaGVyZSB3ZSBkaXNhYmxlCi0JCSAqIHRo ZSBJUlEgdXNlZCBieSB0aGlzIGludGVyZmFjZSB3aGlsZSB0aGUgcmVxdWVzdCBpcyBiZWluZyBz dGFydGVkLgotCQkgKiBUaGlzIG1heSBsb29rIGJhZCBhdCBmaXJzdCwgYnV0IHByZXR0eSBtdWNo IHRoZSBzYW1lIHRoaW5nCi0JCSAqIGhhcHBlbnMgYW55d2F5IHdoZW4gYW55IGludGVycnVwdCBj b21lcyBpbiwgSURFIG9yIG90aGVyd2lzZQotCQkgKiAgLS0gdGhlIGtlcm5lbCBtYXNrcyB0aGUg SVJRIHdoaWxlIGl0IGlzIGJlaW5nIGhhbmRsZWQuCi0JCSAqLwotCQlpZiAobWFza2VkX2lycSAh PSBJREVfTk9fSVJRICYmIGh3aWYtPmlycSAhPSBtYXNrZWRfaXJxKQotCQkJZGlzYWJsZV9pcnFf bm9zeW5jKGh3aWYtPmlycSk7Ci0JCXNwaW5fdW5sb2NrKCZod2dyb3VwLT5sb2NrKTsKLQkJbG9j YWxfaXJxX2VuYWJsZV9pbl9oYXJkaXJxKCk7Ci0JCQkvKiBhbGxvdyBvdGhlciBJUlFzIHdoaWxl IHdlIHN0YXJ0IHRoaXMgcmVxdWVzdCAqLworCQlzcGluX3VubG9ja19pcnEoJmh3Z3JvdXAtPmxv Y2spOwogCQlzdGFydHN0b3AgPSBzdGFydF9yZXF1ZXN0KGRyaXZlLCBycSk7CiAJCXNwaW5fbG9j a19pcnEoJmh3Z3JvdXAtPmxvY2spOwotCQlpZiAobWFza2VkX2lycSAhPSBJREVfTk9fSVJRICYm IGh3aWYtPmlycSAhPSBtYXNrZWRfaXJxKQotCQkJZW5hYmxlX2lycShod2lmLT5pcnEpOworCiAJ CWlmIChzdGFydHN0b3AgPT0gaWRlX3N0b3BwZWQpCi0JCQlod2dyb3VwLT5idXN5ID0gMDsKLQl9 Ci19CisJCQlnb3RvIHJlcGVhdDsKKwl9IGVsc2UKKwkJZ290byBwbHVnX2RldmljZTsKK291dDoK KwlzcGluX3VubG9ja19pcnEoJmh3Z3JvdXAtPmxvY2spOworCXNwaW5fbG9ja19pcnEocS0+cXVl dWVfbG9jayk7CisJcmV0dXJuOwogCi0vKgotICogUGFzc2VzIHRoZSBzdHVmZiB0byBpZGVfZG9f cmVxdWVzdAotICovCi12b2lkIGRvX2lkZV9yZXF1ZXN0KHN0cnVjdCByZXF1ZXN0X3F1ZXVlICpx KQotewotCWlkZV9kcml2ZV90ICpkcml2ZSA9IHEtPnF1ZXVlZGF0YTsKK3BsdWdfZGV2aWNlOgor CXNwaW5fdW5sb2NrX2lycSgmaHdncm91cC0+bG9jayk7CisJc3Bpbl9sb2NrX2lycShxLT5xdWV1 ZV9sb2NrKTsKIAotCWlkZV9kb19yZXF1ZXN0KEhXR1JPVVAoZHJpdmUpLCBJREVfTk9fSVJRKTsK KwlpZiAoIWVsdl9xdWV1ZV9lbXB0eShxKSkKKwkJYmxrX3BsdWdfZGV2aWNlKHEpOwogfQogCiAv KgpAQCAtOTgzLDYgKzg2MywxNyBAQCBvdXQ6CiAJcmV0dXJuIHJldDsKIH0KIAorc3RhdGljIHZv aWQgaWRlX3BsdWdfZGV2aWNlKGlkZV9kcml2ZV90ICpkcml2ZSkKK3sKKwlzdHJ1Y3QgcmVxdWVz dF9xdWV1ZSAqcSA9IGRyaXZlLT5xdWV1ZTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bp bl9sb2NrX2lycXNhdmUocS0+cXVldWVfbG9jaywgZmxhZ3MpOworCWlmICghZWx2X3F1ZXVlX2Vt cHR5KHEpKQorCQlibGtfcGx1Z19kZXZpY2UocSk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZShx LT5xdWV1ZV9sb2NrLCBmbGFncyk7Cit9CisKIC8qKgogICoJaWRlX3RpbWVyX2V4cGlyeQktCWhh bmRsZSBsYWNrIG9mIGFuIElERSBpbnRlcnJ1cHQKICAqCUBkYXRhOiB0aW1lciBjYWxsYmFjayBt YWdpYyAoaHdncm91cCkKQEAgLTEwMDAsMTAgKzg5MSwxMiBAQCBvdXQ6CiB2b2lkIGlkZV90aW1l cl9leHBpcnkgKHVuc2lnbmVkIGxvbmcgZGF0YSkKIHsKIAlpZGVfaHdncm91cF90CSpod2dyb3Vw ID0gKGlkZV9od2dyb3VwX3QgKikgZGF0YTsKKwlpZGVfZHJpdmVfdAkqdW5pbml0aWFsaXplZF92 YXIoZHJpdmUpOwogCWlkZV9oYW5kbGVyX3QJKmhhbmRsZXI7CiAJaWRlX2V4cGlyeV90CSpleHBp cnk7CiAJdW5zaWduZWQgbG9uZwlmbGFnczsKIAl1bnNpZ25lZCBsb25nCXdhaXQgPSAtMTsKKwlp bnQJCXBsdWdfZGV2aWNlID0gMDsKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZod2dyb3VwLT5sb2Nr LCBmbGFncyk7CiAKQEAgLTEwMTUsMjIgKzkwOCwxNSBAQCB2b2lkIGlkZV90aW1lcl9leHBpcnkg KHVuc2lnbmVkIGxvbmcgZGF0YSkKIAkJICogb3Igd2Ugd2VyZSAic2xlZXBpbmciIHRvIGdpdmUg b3RoZXIgZGV2aWNlcyBhIGNoYW5jZS4KIAkJICogRWl0aGVyIHdheSwgd2UgZG9uJ3QgcmVhbGx5 IHdhbnQgdG8gY29tcGxhaW4gYWJvdXQgYW55dGhpbmcuCiAJCSAqLwotCQlpZiAoaHdncm91cC0+ c2xlZXBpbmcpIHsKLQkJCWh3Z3JvdXAtPnNsZWVwaW5nID0gMDsKLQkJCWh3Z3JvdXAtPmJ1c3kg PSAwOwotCQl9CiAJfSBlbHNlIHsKLQkJaWRlX2RyaXZlX3QgKmRyaXZlID0gaHdncm91cC0+ZHJp dmU7CisJCWRyaXZlID0gaHdncm91cC0+ZHJpdmU7CiAJCWlmICghZHJpdmUpIHsKIAkJCXByaW50 ayhLRVJOX0VSUiAiaWRlX3RpbWVyX2V4cGlyeTogaHdncm91cC0+ZHJpdmUgd2FzIE5VTExcbiIp OwogCQkJaHdncm91cC0+aGFuZGxlciA9IE5VTEw7CiAJCX0gZWxzZSB7CiAJCQlpZGVfaHdpZl90 ICpod2lmOwogCQkJaWRlX3N0YXJ0c3RvcF90IHN0YXJ0c3RvcCA9IGlkZV9zdG9wcGVkOwotCQkJ aWYgKCFod2dyb3VwLT5idXN5KSB7Ci0JCQkJaHdncm91cC0+YnVzeSA9IDE7CS8qIHBhcmFub2lh ICovCi0JCQkJcHJpbnRrKEtFUk5fRVJSICIlczogaWRlX3RpbWVyX2V4cGlyeTogaHdncm91cC0+ YnVzeSB3YXMgMCA/P1xuIiwgZHJpdmUtPm5hbWUpOwotCQkJfQorCiAJCQlpZiAoKGV4cGlyeSA9 IGh3Z3JvdXAtPmV4cGlyeSkgIT0gTlVMTCkgewogCQkJCS8qIGNvbnRpbnVlICovCiAJCQkJaWYg KCh3YWl0ID0gZXhwaXJ5KGRyaXZlKSkgPiAwKSB7CkBAIC0xMDcxLDE1ICs5NTcsMTggQEAgdm9p ZCBpZGVfdGltZXJfZXhwaXJ5ICh1bnNpZ25lZCBsb25nIGRhdGEpCiAJCQkJCWlkZV9lcnJvcihk cml2ZSwgImlycSB0aW1lb3V0IiwKIAkJCQkJCSAgaHdpZi0+dHBfb3BzLT5yZWFkX3N0YXR1cyho d2lmKSk7CiAJCQl9Ci0JCQlkcml2ZS0+c2VydmljZV90aW1lID0gamlmZmllcyAtIGRyaXZlLT5z ZXJ2aWNlX3N0YXJ0OwogCQkJc3Bpbl9sb2NrX2lycSgmaHdncm91cC0+bG9jayk7CiAJCQllbmFi bGVfaXJxKGh3aWYtPmlycSk7Ci0JCQlpZiAoc3RhcnRzdG9wID09IGlkZV9zdG9wcGVkKQotCQkJ CWh3Z3JvdXAtPmJ1c3kgPSAwOworCQkJaWYgKHN0YXJ0c3RvcCA9PSBpZGVfc3RvcHBlZCkgewor CQkJCWlkZV91bmxvY2tfaHdncm91cChod2dyb3VwKTsKKwkJCQlwbHVnX2RldmljZSA9IDE7CisJ CQl9CiAJCX0KIAl9Ci0JaWRlX2RvX3JlcXVlc3QoaHdncm91cCwgSURFX05PX0lSUSk7CiAJc3Bp bl91bmxvY2tfaXJxcmVzdG9yZSgmaHdncm91cC0+bG9jaywgZmxhZ3MpOworCisJaWYgKHBsdWdf ZGV2aWNlKQorCQlpZGVfcGx1Z19kZXZpY2UoZHJpdmUpOwogfQogCiAvKioKQEAgLTExNzMsMTAg KzEwNjIsMTEgQEAgaXJxcmV0dXJuX3QgaWRlX2ludHIgKGludCBpcnEsIHZvaWQgKmRldl9pZCkK IAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCWlkZV9od2dyb3VwX3QgKmh3Z3JvdXAgPSAoaWRlX2h3 Z3JvdXBfdCAqKWRldl9pZDsKIAlpZGVfaHdpZl90ICpod2lmID0gaHdncm91cC0+aHdpZjsKLQlp ZGVfZHJpdmVfdCAqZHJpdmU7CisJaWRlX2RyaXZlX3QgKnVuaW5pdGlhbGl6ZWRfdmFyKGRyaXZl KTsKIAlpZGVfaGFuZGxlcl90ICpoYW5kbGVyOwogCWlkZV9zdGFydHN0b3BfdCBzdGFydHN0b3A7 CiAJaXJxcmV0dXJuX3QgaXJxX3JldCA9IElSUV9OT05FOworCWludCBwbHVnX2RldmljZSA9IDA7 CiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmaHdncm91cC0+bG9jaywgZmxhZ3MpOwogCkBAIC0xMjQx LDEwICsxMTMxLDYgQEAgaXJxcmV0dXJuX3QgaWRlX2ludHIgKGludCBpcnEsIHZvaWQgKmRldl9p ZCkKIAkJICovCiAJCWdvdG8gb3V0OwogCi0JaWYgKCFod2dyb3VwLT5idXN5KSB7Ci0JCWh3Z3Jv dXAtPmJ1c3kgPSAxOwkvKiBwYXJhbm9pYSAqLwotCQlwcmludGsoS0VSTl9FUlIgIiVzOiBpZGVf aW50cjogaHdncm91cC0+YnVzeSB3YXMgMCA/P1xuIiwgZHJpdmUtPm5hbWUpOwotCX0KIAlod2dy b3VwLT5oYW5kbGVyID0gTlVMTDsKIAlod2dyb3VwLT5yZXFfZ2VuKys7CiAJZGVsX3RpbWVyKCZo d2dyb3VwLT50aW1lcik7CkBAIC0xMjY3LDIwICsxMTUzLDIyIEBAIGlycXJldHVybl90IGlkZV9p bnRyIChpbnQgaXJxLCB2b2lkICpkZXZfaWQpCiAJICogc2FtZSBpcnEgYXMgaXMgY3VycmVudGx5 IGJlaW5nIHNlcnZpY2VkIGhlcmUsIGFuZCBMaW51eAogCSAqIHdvbid0IGFsbG93IGFub3RoZXIg b2YgdGhlIHNhbWUgKG9uIGFueSBDUFUpIHVudGlsIHdlIHJldHVybi4KIAkgKi8KLQlkcml2ZS0+ c2VydmljZV90aW1lID0gamlmZmllcyAtIGRyaXZlLT5zZXJ2aWNlX3N0YXJ0OwogCWlmIChzdGFy dHN0b3AgPT0gaWRlX3N0b3BwZWQpIHsKIAkJaWYgKGh3Z3JvdXAtPmhhbmRsZXIgPT0gTlVMTCkg ewkvKiBwYXJhbm9pYSAqLwotCQkJaHdncm91cC0+YnVzeSA9IDA7Ci0JCQlpZGVfZG9fcmVxdWVz dChod2dyb3VwLCBod2lmLT5pcnEpOwotCQl9IGVsc2UgewotCQkJcHJpbnRrKEtFUk5fRVJSICIl czogaWRlX2ludHI6IGh1aD8gZXhwZWN0ZWQgTlVMTCBoYW5kbGVyICIKLQkJCQkib24gZXhpdFxu IiwgZHJpdmUtPm5hbWUpOwotCQl9CisJCQlpZGVfdW5sb2NrX2h3Z3JvdXAoaHdncm91cCk7CisJ CQlwbHVnX2RldmljZSA9IDE7CisJCX0gZWxzZQorCQkJcHJpbnRrKEtFUk5fRVJSICIlczogJXM6 IGh1aD8gZXhwZWN0ZWQgTlVMTCBoYW5kbGVyICIKKwkJCQkJIm9uIGV4aXRcbiIsIF9fZnVuY19f LCBkcml2ZS0+bmFtZSk7CiAJfQogb3V0X2hhbmRsZWQ6CiAJaXJxX3JldCA9IElSUV9IQU5ETEVE Owogb3V0OgogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmh3Z3JvdXAtPmxvY2ssIGZsYWdzKTsK KworCWlmIChwbHVnX2RldmljZSkKKwkJaWRlX3BsdWdfZGV2aWNlKGRyaXZlKTsKKwogCXJldHVy biBpcnFfcmV0OwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lkZS9pZGUtaW9jdGxzLmMgYi9k cml2ZXJzL2lkZS9pZGUtaW9jdGxzLmMKaW5kZXggMjgyMzJjNi4uMWJlMjYzZSAxMDA2NDQKLS0t IGEvZHJpdmVycy9pZGUvaWRlLWlvY3Rscy5jCisrKyBiL2RyaXZlcnMvaWRlL2lkZS1pb2N0bHMu YwpAQCAtOTUsOCArOTUsNyBAQCBzdGF0aWMgaW50IGlkZV9zZXRfbmljZV9pb2N0bChpZGVfZHJp dmVfdCAqZHJpdmUsIHVuc2lnbmVkIGxvbmcgYXJnKQogCQlyZXR1cm4gLUVQRVJNOwogCiAJaWYg KCgoYXJnID4+IElERV9OSUNFX0RTQ19PVkVSTEFQKSAmIDEpICYmCi0JICAgIChkcml2ZS0+bWVk aWEgIT0gaWRlX3RhcGUgfHwKLQkgICAgIChkcml2ZS0+ZGV2X2ZsYWdzICYgSURFX0RGTEFHX1ND U0kpKSkKKwkgICAgKGRyaXZlLT5tZWRpYSAhPSBpZGVfdGFwZSkpCiAJCXJldHVybiAtRVBFUk07 CiAKIAlpZiAoKGFyZyA+PiBJREVfTklDRV9EU0NfT1ZFUkxBUCkgJiAxKQpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9pZGUvaWRlLXBhcmsuYyBiL2RyaXZlcnMvaWRlL2lkZS1wYXJrLmMKaW5kZXggNjNk MDFjNS4uNjc4NDU0YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pZGUvaWRlLXBhcmsuYworKysgYi9k cml2ZXJzL2lkZS9pZGUtcGFyay5jCkBAIC0xNiwxNiArMTYsMTkgQEAgc3RhdGljIHZvaWQgaXNz dWVfcGFya19jbWQoaWRlX2RyaXZlX3QgKmRyaXZlLCB1bnNpZ25lZCBsb25nIHRpbWVvdXQpCiAJ c3Bpbl9sb2NrX2lycSgmaHdncm91cC0+bG9jayk7CiAJaWYgKGRyaXZlLT5kZXZfZmxhZ3MgJiBJ REVfREZMQUdfUEFSS0VEKSB7CiAJCWludCByZXNldF90aW1lciA9IHRpbWVfYmVmb3JlKHRpbWVv dXQsIGRyaXZlLT5zbGVlcCk7CisJCWludCBzdGFydF9xdWV1ZSA9IDA7CiAKIAkJZHJpdmUtPnNs ZWVwID0gdGltZW91dDsKIAkJd2FrZV91cF9hbGwoJmlkZV9wYXJrX3dxKTsKLQkJaWYgKHJlc2V0 X3RpbWVyICYmIGh3Z3JvdXAtPnNsZWVwaW5nICYmCi0JCSAgICBkZWxfdGltZXIoJmh3Z3JvdXAt PnRpbWVyKSkgewotCQkJaHdncm91cC0+c2xlZXBpbmcgPSAwOwotCQkJaHdncm91cC0+YnVzeSA9 IDA7CisJCWlmIChyZXNldF90aW1lciAmJiBkZWxfdGltZXIoJmh3Z3JvdXAtPnRpbWVyKSkKKwkJ CXN0YXJ0X3F1ZXVlID0gMTsKKwkJc3Bpbl91bmxvY2tfaXJxKCZod2dyb3VwLT5sb2NrKTsKKwor CQlpZiAoc3RhcnRfcXVldWUpIHsKKwkJCXNwaW5fbG9ja19pcnEocS0+cXVldWVfbG9jayk7CiAJ CQlibGtfc3RhcnRfcXVldWVpbmcocSk7CisJCQlzcGluX3VubG9ja19pcnEocS0+cXVldWVfbG9j ayk7CiAJCX0KLQkJc3Bpbl91bmxvY2tfaXJxKCZod2dyb3VwLT5sb2NrKTsKIAkJcmV0dXJuOwog CX0KIAlzcGluX3VubG9ja19pcnEoJmh3Z3JvdXAtPmxvY2spOwpkaWZmIC0tZ2l0IGEvZHJpdmVy cy9pZGUvaWRlLXByb2JlLmMgYi9kcml2ZXJzL2lkZS9pZGUtcHJvYmUuYwppbmRleCBhNjRlYzI1 Li5jNWFkYjdiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lkZS9pZGUtcHJvYmUuYworKysgYi9kcml2 ZXJzL2lkZS9pZGUtcHJvYmUuYwpAQCAtMTAxLDYgKzEwMSw4MiBAQCBzdGF0aWMgdm9pZCBpZGVf ZGlza19pbml0X211bHRfY291bnQoaWRlX2RyaXZlX3QgKmRyaXZlKQogCX0KIH0KIAorc3RhdGlj IHZvaWQgaWRlX2NsYXNzaWZ5X2F0YV9kZXYoaWRlX2RyaXZlX3QgKmRyaXZlKQoreworCXUxNiAq aWQgPSBkcml2ZS0+aWQ7CisJY2hhciAqbSA9IChjaGFyICopJmlkW0FUQV9JRF9QUk9EXTsKKwlp bnQgaXNfY2ZhID0gYXRhX2lkX2lzX2NmYShpZCk7CisKKwkvKiBDRiBkZXZpY2VzIGFyZSAqbm90 KiByZW1vdmFibGUgaW4gTGludXggZGVmaW5pdGlvbiBvZiB0aGUgdGVybSAqLworCWlmIChpc19j ZmEgPT0gMCAmJiAoaWRbQVRBX0lEX0NPTkZJR10gJiAoMSA8PCA3KSkpCisJCWRyaXZlLT5kZXZf ZmxhZ3MgfD0gSURFX0RGTEFHX1JFTU9WQUJMRTsKKworCWRyaXZlLT5tZWRpYSA9IGlkZV9kaXNr OworCisJaWYgKCFhdGFfaWRfaGFzX3VubG9hZChkcml2ZS0+aWQpKQorCQlkcml2ZS0+ZGV2X2Zs YWdzIHw9IElERV9ERkxBR19OT19VTkxPQUQ7CisKKwlwcmludGsoS0VSTl9JTkZPICIlczogJXMs ICVzIERJU0sgZHJpdmVcbiIsIGRyaXZlLT5uYW1lLCBtLAorCQlpc19jZmEgPyAiQ0ZBIiA6ICJB VEEiKTsKK30KKworc3RhdGljIHZvaWQgaWRlX2NsYXNzaWZ5X2F0YXBpX2RldihpZGVfZHJpdmVf dCAqZHJpdmUpCit7CisJdTE2ICppZCA9IGRyaXZlLT5pZDsKKwljaGFyICptID0gKGNoYXIgKikm aWRbQVRBX0lEX1BST0RdOworCXU4IHR5cGUgPSAoaWRbQVRBX0lEX0NPTkZJR10gPj4gOCkgJiAw eDFmOworCisJcHJpbnRrKEtFUk5fSU5GTyAiJXM6ICVzLCBBVEFQSSAiLCBkcml2ZS0+bmFtZSwg bSk7CisJc3dpdGNoICh0eXBlKSB7CisJY2FzZSBpZGVfZmxvcHB5OgorCQlpZiAoIXN0cnN0ciht LCAiQ0QtUk9NIikpIHsKKwkJCWlmICghc3Ryc3RyKG0sICJvcHB5IikgJiYKKwkJCSAgICAhc3Ry c3RyKG0sICJwb3lwIikgJiYKKwkJCSAgICAhc3Ryc3RyKG0sICJaSVAiKSkKKwkJCQlwcmludGso S0VSTl9DT05UICJjZHJvbSBvciBmbG9wcHk/LCBhc3N1bWluZyAiKTsKKwkJCWlmIChkcml2ZS0+ bWVkaWEgIT0gaWRlX2Nkcm9tKSB7CisJCQkJcHJpbnRrKEtFUk5fQ09OVCAiRkxPUFBZIik7CisJ CQkJZHJpdmUtPmRldl9mbGFncyB8PSBJREVfREZMQUdfUkVNT1ZBQkxFOworCQkJCWJyZWFrOwor CQkJfQorCQl9CisJCS8qIEVhcmx5IGNkcm9tIG1vZGVscyB1c2VkIHplcm8gKi8KKwkJdHlwZSA9 IGlkZV9jZHJvbTsKKwljYXNlIGlkZV9jZHJvbToKKwkJZHJpdmUtPmRldl9mbGFncyB8PSBJREVf REZMQUdfUkVNT1ZBQkxFOworI2lmZGVmIENPTkZJR19QUEMKKwkJLyoga2x1ZGdlIGZvciBBcHBs ZSBQb3dlckJvb2sgaW50ZXJuYWwgemlwICovCisJCWlmICghc3Ryc3RyKG0sICJDRC1ST00iKSAm JiBzdHJzdHIobSwgIlpJUCIpKSB7CisJCQlwcmludGsoS0VSTl9DT05UICJGTE9QUFkiKTsKKwkJ CXR5cGUgPSBpZGVfZmxvcHB5OworCQkJYnJlYWs7CisJCX0KKyNlbmRpZgorCQlwcmludGsoS0VS Tl9DT05UICJDRC9EVkQtUk9NIik7CisJCWJyZWFrOworCWNhc2UgaWRlX3RhcGU6CisJCXByaW50 ayhLRVJOX0NPTlQgIlRBUEUiKTsKKwkJYnJlYWs7CisJY2FzZSBpZGVfb3B0aWNhbDoKKwkJcHJp bnRrKEtFUk5fQ09OVCAiT1BUSUNBTCIpOworCQlkcml2ZS0+ZGV2X2ZsYWdzIHw9IElERV9ERkxB R19SRU1PVkFCTEU7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXByaW50ayhLRVJOX0NPTlQgIlVO S05PV04gKHR5cGUgJWQpIiwgdHlwZSk7CisJCWJyZWFrOworCX0KKworCXByaW50ayhLRVJOX0NP TlQgIiBkcml2ZVxuIik7CisJZHJpdmUtPm1lZGlhID0gdHlwZTsKKwkvKiBhbiBBVEFQSSBkZXZp Y2UgaWdub3JlcyBEUkRZICovCisJZHJpdmUtPnJlYWR5X3N0YXQgPSAwOworCWlmIChhdGFfaWRf Y2RiX2ludHIoaWQpKQorCQlkcml2ZS0+YXRhcGlfZmxhZ3MgfD0gSURFX0FGTEFHX0RSUV9JTlRF UlJVUFQ7CisJZHJpdmUtPmRldl9mbGFncyB8PSBJREVfREZMQUdfRE9PUkxPQ0tJTkc7CisJLyog d2UgZG9uJ3QgZG8gaGVhZCB1bmxvYWRpbmcgb24gQVRBUEkgZGV2aWNlcyAqLworCWRyaXZlLT5k ZXZfZmxhZ3MgfD0gSURFX0RGTEFHX05PX1VOTE9BRDsKK30KKwogLyoqCiAgKglkb19pZGVudGlm eQktCWlkZW50aWZ5IGEgZHJpdmUKICAqCUBkcml2ZTogZHJpdmUgdG8gaWRlbnRpZnkgCkBAIC0x MTcsNyArMTkzLDcgQEAgc3RhdGljIHZvaWQgZG9faWRlbnRpZnkoaWRlX2RyaXZlX3QgKmRyaXZl LCB1OCBjbWQpCiAJdTE2ICppZCA9IGRyaXZlLT5pZDsKIAljaGFyICptID0gKGNoYXIgKikmaWRb QVRBX0lEX1BST0RdOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0JaW50IGJzd2FwID0gMSwgaXNf Y2ZhOworCWludCBic3dhcCA9IDE7CiAKIAkvKiBsb2NhbCBDUFUgb25seTsgc29tZSBzeXN0ZW1z IG5lZWQgdGhpcyAqLwogCWxvY2FsX2lycV9zYXZlKGZsYWdzKTsKQEAgLTE1NCw5MSArMjMwLDIz IEBAIHN0YXRpYyB2b2lkIGRvX2lkZW50aWZ5KGlkZV9kcml2ZV90ICpkcml2ZSwgdTggY21kKQog CWlmIChzdHJzdHIobSwgIkUgWCBBIEIgWSBUIEUgTiBFIFMgVCIpKQogCQlnb3RvIGVycl9taXNj OwogCi0JcHJpbnRrKEtFUk5fSU5GTyAiJXM6ICVzLCAiLCBkcml2ZS0+bmFtZSwgbSk7Ci0KIAlk cml2ZS0+ZGV2X2ZsYWdzIHw9IElERV9ERkxBR19QUkVTRU5UOwogCWRyaXZlLT5kZXZfZmxhZ3Mg Jj0gfklERV9ERkxBR19ERUFEOwogCiAJLyoKIAkgKiBDaGVjayBmb3IgYW4gQVRBUEkgZGV2aWNl CiAJICovCi0JaWYgKGNtZCA9PSBBVEFfQ01EX0lEX0FUQVBJKSB7Ci0JCXU4IHR5cGUgPSAoaWRb QVRBX0lEX0NPTkZJR10gPj4gOCkgJiAweDFmOwotCi0JCXByaW50ayhLRVJOX0NPTlQgIkFUQVBJ ICIpOwotCQlzd2l0Y2ggKHR5cGUpIHsKLQkJCWNhc2UgaWRlX2Zsb3BweToKLQkJCQlpZiAoIXN0 cnN0cihtLCAiQ0QtUk9NIikpIHsKLQkJCQkJaWYgKCFzdHJzdHIobSwgIm9wcHkiKSAmJgotCQkJ CQkgICAgIXN0cnN0cihtLCAicG95cCIpICYmCi0JCQkJCSAgICAhc3Ryc3RyKG0sICJaSVAiKSkK LQkJCQkJCXByaW50ayhLRVJOX0NPTlQgImNkcm9tIG9yIGZsb3BweT8sIGFzc3VtaW5nICIpOwot CQkJCQlpZiAoZHJpdmUtPm1lZGlhICE9IGlkZV9jZHJvbSkgewotCQkJCQkJcHJpbnRrKEtFUk5f Q09OVCAiRkxPUFBZIik7Ci0JCQkJCQlkcml2ZS0+ZGV2X2ZsYWdzIHw9IElERV9ERkxBR19SRU1P VkFCTEU7Ci0JCQkJCQlicmVhazsKLQkJCQkJfQotCQkJCX0KLQkJCQkvKiBFYXJseSBjZHJvbSBt b2RlbHMgdXNlZCB6ZXJvICovCi0JCQkJdHlwZSA9IGlkZV9jZHJvbTsKLQkJCWNhc2UgaWRlX2Nk cm9tOgotCQkJCWRyaXZlLT5kZXZfZmxhZ3MgfD0gSURFX0RGTEFHX1JFTU9WQUJMRTsKLSNpZmRl ZiBDT05GSUdfUFBDCi0JCQkJLyoga2x1ZGdlIGZvciBBcHBsZSBQb3dlckJvb2sgaW50ZXJuYWwg emlwICovCi0JCQkJaWYgKCFzdHJzdHIobSwgIkNELVJPTSIpICYmIHN0cnN0cihtLCAiWklQIikp IHsKLQkJCQkJcHJpbnRrKEtFUk5fQ09OVCAiRkxPUFBZIik7Ci0JCQkJCXR5cGUgPSBpZGVfZmxv cHB5OwotCQkJCQlicmVhazsKLQkJCQl9Ci0jZW5kaWYKLQkJCQlwcmludGsoS0VSTl9DT05UICJD RC9EVkQtUk9NIik7Ci0JCQkJYnJlYWs7Ci0JCQljYXNlIGlkZV90YXBlOgotCQkJCXByaW50ayhL RVJOX0NPTlQgIlRBUEUiKTsKLQkJCQlicmVhazsKLQkJCWNhc2UgaWRlX29wdGljYWw6Ci0JCQkJ cHJpbnRrKEtFUk5fQ09OVCAiT1BUSUNBTCIpOwotCQkJCWRyaXZlLT5kZXZfZmxhZ3MgfD0gSURF X0RGTEFHX1JFTU9WQUJMRTsKLQkJCQlicmVhazsKLQkJCWRlZmF1bHQ6Ci0JCQkJcHJpbnRrKEtF Uk5fQ09OVCAiVU5LTk9XTiAodHlwZSAlZCkiLCB0eXBlKTsKLQkJCQlicmVhazsKLQkJfQotCQlw cmludGsoS0VSTl9DT05UICIgZHJpdmVcbiIpOwotCQlkcml2ZS0+bWVkaWEgPSB0eXBlOwotCQkv KiBhbiBBVEFQSSBkZXZpY2UgaWdub3JlcyBEUkRZICovCi0JCWRyaXZlLT5yZWFkeV9zdGF0ID0g MDsKLQkJaWYgKGF0YV9pZF9jZGJfaW50cihpZCkpCi0JCQlkcml2ZS0+YXRhcGlfZmxhZ3MgfD0g SURFX0FGTEFHX0RSUV9JTlRFUlJVUFQ7Ci0JCWRyaXZlLT5kZXZfZmxhZ3MgfD0gSURFX0RGTEFH X0RPT1JMT0NLSU5HOwotCQkvKiB3ZSBkb24ndCBkbyBoZWFkIHVubG9hZGluZyBvbiBBVEFQSSBk ZXZpY2VzICovCi0JCWRyaXZlLT5kZXZfZmxhZ3MgfD0gSURFX0RGTEFHX05PX1VOTE9BRDsKLQkJ cmV0dXJuOwotCX0KLQorCWlmIChjbWQgPT0gQVRBX0NNRF9JRF9BVEFQSSkKKwkJaWRlX2NsYXNz aWZ5X2F0YXBpX2Rldihkcml2ZSk7CisJZWxzZQogCS8qCiAJICogTm90IGFuIEFUQVBJIGRldmlj ZTogbG9va3MgbGlrZSBhICJyZWd1bGFyIiBoYXJkIGRpc2sKIAkgKi8KLQotCWlzX2NmYSA9IGF0 YV9pZF9pc19jZmEoaWQpOwotCi0JLyogQ0YgZGV2aWNlcyBhcmUgKm5vdCogcmVtb3ZhYmxlIGlu IExpbnV4IGRlZmluaXRpb24gb2YgdGhlIHRlcm0gKi8KLQlpZiAoaXNfY2ZhID09IDAgJiYgKGlk W0FUQV9JRF9DT05GSUddICYgKDEgPDwgNykpKQotCQlkcml2ZS0+ZGV2X2ZsYWdzIHw9IElERV9E RkxBR19SRU1PVkFCTEU7Ci0KLQlkcml2ZS0+bWVkaWEgPSBpZGVfZGlzazsKLQotCWlmICghYXRh X2lkX2hhc191bmxvYWQoZHJpdmUtPmlkKSkKLQkJZHJpdmUtPmRldl9mbGFncyB8PSBJREVfREZM QUdfTk9fVU5MT0FEOwotCi0JcHJpbnRrKEtFUk5fQ09OVCAiJXMgRElTSyBkcml2ZVxuIiwgaXNf Y2ZhID8gIkNGQSIgOiAiQVRBIik7Ci0KKwkJaWRlX2NsYXNzaWZ5X2F0YV9kZXYoZHJpdmUpOwog CXJldHVybjsKLQogZXJyX21pc2M6CiAJa2ZyZWUoaWQpOwogCWRyaXZlLT5kZXZfZmxhZ3MgJj0g fklERV9ERkxBR19QUkVTRU5UOwotCXJldHVybjsKIH0KIAogLyoqCkBAIC02NDEsMTQgKzY0OSw5 IEBAIHN0YXRpYyBpbnQgaWRlX3JlZ2lzdGVyX3BvcnQoaWRlX2h3aWZfdCAqaHdpZikKIAkvKiBy ZWdpc3RlciB3aXRoIGdsb2JhbCBkZXZpY2UgdHJlZSAqLwogCWRldl9zZXRfbmFtZSgmaHdpZi0+ Z2VuZGV2LCBod2lmLT5uYW1lKTsKIAlod2lmLT5nZW5kZXYuZHJpdmVyX2RhdGEgPSBod2lmOwot CWlmIChod2lmLT5nZW5kZXYucGFyZW50ID09IE5VTEwpIHsKLQkJaWYgKGh3aWYtPmRldikKLQkJ CWh3aWYtPmdlbmRldi5wYXJlbnQgPSBod2lmLT5kZXY7Ci0JCWVsc2UKLQkJCS8qIFdvdWxkIGxp a2UgdG8gZG8gPSAmZGV2aWNlX2xlZ2FjeSAqLwotCQkJaHdpZi0+Z2VuZGV2LnBhcmVudCA9IE5V TEw7Ci0JfQorCWh3aWYtPmdlbmRldi5wYXJlbnQgPSBod2lmLT5kZXY7CiAJaHdpZi0+Z2VuZGV2 LnJlbGVhc2UgPSBod2lmX3JlbGVhc2VfZGV2OworCiAJcmV0ID0gZGV2aWNlX3JlZ2lzdGVyKCZo d2lmLT5nZW5kZXYpOwogCWlmIChyZXQgPCAwKSB7CiAJCXByaW50ayhLRVJOX1dBUk5JTkcgIklE RTogJXM6IGRldmljZV9yZWdpc3RlciBlcnJvcjogJWRcbiIsCkBAIC04NzgsOCArODgxLDcgQEAg c3RhdGljIGludCBpZGVfaW5pdF9xdWV1ZShpZGVfZHJpdmVfdCAqZHJpdmUpCiAJICoJZG8gbm90 LgogCSAqLwogCi0JcSA9IGJsa19pbml0X3F1ZXVlX25vZGUoZG9faWRlX3JlcXVlc3QsICZod2lm LT5od2dyb3VwLT5sb2NrLAotCQkJCWh3aWZfdG9fbm9kZShod2lmKSk7CisJcSA9IGJsa19pbml0 X3F1ZXVlX25vZGUoZG9faWRlX3JlcXVlc3QsIE5VTEwsIGh3aWZfdG9fbm9kZShod2lmKSk7CiAJ aWYgKCFxKQogCQlyZXR1cm4gMTsKIApAQCAtMTEzOSw4ICsxMTQxLDYgQEAgc3RhdGljIHN0cnVj dCBrb2JqZWN0ICphdGFfcHJvYmUoZGV2X3QgZGV2LCBpbnQgKnBhcnQsIHZvaWQgKmRhdGEpCiAK IAlpZiAoZHJpdmUtPm1lZGlhID09IGlkZV9kaXNrKQogCQlyZXF1ZXN0X21vZHVsZSgiaWRlLWRp c2siKTsKLQlpZiAoZHJpdmUtPmRldl9mbGFncyAmIElERV9ERkxBR19TQ1NJKQotCQlyZXF1ZXN0 X21vZHVsZSgiaWRlLXNjc2kiKTsKIAlpZiAoZHJpdmUtPm1lZGlhID09IGlkZV9jZHJvbSB8fCBk cml2ZS0+bWVkaWEgPT0gaWRlX29wdGljYWwpCiAJCXJlcXVlc3RfbW9kdWxlKCJpZGUtY2QiKTsK IAlpZiAoZHJpdmUtPm1lZGlhID09IGlkZV90YXBlKQpAQCAtMTQxNyw1OCArMTQxNyw2IEBAIHN0 YXRpYyB2b2lkIGlkZV9wb3J0X2NhYmxlX2RldGVjdChpZGVfaHdpZl90ICpod2lmKQogCX0KIH0K IAotc3RhdGljIHNzaXplX3Qgc3RvcmVfZGVsZXRlX2RldmljZXMoc3RydWN0IGRldmljZSAqcG9y dGRldiwKLQkJCQkgICAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsCi0JCQkJICAgIGNv bnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IG4pCi17Ci0JaWRlX2h3aWZfdCAqaHdpZiA9IGRldl9nZXRf ZHJ2ZGF0YShwb3J0ZGV2KTsKLQotCWlmIChzdHJuY21wKGJ1ZiwgIjEiLCBuKSkKLQkJcmV0dXJu IC1FSU5WQUw7Ci0KLQlpZGVfcG9ydF91bnJlZ2lzdGVyX2RldmljZXMoaHdpZik7Ci0KLQlyZXR1 cm4gbjsKLX07Ci0KLXN0YXRpYyBERVZJQ0VfQVRUUihkZWxldGVfZGV2aWNlcywgU19JV1VTUiwg TlVMTCwgc3RvcmVfZGVsZXRlX2RldmljZXMpOwotCi1zdGF0aWMgc3NpemVfdCBzdG9yZV9zY2Fu KHN0cnVjdCBkZXZpY2UgKnBvcnRkZXYsCi0JCQkgIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICph dHRyLAotCQkJICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBuKQotewotCWlkZV9od2lmX3QgKmh3 aWYgPSBkZXZfZ2V0X2RydmRhdGEocG9ydGRldik7Ci0KLQlpZiAoc3RybmNtcChidWYsICIxIiwg bikpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JaWRlX3BvcnRfdW5yZWdpc3Rlcl9kZXZpY2VzKGh3 aWYpOwotCWlkZV9wb3J0X3NjYW4oaHdpZik7Ci0KLQlyZXR1cm4gbjsKLX07Ci0KLXN0YXRpYyBE RVZJQ0VfQVRUUihzY2FuLCBTX0lXVVNSLCBOVUxMLCBzdG9yZV9zY2FuKTsKLQotc3RhdGljIHN0 cnVjdCBkZXZpY2VfYXR0cmlidXRlICppZGVfcG9ydF9hdHRyc1tdID0gewotCSZkZXZfYXR0cl9k ZWxldGVfZGV2aWNlcywKLQkmZGV2X2F0dHJfc2NhbiwKLQlOVUxMCi19OwotCi1zdGF0aWMgaW50 IGlkZV9zeXNmc19yZWdpc3Rlcl9wb3J0KGlkZV9od2lmX3QgKmh3aWYpCi17Ci0JaW50IGksIHVu aW5pdGlhbGl6ZWRfdmFyKHJjKTsKLQotCWZvciAoaSA9IDA7IGlkZV9wb3J0X2F0dHJzW2ldOyBp KyspIHsKLQkJcmMgPSBkZXZpY2VfY3JlYXRlX2ZpbGUoaHdpZi0+cG9ydGRldiwgaWRlX3BvcnRf YXR0cnNbaV0pOwotCQlpZiAocmMpCi0JCQlicmVhazsKLQl9Ci0KLQlyZXR1cm4gcmM7Ci19Ci0K IHN0YXRpYyB1bnNpZ25lZCBpbnQgaWRlX2luZGV4ZXM7CiAKIC8qKgpAQCAtMTY1NSw5ICsxNjAz LDYgQEAgaW50IGlkZV9ob3N0X3JlZ2lzdGVyKHN0cnVjdCBpZGVfaG9zdCAqaG9zdCwgY29uc3Qg c3RydWN0IGlkZV9wb3J0X2luZm8gKmQsCiAJCWlmIChod2lmID09IE5VTEwpCiAJCQljb250aW51 ZTsKIAotCQlpZiAoaHdpZi0+Y2hpcHNldCA9PSBpZGVfdW5rbm93bikKLQkJCWh3aWYtPmNoaXBz ZXQgPSBpZGVfZ2VuZXJpYzsKLQogCQlpZiAoaHdpZi0+cHJlc2VudCkKIAkJCWh3aWZfcmVnaXN0 ZXJfZGV2aWNlcyhod2lmKTsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lkZS9pZGUtc3lzZnMu YyBiL2RyaXZlcnMvaWRlL2lkZS1zeXNmcy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAuLjg4M2ZmYWMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2lkZS9pZGUtc3lzZnMu YwpAQCAtMCwwICsxLDEyNSBAQAorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUg PGxpbnV4L2lkZS5oPgorCitjaGFyICppZGVfbWVkaWFfc3RyaW5nKGlkZV9kcml2ZV90ICpkcml2 ZSkKK3sKKwlzd2l0Y2ggKGRyaXZlLT5tZWRpYSkgeworCWNhc2UgaWRlX2Rpc2s6CisJCXJldHVy biAiZGlzayI7CisJY2FzZSBpZGVfY2Ryb206CisJCXJldHVybiAiY2Ryb20iOworCWNhc2UgaWRl X3RhcGU6CisJCXJldHVybiAidGFwZSI7CisJY2FzZSBpZGVfZmxvcHB5OgorCQlyZXR1cm4gImZs b3BweSI7CisJY2FzZSBpZGVfb3B0aWNhbDoKKwkJcmV0dXJuICJvcHRpY2FsIjsKKwlkZWZhdWx0 OgorCQlyZXR1cm4gIlVOS05PV04iOworCX0KK30KKworc3RhdGljIHNzaXplX3QgbWVkaWFfc2hv dyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAorCQkJ ICBjaGFyICpidWYpCit7CisJaWRlX2RyaXZlX3QgKmRyaXZlID0gdG9faWRlX2RldmljZShkZXYp OworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVzXG4iLCBpZGVfbWVkaWFfc3RyaW5nKGRyaXZlKSk7 Cit9CisKK3N0YXRpYyBzc2l6ZV90IGRyaXZlbmFtZV9zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwg c3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsCisJCQkgICAgICBjaGFyICpidWYpCit7CisJ aWRlX2RyaXZlX3QgKmRyaXZlID0gdG9faWRlX2RldmljZShkZXYpOworCXJldHVybiBzcHJpbnRm KGJ1ZiwgIiVzXG4iLCBkcml2ZS0+bmFtZSk7Cit9CisKK3N0YXRpYyBzc2l6ZV90IG1vZGFsaWFz X3Nob3coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwK KwkJCSAgICAgY2hhciAqYnVmKQoreworCWlkZV9kcml2ZV90ICpkcml2ZSA9IHRvX2lkZV9kZXZp Y2UoZGV2KTsKKwlyZXR1cm4gc3ByaW50ZihidWYsICJpZGU6bS0lc1xuIiwgaWRlX21lZGlhX3N0 cmluZyhkcml2ZSkpOworfQorCitzdGF0aWMgc3NpemVfdCBtb2RlbF9zaG93KHN0cnVjdCBkZXZp Y2UgKmRldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsCisJCQkgIGNoYXIgKmJ1ZikK K3sKKwlpZGVfZHJpdmVfdCAqZHJpdmUgPSB0b19pZGVfZGV2aWNlKGRldik7CisJcmV0dXJuIHNw cmludGYoYnVmLCAiJXNcbiIsIChjaGFyICopJmRyaXZlLT5pZFtBVEFfSURfUFJPRF0pOworfQor CitzdGF0aWMgc3NpemVfdCBmaXJtd2FyZV9zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0 IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsCisJCQkgICAgIGNoYXIgKmJ1ZikKK3sKKwlpZGVfZHJp dmVfdCAqZHJpdmUgPSB0b19pZGVfZGV2aWNlKGRldik7CisJcmV0dXJuIHNwcmludGYoYnVmLCAi JXNcbiIsIChjaGFyICopJmRyaXZlLT5pZFtBVEFfSURfRldfUkVWXSk7Cit9CisKK3N0YXRpYyBz c2l6ZV90IHNlcmlhbF9zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9hdHRy aWJ1dGUgKmF0dHIsCisJCQkgICBjaGFyICpidWYpCit7CisJaWRlX2RyaXZlX3QgKmRyaXZlID0g dG9faWRlX2RldmljZShkZXYpOworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVzXG4iLCAoY2hhciAq KSZkcml2ZS0+aWRbQVRBX0lEX1NFUk5PXSk7Cit9CisKK3N0cnVjdCBkZXZpY2VfYXR0cmlidXRl IGlkZV9kZXZfYXR0cnNbXSA9IHsKKwlfX0FUVFJfUk8obWVkaWEpLAorCV9fQVRUUl9STyhkcml2 ZW5hbWUpLAorCV9fQVRUUl9STyhtb2RhbGlhcyksCisJX19BVFRSX1JPKG1vZGVsKSwKKwlfX0FU VFJfUk8oZmlybXdhcmUpLAorCV9fQVRUUihzZXJpYWwsIDA0MDAsIHNlcmlhbF9zaG93LCBOVUxM KSwKKwlfX0FUVFIodW5sb2FkX2hlYWRzLCAwNjQ0LCBpZGVfcGFya19zaG93LCBpZGVfcGFya19z dG9yZSksCisJX19BVFRSX05VTEwKK307CisKK3N0YXRpYyBzc2l6ZV90IHN0b3JlX2RlbGV0ZV9k ZXZpY2VzKHN0cnVjdCBkZXZpY2UgKnBvcnRkZXYsCisJCQkJICAgIHN0cnVjdCBkZXZpY2VfYXR0 cmlidXRlICphdHRyLAorCQkJCSAgICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBuKQoreworCWlk ZV9od2lmX3QgKmh3aWYgPSBkZXZfZ2V0X2RydmRhdGEocG9ydGRldik7CisKKwlpZiAoc3RybmNt cChidWYsICIxIiwgbikpCisJCXJldHVybiAtRUlOVkFMOworCisJaWRlX3BvcnRfdW5yZWdpc3Rl cl9kZXZpY2VzKGh3aWYpOworCisJcmV0dXJuIG47Cit9OworCitzdGF0aWMgREVWSUNFX0FUVFIo ZGVsZXRlX2RldmljZXMsIFNfSVdVU1IsIE5VTEwsIHN0b3JlX2RlbGV0ZV9kZXZpY2VzKTsKKwor c3RhdGljIHNzaXplX3Qgc3RvcmVfc2NhbihzdHJ1Y3QgZGV2aWNlICpwb3J0ZGV2LAorCQkJICBz dHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKKwkJCSAgY29uc3QgY2hhciAqYnVmLCBzaXpl X3QgbikKK3sKKwlpZGVfaHdpZl90ICpod2lmID0gZGV2X2dldF9kcnZkYXRhKHBvcnRkZXYpOwor CisJaWYgKHN0cm5jbXAoYnVmLCAiMSIsIG4pKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWlkZV9w b3J0X3VucmVnaXN0ZXJfZGV2aWNlcyhod2lmKTsKKwlpZGVfcG9ydF9zY2FuKGh3aWYpOworCisJ cmV0dXJuIG47Cit9OworCitzdGF0aWMgREVWSUNFX0FUVFIoc2NhbiwgU19JV1VTUiwgTlVMTCwg c3RvcmVfc2Nhbik7CisKK3N0YXRpYyBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqaWRlX3BvcnRf YXR0cnNbXSA9IHsKKwkmZGV2X2F0dHJfZGVsZXRlX2RldmljZXMsCisJJmRldl9hdHRyX3NjYW4s CisJTlVMTAorfTsKKworaW50IGlkZV9zeXNmc19yZWdpc3Rlcl9wb3J0KGlkZV9od2lmX3QgKmh3 aWYpCit7CisJaW50IGksIHVuaW5pdGlhbGl6ZWRfdmFyKHJjKTsKKworCWZvciAoaSA9IDA7IGlk ZV9wb3J0X2F0dHJzW2ldOyBpKyspIHsKKwkJcmMgPSBkZXZpY2VfY3JlYXRlX2ZpbGUoaHdpZi0+ cG9ydGRldiwgaWRlX3BvcnRfYXR0cnNbaV0pOworCQlpZiAocmMpCisJCQlicmVhazsKKwl9CisK KwlyZXR1cm4gcmM7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lkZS9pZGUtdGFwZS5jIGIvZHJp dmVycy9pZGUvaWRlLXRhcGUuYwppbmRleCBhMmQ0NzBlLi41ZDJhYTIyIDEwMDY0NAotLS0gYS9k cml2ZXJzL2lkZS9pZGUtdGFwZS5jCisrKyBiL2RyaXZlcnMvaWRlL2lkZS10YXBlLmMKQEAgLTY5 NCw3ICs2OTQsNyBAQCBzdGF0aWMgaWRlX3N0YXJ0c3RvcF90IGlkZXRhcGVfaXNzdWVfcGMoaWRl X2RyaXZlX3QgKmRyaXZlLAogCiAJcGMtPnJldHJpZXMrKzsKIAotCXJldHVybiBpZGVfaXNzdWVf cGMoZHJpdmUsIFdBSVRfVEFQRV9DTUQsIE5VTEwpOworCXJldHVybiBpZGVfaXNzdWVfcGMoZHJp dmUpOwogfQogCiAvKiBBIG1vZGUgc2Vuc2UgY29tbWFuZCBpcyB1c2VkIHRvICJzZW5zZSIgdGFw ZSBwYXJhbWV0ZXJzLiAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pZGUvaWRlLmMgYi9kcml2ZXJz L2lkZS9pZGUuYwppbmRleCBmMGYwOWY3Li40NmEyZDRjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lk ZS9pZGUuYworKysgYi9kcml2ZXJzL2lkZS9pZGUuYwpAQCAtNDQwLDgxICs0NDAsMTMgQEAgc3Rh dGljIGludCBpZGVfYnVzX21hdGNoKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9k cml2ZXIgKmRydikKIAlyZXR1cm4gMTsKIH0KIAotc3RhdGljIGNoYXIgKm1lZGlhX3N0cmluZyhp ZGVfZHJpdmVfdCAqZHJpdmUpCi17Ci0Jc3dpdGNoIChkcml2ZS0+bWVkaWEpIHsKLQljYXNlIGlk ZV9kaXNrOgotCQlyZXR1cm4gImRpc2siOwotCWNhc2UgaWRlX2Nkcm9tOgotCQlyZXR1cm4gImNk cm9tIjsKLQljYXNlIGlkZV90YXBlOgotCQlyZXR1cm4gInRhcGUiOwotCWNhc2UgaWRlX2Zsb3Bw eToKLQkJcmV0dXJuICJmbG9wcHkiOwotCWNhc2UgaWRlX29wdGljYWw6Ci0JCXJldHVybiAib3B0 aWNhbCI7Ci0JZGVmYXVsdDoKLQkJcmV0dXJuICJVTktOT1dOIjsKLQl9Ci19Ci0KLXN0YXRpYyBz c2l6ZV90IG1lZGlhX3Nob3coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJp YnV0ZSAqYXR0ciwgY2hhciAqYnVmKQotewotCWlkZV9kcml2ZV90ICpkcml2ZSA9IHRvX2lkZV9k ZXZpY2UoZGV2KTsKLQlyZXR1cm4gc3ByaW50ZihidWYsICIlc1xuIiwgbWVkaWFfc3RyaW5nKGRy aXZlKSk7Ci19Ci0KLXN0YXRpYyBzc2l6ZV90IGRyaXZlbmFtZV9zaG93KHN0cnVjdCBkZXZpY2Ug KmRldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsIGNoYXIgKmJ1ZikKLXsKLQlpZGVf ZHJpdmVfdCAqZHJpdmUgPSB0b19pZGVfZGV2aWNlKGRldik7Ci0JcmV0dXJuIHNwcmludGYoYnVm LCAiJXNcbiIsIGRyaXZlLT5uYW1lKTsKLX0KLQotc3RhdGljIHNzaXplX3QgbW9kYWxpYXNfc2hv dyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFy ICpidWYpCi17Ci0JaWRlX2RyaXZlX3QgKmRyaXZlID0gdG9faWRlX2RldmljZShkZXYpOwotCXJl dHVybiBzcHJpbnRmKGJ1ZiwgImlkZTptLSVzXG4iLCBtZWRpYV9zdHJpbmcoZHJpdmUpKTsKLX0K LQotc3RhdGljIHNzaXplX3QgbW9kZWxfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBk ZXZpY2VfYXR0cmlidXRlICphdHRyLAotCQkJICBjaGFyICpidWYpCi17Ci0JaWRlX2RyaXZlX3Qg KmRyaXZlID0gdG9faWRlX2RldmljZShkZXYpOwotCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVzXG4i LCAoY2hhciAqKSZkcml2ZS0+aWRbQVRBX0lEX1BST0RdKTsKLX0KLQotc3RhdGljIHNzaXplX3Qg ZmlybXdhcmVfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRl ICphdHRyLAotCQkJICAgICBjaGFyICpidWYpCi17Ci0JaWRlX2RyaXZlX3QgKmRyaXZlID0gdG9f aWRlX2RldmljZShkZXYpOwotCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVzXG4iLCAoY2hhciAqKSZk cml2ZS0+aWRbQVRBX0lEX0ZXX1JFVl0pOwotfQotCi1zdGF0aWMgc3NpemVfdCBzZXJpYWxfc2hv dyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAotCQkJ ICAgY2hhciAqYnVmKQotewotCWlkZV9kcml2ZV90ICpkcml2ZSA9IHRvX2lkZV9kZXZpY2UoZGV2 KTsKLQlyZXR1cm4gc3ByaW50ZihidWYsICIlc1xuIiwgKGNoYXIgKikmZHJpdmUtPmlkW0FUQV9J RF9TRVJOT10pOwotfQotCi1zdGF0aWMgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgaWRlX2Rldl9h dHRyc1tdID0gewotCV9fQVRUUl9STyhtZWRpYSksCi0JX19BVFRSX1JPKGRyaXZlbmFtZSksCi0J X19BVFRSX1JPKG1vZGFsaWFzKSwKLQlfX0FUVFJfUk8obW9kZWwpLAotCV9fQVRUUl9STyhmaXJt d2FyZSksCi0JX19BVFRSKHNlcmlhbCwgMDQwMCwgc2VyaWFsX3Nob3csIE5VTEwpLAotCV9fQVRU Uih1bmxvYWRfaGVhZHMsIDA2NDQsIGlkZV9wYXJrX3Nob3csIGlkZV9wYXJrX3N0b3JlKSwKLQlf X0FUVFJfTlVMTAotfTsKLQogc3RhdGljIGludCBpZGVfdWV2ZW50KHN0cnVjdCBkZXZpY2UgKmRl diwgc3RydWN0IGtvYmpfdWV2ZW50X2VudiAqZW52KQogewogCWlkZV9kcml2ZV90ICpkcml2ZSA9 IHRvX2lkZV9kZXZpY2UoZGV2KTsKIAotCWFkZF91ZXZlbnRfdmFyKGVudiwgIk1FRElBPSVzIiwg bWVkaWFfc3RyaW5nKGRyaXZlKSk7CisJYWRkX3VldmVudF92YXIoZW52LCAiTUVESUE9JXMiLCBp ZGVfbWVkaWFfc3RyaW5nKGRyaXZlKSk7CiAJYWRkX3VldmVudF92YXIoZW52LCAiRFJJVkVOQU1F PSVzIiwgZHJpdmUtPm5hbWUpOwotCWFkZF91ZXZlbnRfdmFyKGVudiwgIk1PREFMSUFTPWlkZTpt LSVzIiwgbWVkaWFfc3RyaW5nKGRyaXZlKSk7CisJYWRkX3VldmVudF92YXIoZW52LCAiTU9EQUxJ QVM9aWRlOm0tJXMiLCBpZGVfbWVkaWFfc3RyaW5nKGRyaXZlKSk7CiAJcmV0dXJuIDA7CiB9CiAK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvaWRlL3R4NDkzOGlkZS5jIGIvZHJpdmVycy9pZGUvdHg0OTM4 aWRlLmMKaW5kZXggMTNiNjNlNy4uYjRlZjIxOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pZGUvdHg0 OTM4aWRlLmMKKysrIGIvZHJpdmVycy9pZGUvdHg0OTM4aWRlLmMKQEAgLTIxNiwxNiArMjE2LDE3 IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgaWRlX3RwX29wcyB0eDQ5MzhpZGVfdHBfb3BzID0gewog I2VuZGlmCS8qIF9fQklHX0VORElBTiAqLwogCiBzdGF0aWMgY29uc3Qgc3RydWN0IGlkZV9wb3J0 X29wcyB0eDQ5MzhpZGVfcG9ydF9vcHMgPSB7Ci0JLnNldF9waW9fbW9kZSA9IHR4NDkzOGlkZV9z ZXRfcGlvX21vZGUsCisJLnNldF9waW9fbW9kZQkJPSB0eDQ5MzhpZGVfc2V0X3Bpb19tb2RlLAog fTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBpZGVfcG9ydF9pbmZvIHR4NDkzOGlkZV9wb3J0X2lu Zm8gX19pbml0ZGF0YSA9IHsKLQkucG9ydF9vcHMgPSAmdHg0OTM4aWRlX3BvcnRfb3BzLAorCS5w b3J0X29wcwkJPSAmdHg0OTM4aWRlX3BvcnRfb3BzLAogI2lmZGVmIF9fQklHX0VORElBTgotCS50 cF9vcHMgPSAmdHg0OTM4aWRlX3RwX29wcywKKwkudHBfb3BzCQkJPSAmdHg0OTM4aWRlX3RwX29w cywKICNlbmRpZgotCS5ob3N0X2ZsYWdzID0gSURFX0hGTEFHX01NSU8gfCBJREVfSEZMQUdfTk9f RE1BLAotCS5waW9fbWFzayA9IEFUQV9QSU81LAorCS5ob3N0X2ZsYWdzCQk9IElERV9IRkxBR19N TUlPIHwgSURFX0hGTEFHX05PX0RNQSwKKwkucGlvX21hc2sJCT0gQVRBX1BJTzUsCisJLmNoaXBz ZXQJCT0gaWRlX2dlbmVyaWMsCiB9OwogCiBzdGF0aWMgaW50IF9faW5pdCB0eDQ5MzhpZGVfcHJv YmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaWRl L3R4NDkzOWlkZS5jIGIvZHJpdmVycy9pZGUvdHg0OTM5aWRlLmMKaW5kZXggOTdjZDllMC4uNGE4 YzVhMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pZGUvdHg0OTM5aWRlLmMKKysrIGIvZHJpdmVycy9p ZGUvdHg0OTM5aWRlLmMKQEAgLTYyMywzMyArNjIzLDM0IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3Qg aWRlX3RwX29wcyB0eDQ5MzlpZGVfdHBfb3BzID0gewogI2VuZGlmCS8qIF9fTElUVExFX0VORElB TiAqLwogCiBzdGF0aWMgY29uc3Qgc3RydWN0IGlkZV9wb3J0X29wcyB0eDQ5MzlpZGVfcG9ydF9v cHMgPSB7Ci0JLnNldF9waW9fbW9kZSA9IHR4NDkzOWlkZV9zZXRfcGlvX21vZGUsCi0JLnNldF9k bWFfbW9kZSA9IHR4NDkzOWlkZV9zZXRfZG1hX21vZGUsCi0JLmNsZWFyX2lycSA9IHR4NDkzOWlk ZV9jbGVhcl9pcnEsCi0JLmNhYmxlX2RldGVjdCA9IHR4NDkzOWlkZV9jYWJsZV9kZXRlY3QsCisJ LnNldF9waW9fbW9kZQkJPSB0eDQ5MzlpZGVfc2V0X3Bpb19tb2RlLAorCS5zZXRfZG1hX21vZGUJ CT0gdHg0OTM5aWRlX3NldF9kbWFfbW9kZSwKKwkuY2xlYXJfaXJxCQk9IHR4NDkzOWlkZV9jbGVh cl9pcnEsCisJLmNhYmxlX2RldGVjdAkJPSB0eDQ5MzlpZGVfY2FibGVfZGV0ZWN0LAogfTsKIAog c3RhdGljIGNvbnN0IHN0cnVjdCBpZGVfZG1hX29wcyB0eDQ5MzlpZGVfZG1hX29wcyA9IHsKLQku ZG1hX2hvc3Rfc2V0ID0gdHg0OTM5aWRlX2RtYV9ob3N0X3NldCwKLQkuZG1hX3NldHVwID0gdHg0 OTM5aWRlX2RtYV9zZXR1cCwKLQkuZG1hX2V4ZWNfY21kID0gaWRlX2RtYV9leGVjX2NtZCwKLQku ZG1hX3N0YXJ0ID0gaWRlX2RtYV9zdGFydCwKLQkuZG1hX2VuZCA9IHR4NDkzOWlkZV9kbWFfZW5k LAotCS5kbWFfdGVzdF9pcnEgPSB0eDQ5MzlpZGVfZG1hX3Rlc3RfaXJxLAotCS5kbWFfbG9zdF9p cnEgPSBpZGVfZG1hX2xvc3RfaXJxLAotCS5kbWFfdGltZW91dCA9IGlkZV9kbWFfdGltZW91dCwK KwkuZG1hX2hvc3Rfc2V0CQk9IHR4NDkzOWlkZV9kbWFfaG9zdF9zZXQsCisJLmRtYV9zZXR1cAkJ PSB0eDQ5MzlpZGVfZG1hX3NldHVwLAorCS5kbWFfZXhlY19jbWQJCT0gaWRlX2RtYV9leGVjX2Nt ZCwKKwkuZG1hX3N0YXJ0CQk9IGlkZV9kbWFfc3RhcnQsCisJLmRtYV9lbmQJCT0gdHg0OTM5aWRl X2RtYV9lbmQsCisJLmRtYV90ZXN0X2lycQkJPSB0eDQ5MzlpZGVfZG1hX3Rlc3RfaXJxLAorCS5k bWFfbG9zdF9pcnEJCT0gaWRlX2RtYV9sb3N0X2lycSwKKwkuZG1hX3RpbWVvdXQJCT0gaWRlX2Rt YV90aW1lb3V0LAogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBpZGVfcG9ydF9pbmZvIHR4NDkz OWlkZV9wb3J0X2luZm8gX19pbml0ZGF0YSA9IHsKLQkuaW5pdF9od2lmID0gdHg0OTM5aWRlX2lu aXRfaHdpZiwKLQkuaW5pdF9kbWEgPSB0eDQ5MzlpZGVfaW5pdF9kbWEsCi0JLnBvcnRfb3BzID0g JnR4NDkzOWlkZV9wb3J0X29wcywKLQkuZG1hX29wcyA9ICZ0eDQ5MzlpZGVfZG1hX29wcywKLQku dHBfb3BzID0gJnR4NDkzOWlkZV90cF9vcHMsCi0JLmhvc3RfZmxhZ3MgPSBJREVfSEZMQUdfTU1J TywKLQkucGlvX21hc2sgPSBBVEFfUElPNCwKLQkubXdkbWFfbWFzayA9IEFUQV9NV0RNQTIsCi0J LnVkbWFfbWFzayA9IEFUQV9VRE1BNSwKKwkuaW5pdF9od2lmCQk9IHR4NDkzOWlkZV9pbml0X2h3 aWYsCisJLmluaXRfZG1hCQk9IHR4NDkzOWlkZV9pbml0X2RtYSwKKwkucG9ydF9vcHMJCT0gJnR4 NDkzOWlkZV9wb3J0X29wcywKKwkuZG1hX29wcwkJPSAmdHg0OTM5aWRlX2RtYV9vcHMsCisJLnRw X29wcwkJCT0gJnR4NDkzOWlkZV90cF9vcHMsCisJLmhvc3RfZmxhZ3MJCT0gSURFX0hGTEFHX01N SU8sCisJLnBpb19tYXNrCQk9IEFUQV9QSU80LAorCS5td2RtYV9tYXNrCQk9IEFUQV9NV0RNQTIs CisJLnVkbWFfbWFzawkJPSBBVEFfVURNQTUsCisJLmNoaXBzZXQJCT0gaWRlX2dlbmVyaWMsCiB9 OwogCiBzdGF0aWMgaW50IF9faW5pdCB0eDQ5MzlpZGVfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2Rl dmljZSAqcGRldikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9LY29uZmlnIGIvZHJpdmVycy9z Y3NpL0tjb25maWcKaW5kZXggMTUyZDRhYS4uYjczMjI5NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9z Y3NpL0tjb25maWcKKysrIGIvZHJpdmVycy9zY3NpL0tjb25maWcKQEAgLTIxLDcgKzIxLDcgQEAg Y29uZmlnIFNDU0kKIAkgIFlvdSBhbHNvIG5lZWQgdG8gc2F5IFkgaGVyZSBpZiB5b3UgaGF2ZSBh IGRldmljZSB3aGljaCBzcGVha3MKIAkgIHRoZSBTQ1NJIHByb3RvY29sLiAgRXhhbXBsZXMgb2Yg dGhpcyBpbmNsdWRlIHRoZSBwYXJhbGxlbCBwb3J0CiAJICB2ZXJzaW9uIG9mIHRoZSBJT01FR0Eg WklQIGRyaXZlLCBVU0Igc3RvcmFnZSBkZXZpY2VzLCBGaWJyZQotCSAgQ2hhbm5lbCwgRmlyZVdp cmUgc3RvcmFnZSBhbmQgdGhlIElERS1TQ1NJIGVtdWxhdGlvbiBkcml2ZXIuCisJICBDaGFubmVs LCBhbmQgRmlyZVdpcmUgc3RvcmFnZS4KIAogCSAgVG8gY29tcGlsZSB0aGlzIGRyaXZlciBhcyBh IG1vZHVsZSwgY2hvb3NlIE0gaGVyZSBhbmQgcmVhZAogCSAgPGZpbGU6RG9jdW1lbnRhdGlvbi9z Y3NpL3Njc2kudHh0Pi4KQEAgLTEwMSw5ICsxMDEsOSBAQCBjb25maWcgQ0hSX0RFVl9PU1NUCiAJ LS0taGVscC0tLQogCSAgVGhlIE9uU3RyZWFtIFNDLXgwIFNDU0kgdGFwZSBkcml2ZXMgY2Fubm90 IGJlIGRyaXZlbiBieSB0aGUKIAkgIHN0YW5kYXJkIHN0IGRyaXZlciwgYnV0IGluc3RlYWQgbmVl ZCB0aGlzIHNwZWNpYWwgb3NzdCBkcml2ZXIgYW5kCi0JICB1c2UgdGhlICAvZGV2L29zc3RYIGNo YXIgZGV2aWNlIG5vZGVzIChtYWpvciAyMDYpLiAgVmlhIHVzYi1zdG9yYWdlCi0JICBhbmQgaWRl LXNjc2ksIHlvdSBtYXkgYmUgYWJsZSB0byBkcml2ZSB0aGUgVVNCLXgwIGFuZCBESS14MCBkcml2 ZXMKLQkgIGFzIHdlbGwuICBOb3RlIHRoYXQgdGhlcmUgaXMgYWxzbyBhIHNlY29uZCBnZW5lcmF0 aW9uIG9mIE9uU3RyZWFtCisJICB1c2UgdGhlICAvZGV2L29zc3RYIGNoYXIgZGV2aWNlIG5vZGVz IChtYWpvciAyMDYpLiAgVmlhIHVzYi1zdG9yYWdlLAorCSAgeW91IG1heSBiZSBhYmxlIHRvIGRy aXZlIHRoZSBVU0IteDAgYW5kIERJLXgwIGRyaXZlcyBhcyB3ZWxsLgorCSAgTm90ZSB0aGF0IHRo ZXJlIGlzIGFsc28gYSBzZWNvbmQgZ2VuZXJhdGlvbiBvZiBPblN0cmVhbQogCSAgdGFwZSBkcml2 ZXMgKEFEUi14MCkgdGhhdCBzdXBwb3J0cyB0aGUgc3RhbmRhcmQgU0NTSS0yIGNvbW1hbmRzIGZv cgogCSAgdGFwZXMgKFFJQy0xNTcpIGFuZCBjYW4gYmUgZHJpdmVuIGJ5IHRoZSBzdGFuZGFyZCBk cml2ZXIgc3QuCiAJICBGb3IgbW9yZSBpbmZvcm1hdGlvbiwgeW91IG1heSBoYXZlIGEgbG9vayBh dCB0aGUgU0NTSS1IT1dUTwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL01ha2VmaWxlIGIvZHJp dmVycy9zY3NpL01ha2VmaWxlCmluZGV4IDE0MTA2OTcuLjc0NjFlYjAgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvc2NzaS9NYWtlZmlsZQorKysgYi9kcml2ZXJzL3Njc2kvTWFrZWZpbGUKQEAgLTEwNSw3 ICsxMDUsNiBAQCBvYmotJChDT05GSUdfU0NTSV9HRFRIKQkJKz0gZ2R0aC5vCiBvYmotJChDT05G SUdfU0NTSV9JTklUSU8pCSs9IGluaXRpby5vCiBvYmotJChDT05GSUdfU0NTSV9JTklBMTAwKQkr PSBhMTAwdTJ3Lm8KIG9iai0kKENPTkZJR19TQ1NJX1FMT0dJQ1BUSSkJKz0gcWxvZ2ljcHRpLm8K LW9iai0kKENPTkZJR19CTEtfREVWX0lERVNDU0kpCSs9IGlkZS1zY3NpLm8KIG9iai0kKENPTkZJ R19TQ1NJX01FU0gpCQkrPSBtZXNoLm8KIG9iai0kKENPTkZJR19TQ1NJX01BQzUzQzk0KQkrPSBt YWM1M2M5NC5vCiBvYmotJChDT05GSUdfQkxLX0RFVl8zV19YWFhYX1JBSUQpICs9IDN3LXh4eHgu bwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2lkZS1zY3NpLmMgYi9kcml2ZXJzL3Njc2kvaWRl LXNjc2kuYwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYzI0MTQwYS4uMDAwMDAwMAot LS0gYS9kcml2ZXJzL3Njc2kvaWRlLXNjc2kuYworKysgL2Rldi9udWxsCkBAIC0xLDg0MCArMCww IEBACi0vKgotICogQ29weXJpZ2h0IChDKSAxOTk2LTE5OTkgIEdhZGkgT3htYW4gPGdhZGlvQG5l dHZpc2lvbi5uZXQuaWw+Ci0gKiBDb3B5cmlnaHQgKEMpIDIwMDQtMjAwNSAgQmFydGxvbWllaiBa b2xuaWVya2lld2ljegotICovCi0KLS8qCi0gKiBFbXVsYXRpb24gb2YgYSBTQ1NJIGhvc3QgYWRh cHRlciBmb3IgSURFIEFUQVBJIGRldmljZXMuCi0gKgotICogV2l0aCB0aGlzIGRyaXZlciwgb25l IGNhbiB1c2UgdGhlIExpbnV4IFNDU0kgZHJpdmVycyBpbnN0ZWFkIG9mIHRoZQotICogbmF0aXZl IElERSBBVEFQSSBkcml2ZXJzLgotICoKLSAqIFZlciAwLjEgICBEZWMgIDMgOTYgICBJbml0aWFs IHZlcnNpb24uCi0gKiBWZXIgMC4yICAgSmFuIDI2IDk3ICAgRml4ZWQgYnVnIGluIGNsZWFudXBf bW9kdWxlKCkgYW5kIGFkZGVkIGVtdWxhdGlvbgotICogICAgICAgICAgICAgICAgICAgICAgICBv ZiBNT0RFX1NFTlNFXzYvTU9ERV9TRUxFQ1RfNiBmb3IgY2Ryb21zLiBUaGFua3MKLSAqICAgICAg ICAgICAgICAgICAgICAgICAgdG8gSmFub3MgRmFya2FzIGZvciBwb2ludGluZyB0aGlzIG91dC4K LSAqICAgICAgICAgICAgICAgICAgICAgICBBdm9pZCB1c2luZyBiaXRmaWVsZHMgaW4gc3RydWN0 dXJlcyBmb3IgbTY4ay4KLSAqICAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBTY2F0dGVyL0dh dGhlciBhbmQgRE1BIHN1cHBvcnQuCi0gKiBWZXIgMC40ICAgRGVjICA3IDk3ICAgQWRkIHN1cHBv cnQgZm9yIEFUQVBJIFBEL0NEIGRyaXZlcy4KLSAqICAgICAgICAgICAgICAgICAgICAgICBVc2Ug dmFyaWFibGUgdGltZW91dCBmb3IgZWFjaCBjb21tYW5kLgotICogVmVyIDAuNSAgIEphbiAgMiA5 OCAgIEZpeCBwcmV2aW91cyBQRC9DRCBzdXBwb3J0LgotICogICAgICAgICAgICAgICAgICAgICAg IEFsbG93IGRpc2FibGluZyBvZiBTQ1NJLTYgdG8gU0NTSS0xMCB0cmFuc2Zvcm1hdGlvbi4KLSAq IFZlciAwLjYgICBKYW4gMjcgOTggICBBbGxvdyBkaXNhYmxpbmcgb2YgU0NTSSBjb21tYW5kIHRy YW5zbGF0aW9uIGxheWVyCi0gKiAgICAgICAgICAgICAgICAgICAgICAgIGZvciBhY2Nlc3MgdGhy b3VnaCAvZGV2L3NnLgotICogICAgICAgICAgICAgICAgICAgICAgIEZpeCBNT0RFX1NFTlNFXzYv TU9ERV9TRUxFQ1RfNi9JTlFVSVJZIHRyYW5zbGF0aW9uLgotICogVmVyIDAuNyAgIERlYyAwNCA5 OCAgIElnbm9yZSBjb21tYW5kcyB3aGVyZSBsdW4gIT0gMCB0byBhdm9pZCBtdWx0aXBsZQotICog ICAgICAgICAgICAgICAgICAgICAgICBkZXRlY3Rpb24gb2YgZGV2aWNlcyB3aXRoIENPTkZJR19T Q1NJX01VTFRJX0xVTgotICogVmVyIDAuOCAgIEZlYiAwNSA5OSAgIE9wdGljYWwgbWVkaWEgbmVl ZCB0cmFuc2xhdGlvbiB0b28uIFJldmVyc2UgMC43LgotICogVmVyIDAuOSAgIEp1bCAwNCA5OSAg IEZpeCBhIGJ1ZyBpbiBTR19TRVRfVFJBTlNGT1JNLgotICogVmVyIDAuOTEgIEp1biAxMCAwMiAg IEZpeCAib2ZmIGJ5IG9uZSIgZXJyb3IgaW4gdHJhbnNmb3JtcwotICogVmVyIDAuOTIgIERlYyAz MSAwMiAgIEltcGxlbWVudCBuZXcgU0NTSSBtaWQgbGV2ZWwgQVBJCi0gKi8KLQotI2RlZmluZSBJ REVTQ1NJX1ZFUlNJT04gIjAuOTIiCi0KLSNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KLSNpbmNs dWRlIDxsaW51eC90eXBlcy5oPgotI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgotI2luY2x1ZGUg PGxpbnV4L2tlcm5lbC5oPgotI2luY2x1ZGUgPGxpbnV4L21tLmg+Ci0jaW5jbHVkZSA8bGludXgv aW9wb3J0Lmg+Ci0jaW5jbHVkZSA8bGludXgvYmxrZGV2Lmg+Ci0jaW5jbHVkZSA8bGludXgvZXJy bm8uaD4KLSNpbmNsdWRlIDxsaW51eC9zbGFiLmg+Ci0jaW5jbHVkZSA8bGludXgvaWRlLmg+Ci0j aW5jbHVkZSA8bGludXgvc2NhdHRlcmxpc3QuaD4KLSNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgot I2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+Ci0jaW5jbHVkZSA8bGludXgvYml0b3BzLmg+Ci0KLSNp bmNsdWRlIDxhc20vaW8uaD4KLSNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgotCi0jaW5jbHVkZSA8 c2NzaS9zY3NpLmg+Ci0jaW5jbHVkZSA8c2NzaS9zY3NpX2NtbmQuaD4KLSNpbmNsdWRlIDxzY3Np L3Njc2lfZGV2aWNlLmg+Ci0jaW5jbHVkZSA8c2NzaS9zY3NpX2hvc3QuaD4KLSNpbmNsdWRlIDxz Y3NpL3Njc2lfdGNxLmg+Ci0jaW5jbHVkZSA8c2NzaS9zZy5oPgotCi0jZGVmaW5lIElERVNDU0lf REVCVUdfTE9HCQkwCi0KLSNpZiBJREVTQ1NJX0RFQlVHX0xPRwotI2RlZmluZSBkZWJ1Z19sb2co Zm10LCBhcmdzLi4uKSBcCi0JcHJpbnRrKEtFUk5fSU5GTyAiaWRlLXNjc2k6ICIgZm10LCAjIyBh cmdzKQotI2Vsc2UKLSNkZWZpbmUgZGVidWdfbG9nKGZtdCwgYXJncy4uLikgZG8ge30gd2hpbGUg KDApCi0jZW5kaWYKLQotLyoKLSAqCVNDU0kgY29tbWFuZCB0cmFuc2Zvcm1hdGlvbiBsYXllcgot ICovCi0jZGVmaW5lIElERVNDU0lfU0dfVFJBTlNGT1JNCQkxCS8qIC9kZXYvc2cgdHJhbnNmb3Jt YXRpb24gKi8KLQotLyoKLSAqCUxvZyBmbGFncwotICovCi0jZGVmaW5lIElERVNDU0lfTE9HX0NN RAkJCTAJLyogTG9nIFNDU0kgY29tbWFuZHMgKi8KLQotdHlwZWRlZiBzdHJ1Y3QgaWRlX3Njc2lf b2JqIHsKLQlpZGVfZHJpdmVfdAkJKmRyaXZlOwotCWlkZV9kcml2ZXJfdAkJKmRyaXZlcjsKLQlz dHJ1Y3QgZ2VuZGlzawkJKmRpc2s7Ci0Jc3RydWN0IFNjc2lfSG9zdAkqaG9zdDsKLQotCXVuc2ln bmVkIGxvbmcgdHJhbnNmb3JtOwkJLyogU0NTSSBjbWQgdHJhbnNsYXRpb24gbGF5ZXIgKi8KLQl1 bnNpZ25lZCBsb25nIGxvZzsJCQkvKiBsb2cgZmxhZ3MgKi8KLX0gaWRlc2NzaV9zY3NpX3Q7Ci0K LXN0YXRpYyBERUZJTkVfTVVURVgoaWRlc2NzaV9yZWZfbXV0ZXgpOwotLyogU2V0IGJ5IG1vZHVs ZSBwYXJhbSB0byBza2lwIGNkICovCi1zdGF0aWMgaW50IGlkZXNjc2lfbm9jZDsKLQotI2RlZmlu ZSBpZGVfc2NzaV9nKGRpc2spIFwKLQljb250YWluZXJfb2YoKGRpc2spLT5wcml2YXRlX2RhdGEs IHN0cnVjdCBpZGVfc2NzaV9vYmosIGRyaXZlcikKLQotc3RhdGljIHN0cnVjdCBpZGVfc2NzaV9v YmogKmlkZV9zY3NpX2dldChzdHJ1Y3QgZ2VuZGlzayAqZGlzaykKLXsKLQlzdHJ1Y3QgaWRlX3Nj c2lfb2JqICpzY3NpID0gTlVMTDsKLQotCW11dGV4X2xvY2soJmlkZXNjc2lfcmVmX211dGV4KTsK LQlzY3NpID0gaWRlX3Njc2lfZyhkaXNrKTsKLQlpZiAoc2NzaSkgewotCQlpZiAoaWRlX2Rldmlj ZV9nZXQoc2NzaS0+ZHJpdmUpKQotCQkJc2NzaSA9IE5VTEw7Ci0JCWVsc2UKLQkJCXNjc2lfaG9z dF9nZXQoc2NzaS0+aG9zdCk7Ci0JfQotCW11dGV4X3VubG9jaygmaWRlc2NzaV9yZWZfbXV0ZXgp OwotCXJldHVybiBzY3NpOwotfQotCi1zdGF0aWMgdm9pZCBpZGVfc2NzaV9wdXQoc3RydWN0IGlk ZV9zY3NpX29iaiAqc2NzaSkKLXsKLQlpZGVfZHJpdmVfdCAqZHJpdmUgPSBzY3NpLT5kcml2ZTsK LQotCW11dGV4X2xvY2soJmlkZXNjc2lfcmVmX211dGV4KTsKLQlzY3NpX2hvc3RfcHV0KHNjc2kt Pmhvc3QpOwotCWlkZV9kZXZpY2VfcHV0KGRyaXZlKTsKLQltdXRleF91bmxvY2soJmlkZXNjc2lf cmVmX211dGV4KTsKLX0KLQotc3RhdGljIGlubGluZSBpZGVzY3NpX3Njc2lfdCAqc2NzaWhvc3Rf dG9faWRlc2NzaShzdHJ1Y3QgU2NzaV9Ib3N0ICpob3N0KQotewotCXJldHVybiAoaWRlc2NzaV9z Y3NpX3QqKSAoJmhvc3RbMV0pOwotfQotCi1zdGF0aWMgaW5saW5lIGlkZXNjc2lfc2NzaV90ICpk cml2ZV90b19pZGVzY3NpKGlkZV9kcml2ZV90ICppZGVfZHJpdmUpCi17Ci0JcmV0dXJuIHNjc2lo b3N0X3RvX2lkZXNjc2koaWRlX2RyaXZlLT5kcml2ZXJfZGF0YSk7Ci19Ci0KLXN0YXRpYyB2b2lk IGlkZV9zY3NpX2hleF9kdW1wKHU4ICpkYXRhLCBpbnQgbGVuKQotewotCXByaW50X2hleF9kdW1w KEtFUk5fQ09OVCwgIiIsIERVTVBfUFJFRklYX05PTkUsIDE2LCAxLCBkYXRhLCBsZW4sIDApOwot fQotCi1zdGF0aWMgaW50IGlkZXNjc2lfZW5kX3JlcXVlc3QoaWRlX2RyaXZlX3QgKiwgaW50LCBp bnQpOwotCi1zdGF0aWMgdm9pZCBpZGVfc2NzaV9jYWxsYmFjayhpZGVfZHJpdmVfdCAqZHJpdmUs IGludCBkc2MpCi17Ci0JaWRlc2NzaV9zY3NpX3QgKnNjc2kgPSBkcml2ZV90b19pZGVzY3NpKGRy aXZlKTsKLQlzdHJ1Y3QgaWRlX2F0YXBpX3BjICpwYyA9IGRyaXZlLT5wYzsKLQotCWlmIChwYy0+ ZmxhZ3MgJiBQQ19GTEFHX1RJTUVET1VUKQotCQlkZWJ1Z19sb2coIiVzOiBnb3QgdGltZWQgb3V0 IHBhY2tldCAlbHUgYXQgJWx1XG4iLCBfX2Z1bmNfXywKLQkJCSAgcGMtPnNjc2lfY21kLT5zZXJp YWxfbnVtYmVyLCBqaWZmaWVzKTsKLQkJLyogZW5kIHRoaXMgcmVxdWVzdCBub3cgLSBzY3NpIHNo b3VsZCByZXRyeSBpdCovCi0JZWxzZSBpZiAodGVzdF9iaXQoSURFU0NTSV9MT0dfQ01ELCAmc2Nz aS0+bG9nKSkKLQkJcHJpbnRrKEtFUk5fSU5GTyAiUGFja2V0IGNvbW1hbmQgY29tcGxldGVkLCAl ZCBieXRlcyIKLQkJCQkgIiB0cmFuc2ZlcnJlZFxuIiwgcGMtPnhmZXJyZWQpOwotCi0JaWRlc2Nz aV9lbmRfcmVxdWVzdChkcml2ZSwgMSwgMCk7Ci19Ci0KLXN0YXRpYyBpbnQgaWRlc2NzaV9jaGVj a19jb25kaXRpb24oaWRlX2RyaXZlX3QgKmRyaXZlLAotCQlzdHJ1Y3QgcmVxdWVzdCAqZmFpbGVk X2NtZCkKLXsKLQlpZGVzY3NpX3Njc2lfdCAqc2NzaSA9IGRyaXZlX3RvX2lkZXNjc2koZHJpdmUp OwotCXN0cnVjdCBpZGVfYXRhcGlfcGMgICAqcGM7Ci0Jc3RydWN0IHJlcXVlc3QgKnJxOwotCXU4 ICAgICAgICAgICAgICpidWY7Ci0KLQkvKiBzdHVmZiBhIHNlbnNlIHJlcXVlc3QgaW4gZnJvbnQg b2Ygb3VyIGN1cnJlbnQgcmVxdWVzdCAqLwotCXBjID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGlk ZV9hdGFwaV9wYyksIEdGUF9BVE9NSUMpOwotCXJxID0gYmxrX2dldF9yZXF1ZXN0KGRyaXZlLT5x dWV1ZSwgUkVBRCwgR0ZQX0FUT01JQyk7Ci0JYnVmID0ga3phbGxvYyhTQ1NJX1NFTlNFX0JVRkZF UlNJWkUsIEdGUF9BVE9NSUMpOwotCWlmICghcGMgfHwgIXJxIHx8ICFidWYpIHsKLQkJa2ZyZWUo YnVmKTsKLQkJaWYgKHJxKQotCQkJYmxrX3B1dF9yZXF1ZXN0KHJxKTsKLQkJa2ZyZWUocGMpOwot CQlyZXR1cm4gLUVOT01FTTsKLQl9Ci0JcnEtPnNwZWNpYWwgPSAoY2hhciAqKSBwYzsKLQlwYy0+ cnEgPSBycTsKLQlwYy0+YnVmID0gYnVmOwotCXBjLT5jWzBdID0gUkVRVUVTVF9TRU5TRTsKLQlw Yy0+Y1s0XSA9IHBjLT5yZXFfeGZlciA9IHBjLT5idWZfc2l6ZSA9IFNDU0lfU0VOU0VfQlVGRkVS U0laRTsKLQlycS0+Y21kX3R5cGUgPSBSRVFfVFlQRV9TRU5TRTsKLQlycS0+Y21kX2ZsYWdzIHw9 IFJFUV9QUkVFTVBUOwotCXBjLT50aW1lb3V0ID0gamlmZmllcyArIFdBSVRfUkVBRFk7Ci0JLyog Tk9URSEgU2F2ZSB0aGUgZmFpbGVkIHBhY2tldCBjb21tYW5kIGluICJycS0+YnVmZmVyIiAqLwot CXJxLT5idWZmZXIgPSAodm9pZCAqKSBmYWlsZWRfY21kLT5zcGVjaWFsOwotCXBjLT5zY3NpX2Nt ZCA9ICgoc3RydWN0IGlkZV9hdGFwaV9wYyAqKSBmYWlsZWRfY21kLT5zcGVjaWFsKS0+c2NzaV9j bWQ7Ci0JaWYgKHRlc3RfYml0KElERVNDU0lfTE9HX0NNRCwgJnNjc2ktPmxvZykpIHsKLQkJcHJp bnRrICgiaWRlLXNjc2k6ICVzOiBxdWV1ZSBjbWQgPSAiLCBkcml2ZS0+bmFtZSk7Ci0JCWlkZV9z Y3NpX2hleF9kdW1wKHBjLT5jLCA2KTsKLQl9Ci0JcnEtPnJxX2Rpc2sgPSBzY3NpLT5kaXNrOwot CXJxLT5yZWZfY291bnQrKzsKLQltZW1jcHkocnEtPmNtZCwgcGMtPmMsIDEyKTsKLQlpZGVfZG9f ZHJpdmVfY21kKGRyaXZlLCBycSk7Ci0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyBpZGVfc3RhcnRz dG9wX3QKLWlkZXNjc2lfYXRhcGlfZXJyb3IoaWRlX2RyaXZlX3QgKmRyaXZlLCBzdHJ1Y3QgcmVx dWVzdCAqcnEsIHU4IHN0YXQsIHU4IGVycikKLXsKLQlpZGVfaHdpZl90ICpod2lmID0gZHJpdmUt Pmh3aWY7Ci0KLQlpZiAoaHdpZi0+dHBfb3BzLT5yZWFkX3N0YXR1cyhod2lmKSAmIChBVEFfQlVT WSB8IEFUQV9EUlEpKQotCQkvKiBmb3JjZSBhbiBhYm9ydCAqLwotCQlod2lmLT50cF9vcHMtPmV4 ZWNfY29tbWFuZChod2lmLCBBVEFfQ01EX0lETEVJTU1FRElBVEUpOwotCi0JcnEtPmVycm9ycysr OwotCi0JaWRlc2NzaV9lbmRfcmVxdWVzdChkcml2ZSwgMCwgMCk7Ci0KLQlyZXR1cm4gaWRlX3N0 b3BwZWQ7Ci19Ci0KLXN0YXRpYyBpbnQgaWRlc2NzaV9lbmRfcmVxdWVzdCAoaWRlX2RyaXZlX3Qg KmRyaXZlLCBpbnQgdXB0b2RhdGUsIGludCBucnNlY3MpCi17Ci0JaWRlc2NzaV9zY3NpX3QgKnNj c2kgPSBkcml2ZV90b19pZGVzY3NpKGRyaXZlKTsKLQlzdHJ1Y3QgcmVxdWVzdCAqcnEgPSBIV0dS T1VQKGRyaXZlKS0+cnE7Ci0Jc3RydWN0IGlkZV9hdGFwaV9wYyAqcGMgPSAoc3RydWN0IGlkZV9h dGFwaV9wYyAqKSBycS0+c3BlY2lhbDsKLQlpbnQgbG9nID0gdGVzdF9iaXQoSURFU0NTSV9MT0df Q01ELCAmc2NzaS0+bG9nKTsKLQlzdHJ1Y3QgU2NzaV9Ib3N0ICpob3N0OwotCWludCBlcnJvcnMg PSBycS0+ZXJyb3JzOwotCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0KLQlpZiAoIWJsa19zcGVjaWFs X3JlcXVlc3QocnEpICYmICFibGtfc2Vuc2VfcmVxdWVzdChycSkpIHsKLQkJaWRlX2VuZF9yZXF1 ZXN0KGRyaXZlLCB1cHRvZGF0ZSwgbnJzZWNzKTsKLQkJcmV0dXJuIDA7Ci0JfQotCWlkZV9lbmRf ZHJpdmVfY21kIChkcml2ZSwgMCwgMCk7Ci0JaWYgKGJsa19zZW5zZV9yZXF1ZXN0KHJxKSkgewot CQlzdHJ1Y3QgaWRlX2F0YXBpX3BjICpvcGMgPSAoc3RydWN0IGlkZV9hdGFwaV9wYyAqKSBycS0+ YnVmZmVyOwotCQlpZiAobG9nKSB7Ci0JCQlwcmludGsgKCJpZGUtc2NzaTogJXM6IHdyYXAgdXAg Y2hlY2sgJWx1LCByc3QgPSAiLCBkcml2ZS0+bmFtZSwgb3BjLT5zY3NpX2NtZC0+c2VyaWFsX251 bWJlcik7Ci0JCQlpZGVfc2NzaV9oZXhfZHVtcChwYy0+YnVmLCAxNik7Ci0JCX0KLQkJbWVtY3B5 KCh2b2lkICopIG9wYy0+c2NzaV9jbWQtPnNlbnNlX2J1ZmZlciwgcGMtPmJ1ZiwKLQkJCVNDU0lf U0VOU0VfQlVGRkVSU0laRSk7Ci0JCWtmcmVlKHBjLT5idWYpOwotCQlrZnJlZShwYyk7Ci0JCWJs a19wdXRfcmVxdWVzdChycSk7Ci0JCXBjID0gb3BjOwotCQlycSA9IHBjLT5ycTsKLQkJcGMtPnNj c2lfY21kLT5yZXN1bHQgPSAoQ0hFQ0tfQ09ORElUSU9OIDw8IDEpIHwKLQkJCQkoKChwYy0+Zmxh Z3MgJiBQQ19GTEFHX1RJTUVET1VUKSA/Ci0JCQkJICBESURfVElNRV9PVVQgOgotCQkJCSAgRElE X09LKSA8PCAxNik7Ci0JfSBlbHNlIGlmIChwYy0+ZmxhZ3MgJiBQQ19GTEFHX1RJTUVET1VUKSB7 Ci0JCWlmIChsb2cpCi0JCQlwcmludGsgKEtFUk5fV0FSTklORyAiaWRlLXNjc2k6ICVzOiB0aW1l ZCBvdXQgZm9yICVsdVxuIiwKLQkJCQkJZHJpdmUtPm5hbWUsIHBjLT5zY3NpX2NtZC0+c2VyaWFs X251bWJlcik7Ci0JCXBjLT5zY3NpX2NtZC0+cmVzdWx0ID0gRElEX1RJTUVfT1VUIDw8IDE2Owot CX0gZWxzZSBpZiAoZXJyb3JzID49IEVSUk9SX01BWCkgewotCQlwYy0+c2NzaV9jbWQtPnJlc3Vs dCA9IERJRF9FUlJPUiA8PCAxNjsKLQkJaWYgKGxvZykKLQkJCXByaW50ayAoImlkZS1zY3NpOiAl czogSS9PIGVycm9yIGZvciAlbHVcbiIsIGRyaXZlLT5uYW1lLCBwYy0+c2NzaV9jbWQtPnNlcmlh bF9udW1iZXIpOwotCX0gZWxzZSBpZiAoZXJyb3JzKSB7Ci0JCWlmIChsb2cpCi0JCQlwcmludGsg KCJpZGUtc2NzaTogJXM6IGNoZWNrIGNvbmRpdGlvbiBmb3IgJWx1XG4iLCBkcml2ZS0+bmFtZSwg cGMtPnNjc2lfY21kLT5zZXJpYWxfbnVtYmVyKTsKLQkJaWYgKCFpZGVzY3NpX2NoZWNrX2NvbmRp dGlvbihkcml2ZSwgcnEpKQotCQkJLyogd2Ugc3RhcnRlZCBhIHJlcXVlc3Qgc2Vuc2UsIHNvIHdl J2xsIGJlIGJhY2ssIGV4aXQgZm9yIG5vdyAqLwotCQkJcmV0dXJuIDA7Ci0JCXBjLT5zY3NpX2Nt ZC0+cmVzdWx0ID0gKENIRUNLX0NPTkRJVElPTiA8PCAxKSB8IChESURfT0sgPDwgMTYpOwotCX0g ZWxzZSB7Ci0JCXBjLT5zY3NpX2NtZC0+cmVzdWx0ID0gRElEX09LIDw8IDE2OwotCX0KLQlob3N0 ID0gcGMtPnNjc2lfY21kLT5kZXZpY2UtPmhvc3Q7Ci0Jc3Bpbl9sb2NrX2lycXNhdmUoaG9zdC0+ aG9zdF9sb2NrLCBmbGFncyk7Ci0JcGMtPmRvbmUocGMtPnNjc2lfY21kKTsKLQlzcGluX3VubG9j a19pcnFyZXN0b3JlKGhvc3QtPmhvc3RfbG9jaywgZmxhZ3MpOwotCWtmcmVlKHBjKTsKLQlibGtf cHV0X3JlcXVlc3QocnEpOwotCWRyaXZlLT5wYyA9IE5VTEw7Ci0JcmV0dXJuIDA7Ci19Ci0KLXN0 YXRpYyBpbmxpbmUgaW50IGlkZXNjc2lfc2V0X2RpcmVjdGlvbihzdHJ1Y3QgaWRlX2F0YXBpX3Bj ICpwYykKLXsKLQlzd2l0Y2ggKHBjLT5jWzBdKSB7Ci0JCWNhc2UgUkVBRF82OiBjYXNlIFJFQURf MTA6IGNhc2UgUkVBRF8xMjoKLQkJCXBjLT5mbGFncyAmPSB+UENfRkxBR19XUklUSU5HOwotCQkJ cmV0dXJuIDA7Ci0JCWNhc2UgV1JJVEVfNjogY2FzZSBXUklURV8xMDogY2FzZSBXUklURV8xMjoK LQkJCXBjLT5mbGFncyB8PSBQQ19GTEFHX1dSSVRJTkc7Ci0JCQlyZXR1cm4gMDsKLQkJZGVmYXVs dDoKLQkJCXJldHVybiAxOwotCX0KLX0KLQotc3RhdGljIGludCBpZGVzY3NpX21hcF9zZyhpZGVf ZHJpdmVfdCAqZHJpdmUsIHN0cnVjdCBpZGVfYXRhcGlfcGMgKnBjKQotewotCWlkZV9od2lmX3Qg Kmh3aWYgPSBkcml2ZS0+aHdpZjsKLQlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLCAqc2NzaV9zZzsK LQlpbnQgc2VnbWVudHM7Ci0KLQlpZiAoIXBjLT5yZXFfeGZlciB8fCBwYy0+cmVxX3hmZXIgJSAx MDI0KQotCQlyZXR1cm4gMTsKLQotCWlmIChpZGVzY3NpX3NldF9kaXJlY3Rpb24ocGMpKQotCQly ZXR1cm4gMTsKLQotCXNnID0gaHdpZi0+c2dfdGFibGU7Ci0Jc2NzaV9zZyA9IHNjc2lfc2dsaXN0 KHBjLT5zY3NpX2NtZCk7Ci0Jc2VnbWVudHMgPSBzY3NpX3NnX2NvdW50KHBjLT5zY3NpX2NtZCk7 Ci0KLQlpZiAoc2VnbWVudHMgPiBod2lmLT5zZ19tYXhfbmVudHMpCi0JCXJldHVybiAxOwotCi0J aHdpZi0+c2dfbmVudHMgPSBzZWdtZW50czsKLQltZW1jcHkoc2csIHNjc2lfc2csIHNpemVvZigq c2cpICogc2VnbWVudHMpOwotCi0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyBpZGVfc3RhcnRzdG9w X3QgaWRlc2NzaV9pc3N1ZV9wYyhpZGVfZHJpdmVfdCAqZHJpdmUsCi0JCXN0cnVjdCBpZGVfYXRh cGlfcGMgKnBjKQotewotCS8qIFNldCB0aGUgY3VycmVudCBwYWNrZXQgY29tbWFuZCAqLwotCWRy aXZlLT5wYyA9IHBjOwotCi0JcmV0dXJuIGlkZV9pc3N1ZV9wYyhkcml2ZSwgaWRlX3Njc2lfZ2V0 X3RpbWVvdXQocGMpLCBpZGVfc2NzaV9leHBpcnkpOwotfQotCi0vKgotICoJaWRlc2NzaV9kb19y ZXF1ZXN0IGlzIG91ciByZXF1ZXN0IGhhbmRsaW5nIGZ1bmN0aW9uLgotICovCi1zdGF0aWMgaWRl X3N0YXJ0c3RvcF90IGlkZXNjc2lfZG9fcmVxdWVzdCAoaWRlX2RyaXZlX3QgKmRyaXZlLCBzdHJ1 Y3QgcmVxdWVzdCAqcnEsIHNlY3Rvcl90IGJsb2NrKQotewotCWRlYnVnX2xvZygiZGV2OiAlcywg Y21kOiAleCwgZXJyb3JzOiAlZFxuIiwgcnEtPnJxX2Rpc2stPmRpc2tfbmFtZSwKLQkJICBycS0+ Y21kWzBdLCBycS0+ZXJyb3JzKTsKLQlkZWJ1Z19sb2coInNlY3RvcjogJWxkLCBucl9zZWN0b3Jz OiAlbGQsIGN1cnJlbnRfbnJfc2VjdG9yczogJWRcbiIsCi0JCSAgcnEtPnNlY3RvciwgcnEtPm5y X3NlY3RvcnMsIHJxLT5jdXJyZW50X25yX3NlY3RvcnMpOwotCi0JaWYgKGJsa19zZW5zZV9yZXF1 ZXN0KHJxKSB8fCBibGtfc3BlY2lhbF9yZXF1ZXN0KHJxKSkgewotCQlzdHJ1Y3QgaWRlX2F0YXBp X3BjICpwYyA9IChzdHJ1Y3QgaWRlX2F0YXBpX3BjICopcnEtPnNwZWNpYWw7Ci0KLQkJaWYgKChk cml2ZS0+ZGV2X2ZsYWdzICYgSURFX0RGTEFHX1VTSU5HX0RNQSkgJiYKLQkJICAgIGlkZXNjc2lf bWFwX3NnKGRyaXZlLCBwYykgPT0gMCkKLQkJCXBjLT5mbGFncyB8PSBQQ19GTEFHX0RNQV9PSzsK LQotCQlyZXR1cm4gaWRlc2NzaV9pc3N1ZV9wYyhkcml2ZSwgcGMpOwotCX0KLQlibGtfZHVtcF9y cV9mbGFncyhycSwgImlkZS1zY3NpOiB1bnN1cCBjb21tYW5kIik7Ci0JaWRlc2NzaV9lbmRfcmVx dWVzdCAoZHJpdmUsIDAsIDApOwotCXJldHVybiBpZGVfc3RvcHBlZDsKLX0KLQotI2lmZGVmIENP TkZJR19JREVfUFJPQ19GUwotc3RhdGljIGlkZV9wcm9jX2VudHJ5X3QgaWRlc2NzaV9wcm9jW10g PSB7Ci0JeyAiY2FwYWNpdHkiLCBTX0lGUkVHfFNfSVJVR08sIHByb2NfaWRlX3JlYWRfY2FwYWNp dHksIE5VTEwgfSwKLQl7IE5VTEwsIDAsIE5VTEwsIE5VTEwgfQotfTsKLQotI2RlZmluZSBpZGVf c2NzaV9kZXZzZXRfZ2V0KG5hbWUsIGZpZWxkKSBcCi1zdGF0aWMgaW50IGdldF8jI25hbWUoaWRl X2RyaXZlX3QgKmRyaXZlKSBcCi17IFwKLQlpZGVzY3NpX3Njc2lfdCAqc2NzaSA9IGRyaXZlX3Rv X2lkZXNjc2koZHJpdmUpOyBcCi0JcmV0dXJuIHNjc2ktPmZpZWxkOyBcCi19Ci0KLSNkZWZpbmUg aWRlX3Njc2lfZGV2c2V0X3NldChuYW1lLCBmaWVsZCkgXAotc3RhdGljIGludCBzZXRfIyNuYW1l KGlkZV9kcml2ZV90ICpkcml2ZSwgaW50IGFyZykgXAoteyBcCi0JaWRlc2NzaV9zY3NpX3QgKnNj c2kgPSBkcml2ZV90b19pZGVzY3NpKGRyaXZlKTsgXAotCXNjc2ktPmZpZWxkID0gYXJnOyBcCi0J cmV0dXJuIDA7IFwKLX0KLQotI2RlZmluZSBpZGVfc2NzaV9kZXZzZXRfcndfZmllbGQoX25hbWUs IF9maWVsZCkgXAotaWRlX3Njc2lfZGV2c2V0X2dldChfbmFtZSwgX2ZpZWxkKTsgXAotaWRlX3Nj c2lfZGV2c2V0X3NldChfbmFtZSwgX2ZpZWxkKTsgXAotSURFX0RFVlNFVChfbmFtZSwgRFNfU1lO QywgZ2V0XyMjX25hbWUsIHNldF8jI19uYW1lKTsKLQotaWRlX2RldnNldF9yd19maWVsZChiaW9z X2N5bCwgYmlvc19jeWwpOwotaWRlX2RldnNldF9yd19maWVsZChiaW9zX2hlYWQsIGJpb3NfaGVh ZCk7Ci1pZGVfZGV2c2V0X3J3X2ZpZWxkKGJpb3Nfc2VjdCwgYmlvc19zZWN0KTsKLQotaWRlX3Nj c2lfZGV2c2V0X3J3X2ZpZWxkKHRyYW5zZm9ybSwgdHJhbnNmb3JtKTsKLWlkZV9zY3NpX2RldnNl dF9yd19maWVsZChsb2csIGxvZyk7Ci0KLXN0YXRpYyBjb25zdCBzdHJ1Y3QgaWRlX3Byb2NfZGV2 c2V0IGlkZXNjc2lfc2V0dGluZ3NbXSA9IHsKLQlJREVfUFJPQ19ERVZTRVQoYmlvc19jeWwsICAw LCAxMDIzKSwKLQlJREVfUFJPQ19ERVZTRVQoYmlvc19oZWFkLCAwLCAgMjU1KSwKLQlJREVfUFJP Q19ERVZTRVQoYmlvc19zZWN0LCAwLAk2MyksCi0JSURFX1BST0NfREVWU0VUKGxvZywJICAgMCwJ IDEpLAotCUlERV9QUk9DX0RFVlNFVCh0cmFuc2Zvcm0sIDAsCSAzKSwKLQl7IDAgfSwKLX07Ci0K LXN0YXRpYyBpZGVfcHJvY19lbnRyeV90ICppZGVfc2NzaV9wcm9jX2VudHJpZXMoaWRlX2RyaXZl X3QgKmRyaXZlKQotewotCXJldHVybiBpZGVzY3NpX3Byb2M7Ci19Ci0KLXN0YXRpYyBjb25zdCBz dHJ1Y3QgaWRlX3Byb2NfZGV2c2V0ICppZGVfc2NzaV9wcm9jX2RldnNldHMoaWRlX2RyaXZlX3Qg KmRyaXZlKQotewotCXJldHVybiBpZGVzY3NpX3NldHRpbmdzOwotfQotI2VuZGlmCi0KLS8qCi0g KglEcml2ZXIgaW5pdGlhbGl6YXRpb24uCi0gKi8KLXN0YXRpYyB2b2lkIGlkZXNjc2lfc2V0dXAg KGlkZV9kcml2ZV90ICpkcml2ZSwgaWRlc2NzaV9zY3NpX3QgKnNjc2kpCi17Ci0JY2xlYXJfYml0 KElERVNDU0lfU0dfVFJBTlNGT1JNLCAmc2NzaS0+dHJhbnNmb3JtKTsKLSNpZiBJREVTQ1NJX0RF QlVHX0xPRwotCXNldF9iaXQoSURFU0NTSV9MT0dfQ01ELCAmc2NzaS0+bG9nKTsKLSNlbmRpZiAv KiBJREVTQ1NJX0RFQlVHX0xPRyAqLwotCi0JZHJpdmUtPnBjX2NhbGxiYWNrCSA9IGlkZV9zY3Np X2NhbGxiYWNrOwotCWRyaXZlLT5wY191cGRhdGVfYnVmZmVycyA9IE5VTEw7Ci0JZHJpdmUtPnBj X2lvX2J1ZmZlcnMJID0gaWRlX2lvX2J1ZmZlcnM7Ci0KLQlpZGVfcHJvY19yZWdpc3Rlcl9kcml2 ZXIoZHJpdmUsIHNjc2ktPmRyaXZlcik7Ci19Ci0KLXN0YXRpYyB2b2lkIGlkZV9zY3NpX3JlbW92 ZShpZGVfZHJpdmVfdCAqZHJpdmUpCi17Ci0Jc3RydWN0IFNjc2lfSG9zdCAqc2NzaWhvc3QgPSBk cml2ZS0+ZHJpdmVyX2RhdGE7Ci0Jc3RydWN0IGlkZV9zY3NpX29iaiAqc2NzaSA9IHNjc2lob3N0 X3RvX2lkZXNjc2koc2NzaWhvc3QpOwotCXN0cnVjdCBnZW5kaXNrICpnID0gc2NzaS0+ZGlzazsK LQotCXNjc2lfcmVtb3ZlX2hvc3Qoc2NzaWhvc3QpOwotCWlkZV9wcm9jX3VucmVnaXN0ZXJfZHJp dmVyKGRyaXZlLCBzY3NpLT5kcml2ZXIpOwotCi0JaWRlX3VucmVnaXN0ZXJfcmVnaW9uKGcpOwot Ci0JZHJpdmUtPmRyaXZlcl9kYXRhID0gTlVMTDsKLQlnLT5wcml2YXRlX2RhdGEgPSBOVUxMOwot CXB1dF9kaXNrKGcpOwotCi0JaWRlX3Njc2lfcHV0KHNjc2kpOwotCi0JZHJpdmUtPmRldl9mbGFn cyAmPSB+SURFX0RGTEFHX1NDU0k7Ci19Ci0KLXN0YXRpYyBpbnQgaWRlX3Njc2lfcHJvYmUoaWRl X2RyaXZlX3QgKik7Ci0KLXN0YXRpYyBpZGVfZHJpdmVyX3QgaWRlc2NzaV9kcml2ZXIgPSB7Ci0J Lmdlbl9kcml2ZXIgPSB7Ci0JCS5vd25lcgkJPSBUSElTX01PRFVMRSwKLQkJLm5hbWUJCT0gImlk ZS1zY3NpIiwKLQkJLmJ1cwkJPSAmaWRlX2J1c190eXBlLAotCX0sCi0JLnByb2JlCQkJPSBpZGVf c2NzaV9wcm9iZSwKLQkucmVtb3ZlCQkJPSBpZGVfc2NzaV9yZW1vdmUsCi0JLnZlcnNpb24JCT0g SURFU0NTSV9WRVJTSU9OLAotCS5kb19yZXF1ZXN0CQk9IGlkZXNjc2lfZG9fcmVxdWVzdCwKLQku ZW5kX3JlcXVlc3QJCT0gaWRlc2NzaV9lbmRfcmVxdWVzdCwKLQkuZXJyb3IgICAgICAgICAgICAg ICAgICA9IGlkZXNjc2lfYXRhcGlfZXJyb3IsCi0jaWZkZWYgQ09ORklHX0lERV9QUk9DX0ZTCi0J LnByb2NfZW50cmllcwkJPSBpZGVfc2NzaV9wcm9jX2VudHJpZXMsCi0JLnByb2NfZGV2c2V0cwkJ PSBpZGVfc2NzaV9wcm9jX2RldnNldHMsCi0jZW5kaWYKLX07Ci0KLXN0YXRpYyBpbnQgaWRlc2Nz aV9pZGVfb3BlbihzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2LCBmbW9kZV90IG1vZGUpCi17Ci0J c3RydWN0IGlkZV9zY3NpX29iaiAqc2NzaSA9IGlkZV9zY3NpX2dldChiZGV2LT5iZF9kaXNrKTsK LQotCWlmICghc2NzaSkKLQkJcmV0dXJuIC1FTlhJTzsKLQotCXJldHVybiAwOwotfQotCi1zdGF0 aWMgaW50IGlkZXNjc2lfaWRlX3JlbGVhc2Uoc3RydWN0IGdlbmRpc2sgKmRpc2ssIGZtb2RlX3Qg bW9kZSkKLXsKLQlpZGVfc2NzaV9wdXQoaWRlX3Njc2lfZyhkaXNrKSk7Ci0JcmV0dXJuIDA7Ci19 Ci0KLXN0YXRpYyBpbnQgaWRlc2NzaV9pZGVfaW9jdGwoc3RydWN0IGJsb2NrX2RldmljZSAqYmRl diwgZm1vZGVfdCBtb2RlLAotCQkJdW5zaWduZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBhcmcp Ci17Ci0Jc3RydWN0IGlkZV9zY3NpX29iaiAqc2NzaSA9IGlkZV9zY3NpX2coYmRldi0+YmRfZGlz ayk7Ci0JcmV0dXJuIGdlbmVyaWNfaWRlX2lvY3RsKHNjc2ktPmRyaXZlLCBiZGV2LCBjbWQsIGFy Zyk7Ci19Ci0KLXN0YXRpYyBzdHJ1Y3QgYmxvY2tfZGV2aWNlX29wZXJhdGlvbnMgaWRlc2NzaV9v cHMgPSB7Ci0JLm93bmVyCQk9IFRISVNfTU9EVUxFLAotCS5vcGVuCQk9IGlkZXNjc2lfaWRlX29w ZW4sCi0JLnJlbGVhc2UJPSBpZGVzY3NpX2lkZV9yZWxlYXNlLAotCS5sb2NrZWRfaW9jdGwJPSBp ZGVzY3NpX2lkZV9pb2N0bCwKLX07Ci0KLXN0YXRpYyBpbnQgaWRlc2NzaV9zbGF2ZV9jb25maWd1 cmUoc3RydWN0IHNjc2lfZGV2aWNlICogc2RwKQotewotCS8qIENvbmZpZ3VyZSBkZXRlY3RlZCBk ZXZpY2UgKi8KLQlzZHAtPnVzZV8xMF9mb3JfcncgPSAxOwotCXNkcC0+dXNlXzEwX2Zvcl9tcyA9 IDE7Ci0Jc2NzaV9hZGp1c3RfcXVldWVfZGVwdGgoc2RwLCBNU0dfU0lNUExFX1RBRywgc2RwLT5o b3N0LT5jbWRfcGVyX2x1bik7Ci0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyBjb25zdCBjaGFyICpp ZGVzY3NpX2luZm8gKHN0cnVjdCBTY3NpX0hvc3QgKmhvc3QpCi17Ci0JcmV0dXJuICJTQ1NJIGhv c3QgYWRhcHRlciBlbXVsYXRpb24gZm9yIElERSBBVEFQSSBkZXZpY2VzIjsKLX0KLQotc3RhdGlj IGludCBpZGVzY3NpX2lvY3RsIChzdHJ1Y3Qgc2NzaV9kZXZpY2UgKmRldiwgaW50IGNtZCwgdm9p ZCBfX3VzZXIgKmFyZykKLXsKLQlpZGVzY3NpX3Njc2lfdCAqc2NzaSA9IHNjc2lob3N0X3RvX2lk ZXNjc2koZGV2LT5ob3N0KTsKLQotCWlmIChjbWQgPT0gU0dfU0VUX1RSQU5TRk9STSkgewotCQlp ZiAoYXJnKQotCQkJc2V0X2JpdChJREVTQ1NJX1NHX1RSQU5TRk9STSwgJnNjc2ktPnRyYW5zZm9y bSk7Ci0JCWVsc2UKLQkJCWNsZWFyX2JpdChJREVTQ1NJX1NHX1RSQU5TRk9STSwgJnNjc2ktPnRy YW5zZm9ybSk7Ci0JCXJldHVybiAwOwotCX0gZWxzZSBpZiAoY21kID09IFNHX0dFVF9UUkFOU0ZP Uk0pCi0JCXJldHVybiBwdXRfdXNlcih0ZXN0X2JpdChJREVTQ1NJX1NHX1RSQU5TRk9STSwgJnNj c2ktPnRyYW5zZm9ybSksIChpbnQgX191c2VyICopIGFyZyk7Ci0JcmV0dXJuIC1FSU5WQUw7Ci19 Ci0KLXN0YXRpYyBpbnQgaWRlc2NzaV9xdWV1ZSAoc3RydWN0IHNjc2lfY21uZCAqY21kLAotCQl2 b2lkICgqZG9uZSkoc3RydWN0IHNjc2lfY21uZCAqKSkKLXsKLQlzdHJ1Y3QgU2NzaV9Ib3N0ICpo b3N0ID0gY21kLT5kZXZpY2UtPmhvc3Q7Ci0JaWRlc2NzaV9zY3NpX3QgKnNjc2kgPSBzY3NpaG9z dF90b19pZGVzY3NpKGhvc3QpOwotCWlkZV9kcml2ZV90ICpkcml2ZSA9IHNjc2ktPmRyaXZlOwot CXN0cnVjdCByZXF1ZXN0ICpycSA9IE5VTEw7Ci0Jc3RydWN0IGlkZV9hdGFwaV9wYyAqcGMgPSBO VUxMOwotCWludCB3cml0ZSA9IGNtZC0+c2NfZGF0YV9kaXJlY3Rpb24gPT0gRE1BX1RPX0RFVklD RTsKLQotCWlmICghZHJpdmUpIHsKLQkJc2NtZF9wcmludGsgKEtFUk5fRVJSLCBjbWQsICJkcml2 ZSBub3QgcHJlc2VudFxuIik7Ci0JCWdvdG8gYWJvcnQ7Ci0JfQotCXNjc2kgPSBkcml2ZV90b19p ZGVzY3NpKGRyaXZlKTsKLQlwYyA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBpZGVfYXRhcGlfcGMp LCBHRlBfQVRPTUlDKTsKLQlycSA9IGJsa19nZXRfcmVxdWVzdChkcml2ZS0+cXVldWUsIHdyaXRl LCBHRlBfQVRPTUlDKTsKLQlpZiAocnEgPT0gTlVMTCB8fCBwYyA9PSBOVUxMKSB7Ci0JCXByaW50 ayAoS0VSTl9FUlIgImlkZS1zY3NpOiAlczogb3V0IG9mIG1lbW9yeVxuIiwgZHJpdmUtPm5hbWUp OwotCQlnb3RvIGFib3J0OwotCX0KLQotCW1lbXNldCAocGMtPmMsIDAsIDEyKTsKLQlwYy0+Zmxh Z3MgPSAwOwotCWlmIChjbWQtPnNjX2RhdGFfZGlyZWN0aW9uID09IERNQV9UT19ERVZJQ0UpCi0J CXBjLT5mbGFncyB8PSBQQ19GTEFHX1dSSVRJTkc7Ci0JcGMtPnJxID0gcnE7Ci0JbWVtY3B5IChw Yy0+YywgY21kLT5jbW5kLCBjbWQtPmNtZF9sZW4pOwotCXBjLT5idWYgPSBOVUxMOwotCXBjLT5z ZyA9IHNjc2lfc2dsaXN0KGNtZCk7Ci0JcGMtPnNnX2NudCA9IHNjc2lfc2dfY291bnQoY21kKTsK LQlwYy0+Yl9jb3VudCA9IDA7Ci0JcGMtPnJlcV94ZmVyID0gcGMtPmJ1Zl9zaXplID0gc2NzaV9i dWZmbGVuKGNtZCk7Ci0JcGMtPnNjc2lfY21kID0gY21kOwotCXBjLT5kb25lID0gZG9uZTsKLQlw Yy0+dGltZW91dCA9IGppZmZpZXMgKyBjbWQtPnJlcXVlc3QtPnRpbWVvdXQ7Ci0KLQlpZiAodGVz dF9iaXQoSURFU0NTSV9MT0dfQ01ELCAmc2NzaS0+bG9nKSkgewotCQlwcmludGsgKCJpZGUtc2Nz aTogJXM6IHF1ZSAlbHUsIGNtZCA9ICIsIGRyaXZlLT5uYW1lLCBjbWQtPnNlcmlhbF9udW1iZXIp OwotCQlpZGVfc2NzaV9oZXhfZHVtcChjbWQtPmNtbmQsIGNtZC0+Y21kX2xlbik7Ci0JCWlmICht ZW1jbXAocGMtPmMsIGNtZC0+Y21uZCwgY21kLT5jbWRfbGVuKSkgewotCQkJcHJpbnRrICgiaWRl LXNjc2k6ICVzOiBxdWUgJWx1LCB0c2wgPSAiLCBkcml2ZS0+bmFtZSwgY21kLT5zZXJpYWxfbnVt YmVyKTsKLQkJCWlkZV9zY3NpX2hleF9kdW1wKHBjLT5jLCAxMik7Ci0JCX0KLQl9Ci0KLQlycS0+ c3BlY2lhbCA9IChjaGFyICopIHBjOwotCXJxLT5jbWRfdHlwZSA9IFJFUV9UWVBFX1NQRUNJQUw7 Ci0Jc3Bpbl91bmxvY2tfaXJxKGhvc3QtPmhvc3RfbG9jayk7Ci0JcnEtPnJlZl9jb3VudCsrOwot CW1lbWNweShycS0+Y21kLCBwYy0+YywgMTIpOwotCWJsa19leGVjdXRlX3JxX25vd2FpdChkcml2 ZS0+cXVldWUsIHNjc2ktPmRpc2ssIHJxLCAwLCBOVUxMKTsKLQlzcGluX2xvY2tfaXJxKGhvc3Qt Pmhvc3RfbG9jayk7Ci0JcmV0dXJuIDA7Ci1hYm9ydDoKLQlrZnJlZSAocGMpOwotCWlmIChycSkK LQkJYmxrX3B1dF9yZXF1ZXN0KHJxKTsKLQljbWQtPnJlc3VsdCA9IERJRF9FUlJPUiA8PCAxNjsK LQlkb25lKGNtZCk7Ci0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyBpbnQgaWRlc2NzaV9laF9hYm9y dCAoc3RydWN0IHNjc2lfY21uZCAqY21kKQotewotCWlkZXNjc2lfc2NzaV90ICpzY3NpICA9IHNj c2lob3N0X3RvX2lkZXNjc2koY21kLT5kZXZpY2UtPmhvc3QpOwotCWlkZV9kcml2ZV90ICAgICpk cml2ZSA9IHNjc2ktPmRyaXZlOwotCWlkZV9od2lmX3QgICAgICpod2lmOwotCWlkZV9od2dyb3Vw X3QgICpod2dyb3VwOwotCWludAkJYnVzeTsKLQlpbnQgICAgICAgICAgICAgcmV0ICAgPSBGQUlM RUQ7Ci0KLQlzdHJ1Y3QgaWRlX2F0YXBpX3BjICpwYzsKLQotCS8qIEluIGlkZXNjc2lfZWhfYWJv cnQgd2UgdHJ5IHRvIGdlbnRseSBwcnkgb3VyIGNvbW1hbmQgZnJvbSB0aGUgaWRlIHN1YnN5c3Rl bSAqLwotCi0JaWYgKHRlc3RfYml0KElERVNDU0lfTE9HX0NNRCwgJnNjc2ktPmxvZykpCi0JCXBy aW50ayAoS0VSTl9XQVJOSU5HICJpZGUtc2NzaTogYWJvcnQgY2FsbGVkIGZvciAlbHVcbiIsIGNt ZC0+c2VyaWFsX251bWJlcik7Ci0KLQlpZiAoIWRyaXZlKSB7Ci0JCXByaW50ayAoS0VSTl9XQVJO SU5HICJpZGUtc2NzaTogRHJpdmUgbm90IHNldCBpbiBpZGVzY3NpX2VoX2Fib3J0XG4iKTsKLQkJ V0FSTl9PTigxKTsKLQkJZ290byBub19kcml2ZTsKLQl9Ci0KLQlod2lmID0gZHJpdmUtPmh3aWY7 Ci0JaHdncm91cCA9IGh3aWYtPmh3Z3JvdXA7Ci0KLQkvKiBGaXJzdCBnaXZlIGl0IHNvbWUgbW9y ZSB0aW1lLCBob3cgbXVjaCBpcyAicmlnaHQiIGlzIGhhcmQgdG8gc2F5IDotKAotCSAgIEZJWE1F IC0gdXNlcyBtZGVsYXkgd2hpY2ggY2F1c2VzIGxhdGVuY3k/ICovCi0JYnVzeSA9IGlkZV93YWl0 X25vdF9idXN5KGh3aWYsIDEwMCk7Ci0JaWYgKHRlc3RfYml0KElERVNDU0lfTE9HX0NNRCwgJnNj c2ktPmxvZykpCi0JCXByaW50ayAoS0VSTl9XQVJOSU5HICJpZGUtc2NzaTogZHJpdmUgZGlkJXMg YmVjb21lIHJlYWR5XG4iLCBidXN5PyIgbm90IjoiIik7Ci0KLQlzcGluX2xvY2tfaXJxKCZod2dy b3VwLT5sb2NrKTsKLQotCS8qIElmIHRoZXJlIGlzIG5vIHBjIHJ1bm5pbmcgd2UncmUgZG9uZSAo b3VyIGludGVycnVwdCB0b29rIGNhcmUgb2YgaXQpICovCi0JcGMgPSBkcml2ZS0+cGM7Ci0JaWYg KHBjID09IE5VTEwpIHsKLQkJcmV0ID0gU1VDQ0VTUzsKLQkJZ290byBpZGVfdW5sb2NrOwotCX0K LQotCS8qIEl0J3Mgc29tZXdoZXJlIGluIGZsaWdodC4gRG9lcyBpZGUgc3Vic3lzdGVtIGFncmVl PyAqLwotCWlmIChwYy0+c2NzaV9jbWQtPnNlcmlhbF9udW1iZXIgPT0gY21kLT5zZXJpYWxfbnVt YmVyICYmICFidXN5ICYmCi0JICAgIGVsdl9xdWV1ZV9lbXB0eShkcml2ZS0+cXVldWUpICYmIEhX R1JPVVAoZHJpdmUpLT5ycSAhPSBwYy0+cnEpIHsKLQkJLyoKLQkJICogRklYTUUgLSBub3Qgc3Vy ZSB0aGlzIGNvbmRpdGlvbiBjYW4gZXZlciBvY2N1cgotCQkgKi8KLQkJcHJpbnRrIChLRVJOX0VS UiAiaWRlLXNjc2k6IGNtZCBhYm9ydGVkIVxuIik7Ci0KLQkJaWYgKGJsa19zZW5zZV9yZXF1ZXN0 KHBjLT5ycSkpCi0JCQlrZnJlZShwYy0+YnVmKTsKLQkJLyogd2UgbmVlZCB0byBjYWxsIGJsa19w dXRfcmVxdWVzdCB0d2ljZS4gKi8KLQkJYmxrX3B1dF9yZXF1ZXN0KHBjLT5ycSk7Ci0JCWJsa19w dXRfcmVxdWVzdChwYy0+cnEpOwotCQlrZnJlZShwYyk7Ci0JCWRyaXZlLT5wYyA9IE5VTEw7Ci0K LQkJcmV0ID0gU1VDQ0VTUzsKLQl9Ci0KLWlkZV91bmxvY2s6Ci0Jc3Bpbl91bmxvY2tfaXJxKCZo d2dyb3VwLT5sb2NrKTsKLW5vX2RyaXZlOgotCWlmICh0ZXN0X2JpdChJREVTQ1NJX0xPR19DTUQs ICZzY3NpLT5sb2cpKQotCQlwcmludGsgKEtFUk5fV0FSTklORyAiaWRlLXNjc2k6IGFib3J0IHJl dHVybnMgJXNcbiIsIHJldCA9PSBTVUNDRVNTPyJzdWNjZXNzIjoiZmFpbGVkIik7Ci0KLQlyZXR1 cm4gcmV0OwotfQotCi1zdGF0aWMgaW50IGlkZXNjc2lfZWhfcmVzZXQgKHN0cnVjdCBzY3NpX2Nt bmQgKmNtZCkKLXsKLQlzdHJ1Y3QgcmVxdWVzdCAqcmVxOwotCWlkZXNjc2lfc2NzaV90ICpzY3Np ICA9IHNjc2lob3N0X3RvX2lkZXNjc2koY21kLT5kZXZpY2UtPmhvc3QpOwotCWlkZV9kcml2ZV90 ICAgICpkcml2ZSA9IHNjc2ktPmRyaXZlOwotCWlkZV9od2dyb3VwX3QgICpod2dyb3VwOwotCWlu dCAgICAgICAgICAgICByZWFkeSA9IDA7Ci0JaW50ICAgICAgICAgICAgIHJldCAgID0gU1VDQ0VT UzsKLQotCXN0cnVjdCBpZGVfYXRhcGlfcGMgKnBjOwotCi0JLyogSW4gaWRlc2NzaV9laF9yZXNl dCB3ZSBmb3JjZWZ1bGx5IHJlbW92ZSB0aGUgY29tbWFuZCBmcm9tIHRoZSBpZGUgc3Vic3lzdGVt IGFuZCByZXNldCB0aGUgZGV2aWNlLiAqLwotCi0JaWYgKHRlc3RfYml0KElERVNDU0lfTE9HX0NN RCwgJnNjc2ktPmxvZykpCi0JCXByaW50ayAoS0VSTl9XQVJOSU5HICJpZGUtc2NzaTogcmVzZXQg Y2FsbGVkIGZvciAlbHVcbiIsIGNtZC0+c2VyaWFsX251bWJlcik7Ci0KLQlpZiAoIWRyaXZlKSB7 Ci0JCXByaW50ayAoS0VSTl9XQVJOSU5HICJpZGUtc2NzaTogRHJpdmUgbm90IHNldCBpbiBpZGVz Y3NpX2VoX3Jlc2V0XG4iKTsKLQkJV0FSTl9PTigxKTsKLQkJcmV0dXJuIEZBSUxFRDsKLQl9Ci0K LQlod2dyb3VwID0gZHJpdmUtPmh3aWYtPmh3Z3JvdXA7Ci0KLQlzcGluX2xvY2tfaXJxKGNtZC0+ ZGV2aWNlLT5ob3N0LT5ob3N0X2xvY2spOwotCXNwaW5fbG9jaygmaHdncm91cC0+bG9jayk7Ci0K LQlwYyA9IGRyaXZlLT5wYzsKLQlpZiAocGMpCi0JCXJlcSA9IHBjLT5ycTsKLQotCWlmIChwYyA9 PSBOVUxMIHx8IHJlcSAhPSBod2dyb3VwLT5ycSB8fCBod2dyb3VwLT5oYW5kbGVyID09IE5VTEwp IHsKLQkJcHJpbnRrIChLRVJOX1dBUk5JTkcgImlkZS1zY3NpOiBObyBhY3RpdmUgcmVxdWVzdCBp biBpZGVzY3NpX2VoX3Jlc2V0XG4iKTsKLQkJc3Bpbl91bmxvY2soJmh3Z3JvdXAtPmxvY2spOwot CQlzcGluX3VubG9ja19pcnEoY21kLT5kZXZpY2UtPmhvc3QtPmhvc3RfbG9jayk7Ci0JCXJldHVy biBGQUlMRUQ7Ci0JfQotCi0JLyoga2lsbCBjdXJyZW50IHJlcXVlc3QgKi8KLQlpZiAoX19ibGtf ZW5kX3JlcXVlc3QocmVxLCAtRUlPLCAwKSkKLQkJQlVHKCk7Ci0JaWYgKGJsa19zZW5zZV9yZXF1 ZXN0KHJlcSkpCi0JCWtmcmVlKHBjLT5idWYpOwotCWtmcmVlKHBjKTsKLQlkcml2ZS0+cGMgPSBO VUxMOwotCWJsa19wdXRfcmVxdWVzdChyZXEpOwotCi0JLyogbm93IG51a2UgdGhlIGRyaXZlIHF1 ZXVlICovCi0Jd2hpbGUgKChyZXEgPSBlbHZfbmV4dF9yZXF1ZXN0KGRyaXZlLT5xdWV1ZSkpKSB7 Ci0JCWlmIChfX2Jsa19lbmRfcmVxdWVzdChyZXEsIC1FSU8sIDApKQotCQkJQlVHKCk7Ci0JfQot Ci0JaHdncm91cC0+cnEgPSBOVUxMOwotCWh3Z3JvdXAtPmhhbmRsZXIgPSBOVUxMOwotCWh3Z3Jv dXAtPmJ1c3kgPSAxOyAvKiB3aWxsIHNldCB0aGlzIHRvIHplcm8gd2hlbiBpZGUgcmVzZXQgZmlu aXNoZWQgKi8KLQlzcGluX3VubG9jaygmaHdncm91cC0+bG9jayk7Ci0KLQlpZGVfZG9fcmVzZXQo ZHJpdmUpOwotCi0JLyogaWRlX2RvX3Jlc2V0IHN0YXJ0cyBhIHBvbGxpbmcgaGFuZGxlciB3aGlj aCByZXN0YXJ0cyBpdHNlbGYgZXZlcnkgNTBtcyB1bnRpbCB0aGUgcmVzZXQgZmluaXNoZXMgKi8K LQotCWRvIHsKLQkJc3Bpbl91bmxvY2tfaXJxKGNtZC0+ZGV2aWNlLT5ob3N0LT5ob3N0X2xvY2sp OwotCQltc2xlZXAoNTApOwotCQlzcGluX2xvY2tfaXJxKGNtZC0+ZGV2aWNlLT5ob3N0LT5ob3N0 X2xvY2spOwotCX0gd2hpbGUgKCBIV0dST1VQKGRyaXZlKS0+aGFuZGxlciApOwotCi0JcmVhZHkg PSBkcml2ZV9pc19yZWFkeShkcml2ZSk7Ci0JSFdHUk9VUChkcml2ZSktPmJ1c3ktLTsKLQlpZiAo IXJlYWR5KSB7Ci0JCXByaW50ayAoS0VSTl9FUlIgImlkZS1zY3NpOiByZXNldCBmYWlsZWQhXG4i KTsKLQkJcmV0ID0gRkFJTEVEOwotCX0KLQotCXNwaW5fdW5sb2NrX2lycShjbWQtPmRldmljZS0+ aG9zdC0+aG9zdF9sb2NrKTsKLQlyZXR1cm4gcmV0OwotfQotCi1zdGF0aWMgaW50IGlkZXNjc2lf YmlvcyhzdHJ1Y3Qgc2NzaV9kZXZpY2UgKnNkZXYsIHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYs Ci0JCXNlY3Rvcl90IGNhcGFjaXR5LCBpbnQgKnBhcm0pCi17Ci0JaWRlc2NzaV9zY3NpX3QgKmlk ZXNjc2kgPSBzY3NpaG9zdF90b19pZGVzY3NpKHNkZXYtPmhvc3QpOwotCWlkZV9kcml2ZV90ICpk cml2ZSA9IGlkZXNjc2ktPmRyaXZlOwotCi0JaWYgKGRyaXZlLT5iaW9zX2N5bCAmJiBkcml2ZS0+ Ymlvc19oZWFkICYmIGRyaXZlLT5iaW9zX3NlY3QpIHsKLQkJcGFybVswXSA9IGRyaXZlLT5iaW9z X2hlYWQ7Ci0JCXBhcm1bMV0gPSBkcml2ZS0+Ymlvc19zZWN0OwotCQlwYXJtWzJdID0gZHJpdmUt PmJpb3NfY3lsOwotCX0KLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIHN0cnVjdCBzY3NpX2hvc3Rf dGVtcGxhdGUgaWRlc2NzaV90ZW1wbGF0ZSA9IHsKLQkubW9kdWxlCQkJPSBUSElTX01PRFVMRSwK LQkubmFtZQkJCT0gImlkZXNjc2kiLAotCS5pbmZvCQkJPSBpZGVzY3NpX2luZm8sCi0JLnNsYXZl X2NvbmZpZ3VyZSAgICAgICAgPSBpZGVzY3NpX3NsYXZlX2NvbmZpZ3VyZSwKLQkuaW9jdGwJCQk9 IGlkZXNjc2lfaW9jdGwsCi0JLnF1ZXVlY29tbWFuZAkJPSBpZGVzY3NpX3F1ZXVlLAotCS5laF9h Ym9ydF9oYW5kbGVyCT0gaWRlc2NzaV9laF9hYm9ydCwKLQkuZWhfaG9zdF9yZXNldF9oYW5kbGVy ICA9IGlkZXNjc2lfZWhfcmVzZXQsCi0JLmJpb3NfcGFyYW0JCT0gaWRlc2NzaV9iaW9zLAotCS5j YW5fcXVldWUJCT0gNDAsCi0JLnRoaXNfaWQJCT0gLTEsCi0JLnNnX3RhYmxlc2l6ZQkJPSAyNTYs Ci0JLmNtZF9wZXJfbHVuCQk9IDUsCi0JLm1heF9zZWN0b3JzCQk9IDEyOCwKLQkudXNlX2NsdXN0 ZXJpbmcJCT0gRElTQUJMRV9DTFVTVEVSSU5HLAotCS5lbXVsYXRlZAkJPSAxLAotCS5wcm9jX25h bWUJCT0gImlkZS1zY3NpIiwKLX07Ci0KLXN0YXRpYyBpbnQgaWRlX3Njc2lfcHJvYmUoaWRlX2Ry aXZlX3QgKmRyaXZlKQotewotCWlkZXNjc2lfc2NzaV90ICppZGVzY3NpOwotCXN0cnVjdCBTY3Np X0hvc3QgKmhvc3Q7Ci0Jc3RydWN0IGdlbmRpc2sgKmc7Ci0Jc3RhdGljIGludCB3YXJuZWQ7Ci0J aW50IGVyciA9IC1FTk9NRU07Ci0JdTE2IGxhc3RfbHVuOwotCi0JaWYgKCF3YXJuZWQgJiYgZHJp dmUtPm1lZGlhID09IGlkZV9jZHJvbSkgewotCQlwcmludGsoS0VSTl9XQVJOSU5HICJpZGUtc2Nz aSBpcyBkZXByZWNhdGVkIGZvciBjZCBidXJuaW5nISBVc2UgaWRlLWNkIGFuZCBnaXZlIGRldj0v ZGV2L2hkWCBhcyBkZXZpY2VcbiIpOwotCQl3YXJuZWQgPSAxOwotCX0KLQotCWlmIChpZGVzY3Np X25vY2QgJiYgZHJpdmUtPm1lZGlhID09IGlkZV9jZHJvbSkKLQkJcmV0dXJuIC1FTk9ERVY7Ci0K LQlpZiAoIXN0cnN0cigiaWRlLXNjc2kiLCBkcml2ZS0+ZHJpdmVyX3JlcSkgfHwKLQkgICAgZHJp dmUtPm1lZGlhID09IGlkZV9kaXNrIHx8Ci0JICAgICEoaG9zdCA9IHNjc2lfaG9zdF9hbGxvYygm aWRlc2NzaV90ZW1wbGF0ZSxzaXplb2YoaWRlc2NzaV9zY3NpX3QpKSkpCi0JCXJldHVybiAtRU5P REVWOwotCi0JZHJpdmUtPmRldl9mbGFncyB8PSBJREVfREZMQUdfU0NTSTsKLQotCWcgPSBhbGxv Y19kaXNrKDEgPDwgUEFSVE5fQklUUyk7Ci0JaWYgKCFnKQotCQlnb3RvIG91dF9ob3N0X3B1dDsK LQotCWlkZV9pbml0X2Rpc2soZywgZHJpdmUpOwotCi0JaG9zdC0+bWF4X2lkID0gMTsKLQotCWxh c3RfbHVuID0gZHJpdmUtPmlkW0FUQV9JRF9MQVNUX0xVTl07Ci0JaWYgKGxhc3RfbHVuKQotCQlk ZWJ1Z19sb2coIiVzOiBsYXN0X2x1bj0ldVxuIiwgZHJpdmUtPm5hbWUsIGxhc3RfbHVuKTsKLQot CWlmICgobGFzdF9sdW4gJiA3KSAhPSA3KQotCQlob3N0LT5tYXhfbHVuID0gKGxhc3RfbHVuICYg NykgKyAxOwotCWVsc2UKLQkJaG9zdC0+bWF4X2x1biA9IDE7Ci0KLQlkcml2ZS0+ZHJpdmVyX2Rh dGEgPSBob3N0OwotCWlkZXNjc2kgPSBzY3NpaG9zdF90b19pZGVzY3NpKGhvc3QpOwotCWlkZXNj c2ktPmRyaXZlID0gZHJpdmU7Ci0JaWRlc2NzaS0+ZHJpdmVyID0gJmlkZXNjc2lfZHJpdmVyOwot CWlkZXNjc2ktPmhvc3QgPSBob3N0OwotCWlkZXNjc2ktPmRpc2sgPSBnOwotCWctPnByaXZhdGVf ZGF0YSA9ICZpZGVzY3NpLT5kcml2ZXI7Ci0JZXJyID0gMDsKLQlpZGVzY3NpX3NldHVwKGRyaXZl LCBpZGVzY3NpKTsKLQlnLT5mb3BzID0gJmlkZXNjc2lfb3BzOwotCWlkZV9yZWdpc3Rlcl9yZWdp b24oZyk7Ci0JZXJyID0gc2NzaV9hZGRfaG9zdChob3N0LCAmZHJpdmUtPmdlbmRldik7Ci0JaWYg KCFlcnIpIHsKLQkJc2NzaV9zY2FuX2hvc3QoaG9zdCk7Ci0JCXJldHVybiAwOwotCX0KLQkvKiBm YWxsIHRocm91Z2ggb24gZXJyb3IgKi8KLQlpZGVfdW5yZWdpc3Rlcl9yZWdpb24oZyk7Ci0JaWRl X3Byb2NfdW5yZWdpc3Rlcl9kcml2ZXIoZHJpdmUsICZpZGVzY3NpX2RyaXZlcik7Ci0KLQlwdXRf ZGlzayhnKTsKLW91dF9ob3N0X3B1dDoKLQlkcml2ZS0+ZGV2X2ZsYWdzICY9IH5JREVfREZMQUdf U0NTSTsKLQlzY3NpX2hvc3RfcHV0KGhvc3QpOwotCXJldHVybiBlcnI7Ci19Ci0KLXN0YXRpYyBp bnQgX19pbml0IGluaXRfaWRlc2NzaV9tb2R1bGUodm9pZCkKLXsKLQlyZXR1cm4gZHJpdmVyX3Jl Z2lzdGVyKCZpZGVzY3NpX2RyaXZlci5nZW5fZHJpdmVyKTsKLX0KLQotc3RhdGljIHZvaWQgX19l eGl0IGV4aXRfaWRlc2NzaV9tb2R1bGUodm9pZCkKLXsKLQlkcml2ZXJfdW5yZWdpc3RlcigmaWRl c2NzaV9kcml2ZXIuZ2VuX2RyaXZlcik7Ci19Ci0KLW1vZHVsZV9wYXJhbShpZGVzY3NpX25vY2Qs IGludCwgMDYwMCk7Ci1NT0RVTEVfUEFSTV9ERVNDKGlkZXNjc2lfbm9jZCwgIkRpc2FibGUgaGFu ZGxpbmcgb2YgQ0QtUk9NcyBzbyB0aGV5IG1heSBiZSBkcml2ZW4gYnkgaWRlLWNkIik7Ci1tb2R1 bGVfaW5pdChpbml0X2lkZXNjc2lfbW9kdWxlKTsKLW1vZHVsZV9leGl0KGV4aXRfaWRlc2NzaV9t b2R1bGUpOwotTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51 eC9pZGUuaCBiL2luY2x1ZGUvbGludXgvaWRlLmgKaW5kZXggZTk5YzU2ZC4uZGI1ZWY4YSAxMDA2 NDQKLS0tIGEvaW5jbHVkZS9saW51eC9pZGUuaAorKysgYi9pbmNsdWRlL2xpbnV4L2lkZS5oCkBA IC0zMiwxMyArMzIsNiBAQAogIyBkZWZpbmUgU1VQUE9SVF9WTEJfU1lOQyAxCiAjZW5kaWYKIAot LyoKLSAqIFVzZWQgdG8gaW5kaWNhdGUgIm5vIElSUSIsIHNob3VsZCBiZSBhIHZhbHVlIHRoYXQg Y2Fubm90IGJlIGFuIElSUQotICogbnVtYmVyLgotICovCi0gCi0jZGVmaW5lIElERV9OT19JUlEJ CSgtMSkKLQogdHlwZWRlZiB1bnNpZ25lZCBjaGFyCWJ5dGU7CS8qIHVzZWQgZXZlcnl3aGVyZSAq LwogCiAvKgpAQCAtNDAzLDYgKzM5Niw3IEBAIGVudW0gewogICogVGhpcyBpcyB1c2VkIGZvciBz ZXZlcmFsIHBhY2tldCBjb21tYW5kcyAobm90IGZvciBSRUFEL1dSSVRFIGNvbW1hbmRzKS4KICAq LwogI2RlZmluZSBJREVfUENfQlVGRkVSX1NJWkUJMjU2CisjZGVmaW5lIEFUQVBJX1dBSVRfUEMJ CSg2MCAqIEhaKQogCiBzdHJ1Y3QgaWRlX2F0YXBpX3BjIHsKIAkvKiBhY3R1YWwgcGFja2V0IGJ5 dGVzICovCkBAIC00ODAsNTMgKzQ3NCw1MyBAQCBlbnVtIHsKIAogCS8qIGlkZS1jZCAqLwogCS8q IERyaXZlIGNhbm5vdCBlamVjdCB0aGUgZGlzYy4gKi8KLQlJREVfQUZMQUdfTk9fRUpFQ1QJCT0g KDEgPDwgMyksCisJSURFX0FGTEFHX05PX0VKRUNUCQk9ICgxIDw8IDEpLAogCS8qIERyaXZlIGlz IGEgcHJlIEFUQVBJIDEuMiBkcml2ZS4gKi8KLQlJREVfQUZMQUdfUFJFX0FUQVBJMTIJCT0gKDEg PDwgNCksCisJSURFX0FGTEFHX1BSRV9BVEFQSTEyCQk9ICgxIDw8IDIpLAogCS8qIFRPQyBhZGRy ZXNzZXMgYXJlIGluIEJDRC4gKi8KLQlJREVfQUZMQUdfVE9DQUREUl9BU19CQ0QJPSAoMSA8PCA1 KSwKKwlJREVfQUZMQUdfVE9DQUREUl9BU19CQ0QJPSAoMSA8PCAzKSwKIAkvKiBUT0MgdHJhY2sg bnVtYmVycyBhcmUgaW4gQkNELiAqLwotCUlERV9BRkxBR19UT0NUUkFDS1NfQVNfQkNECT0gKDEg PDwgNiksCisJSURFX0FGTEFHX1RPQ1RSQUNLU19BU19CQ0QJPSAoMSA8PCA0KSwKIAkvKgogCSAq IERyaXZlIGRvZXMgbm90IHByb3ZpZGUgZGF0YSBpbiBtdWx0aXBsZXMgb2YgU0VDVE9SX1NJWkUK IAkgKiB3aGVuIG1vcmUgdGhhbiBvbmUgaW50ZXJydXB0IGlzIG5lZWRlZC4KIAkgKi8KLQlJREVf QUZMQUdfTElNSVRfTkZSQU1FUwkJPSAoMSA8PCA3KSwKKwlJREVfQUZMQUdfTElNSVRfTkZSQU1F UwkJPSAoMSA8PCA1KSwKIAkvKiBTYXZlZCBUT0MgaW5mb3JtYXRpb24gaXMgY3VycmVudC4gKi8K LQlJREVfQUZMQUdfVE9DX1ZBTElECQk9ICgxIDw8IDkpLAorCUlERV9BRkxBR19UT0NfVkFMSUQJ CT0gKDEgPDwgNiksCiAJLyogV2UgdGhpbmsgdGhhdCB0aGUgZHJpdmUgZG9vciBpcyBsb2NrZWQu ICovCi0JSURFX0FGTEFHX0RPT1JfTE9DS0VECQk9ICgxIDw8IDEwKSwKKwlJREVfQUZMQUdfRE9P Ul9MT0NLRUQJCT0gKDEgPDwgNyksCiAJLyogU0VUX0NEX1NQRUVEIGNvbW1hbmQgaXMgdW5zdXBw b3J0ZWQuICovCi0JSURFX0FGTEFHX05PX1NQRUVEX1NFTEVDVAk9ICgxIDw8IDExKSwKLQlJREVf QUZMQUdfVkVSVE9TXzMwMF9TU0QJPSAoMSA8PCAxMiksCi0JSURFX0FGTEFHX1ZFUlRPU182MDBf RVNECT0gKDEgPDwgMTMpLAotCUlERV9BRkxBR19TQU5ZT18zQ0QJCT0gKDEgPDwgMTQpLAotCUlE RV9BRkxBR19GVUxMX0NBUFNfUEFHRQk9ICgxIDw8IDE1KSwKLQlJREVfQUZMQUdfUExBWV9BVURJ T19PSwkJPSAoMSA8PCAxNiksCi0JSURFX0FGTEFHX0xFX1NQRUVEX0ZJRUxEUwk9ICgxIDw8IDE3 KSwKKwlJREVfQUZMQUdfTk9fU1BFRURfU0VMRUNUCT0gKDEgPDwgOCksCisJSURFX0FGTEFHX1ZF UlRPU18zMDBfU1NECT0gKDEgPDwgOSksCisJSURFX0FGTEFHX1ZFUlRPU182MDBfRVNECT0gKDEg PDwgMTApLAorCUlERV9BRkxBR19TQU5ZT18zQ0QJCT0gKDEgPDwgMTEpLAorCUlERV9BRkxBR19G VUxMX0NBUFNfUEFHRQk9ICgxIDw8IDEyKSwKKwlJREVfQUZMQUdfUExBWV9BVURJT19PSwkJPSAo MSA8PCAxMyksCisJSURFX0FGTEFHX0xFX1NQRUVEX0ZJRUxEUwk9ICgxIDw8IDE0KSwKIAogCS8q IGlkZS1mbG9wcHkgKi8KIAkvKiBBdm9pZCBjb21tYW5kcyBub3Qgc3VwcG9ydGVkIGluIENsaWsg ZHJpdmUgKi8KLQlJREVfQUZMQUdfQ0xJS19EUklWRQkJPSAoMSA8PCAxOSksCisJSURFX0FGTEFH X0NMSUtfRFJJVkUJCT0gKDEgPDwgMTUpLAogCS8qIFJlcXVpcmVzIEJIIGFsZ29yaXRobSBmb3Ig cGFja2V0cyAqLwotCUlERV9BRkxBR19aSVBfRFJJVkUJCT0gKDEgPDwgMjApLAorCUlERV9BRkxB R19aSVBfRFJJVkUJCT0gKDEgPDwgMTYpLAogCS8qIFN1cHBvcnRzIGZvcm1hdCBwcm9ncmVzcyBy ZXBvcnQgKi8KLQlJREVfQUZMQUdfU1JGUAkJCT0gKDEgPDwgMjIpLAorCUlERV9BRkxBR19TUkZQ CQkJPSAoMSA8PCAxNyksCiAKIAkvKiBpZGUtdGFwZSAqLwotCUlERV9BRkxBR19JR05PUkVfRFND CQk9ICgxIDw8IDIzKSwKKwlJREVfQUZMQUdfSUdOT1JFX0RTQwkJPSAoMSA8PCAxOCksCiAJLyog MCBXaGVuIHRoZSB0YXBlIHBvc2l0aW9uIGlzIHVua25vd24gKi8KLQlJREVfQUZMQUdfQUREUkVT U19WQUxJRAkJPSAoMSA8PAkyNCksCisJSURFX0FGTEFHX0FERFJFU1NfVkFMSUQJCT0gKDEgPDwJ MTkpLAogCS8qIERldmljZSBhbHJlYWR5IG9wZW5lZCAqLwotCUlERV9BRkxBR19CVVNZCQkJPSAo MSA8PCAyNSksCisJSURFX0FGTEFHX0JVU1kJCQk9ICgxIDw8IDIwKSwKIAkvKiBBdHRlbXB0IHRv IGF1dG8tZGV0ZWN0IHRoZSBjdXJyZW50IHVzZXIgYmxvY2sgc2l6ZSAqLwotCUlERV9BRkxBR19E RVRFQ1RfQlMJCT0gKDEgPDwgMjYpLAorCUlERV9BRkxBR19ERVRFQ1RfQlMJCT0gKDEgPDwgMjEp LAogCS8qIEN1cnJlbnRseSBvbiBhIGZpbGVtYXJrICovCi0JSURFX0FGTEFHX0ZJTEVNQVJLCQk9 ICgxIDw8IDI3KSwKKwlJREVfQUZMQUdfRklMRU1BUksJCT0gKDEgPDwgMjIpLAogCS8qIDAgPSBu byB0YXBlIGlzIGxvYWRlZCwgc28gd2UgZG9uJ3QgcmV3aW5kIGFmdGVyIGVqZWN0aW5nICovCi0J SURFX0FGTEFHX01FRElVTV9QUkVTRU5UCT0gKDEgPDwgMjgpLAorCUlERV9BRkxBR19NRURJVU1f UFJFU0VOVAk9ICgxIDw8IDIzKSwKIAotCUlERV9BRkxBR19OT19BVVRPQ0xPU0UJCT0gKDEgPDwg MjkpLAorCUlERV9BRkxBR19OT19BVVRPQ0xPU0UJCT0gKDEgPDwgMjQpLAogfTsKIAogLyogZGV2 aWNlIGZsYWdzICovCkBAIC01NjUsMjggKzU1OSwyNiBAQCBlbnVtIHsKIAlJREVfREZMQUdfTk9E TUEJCQk9ICgxIDw8IDE2KSwKIAkvKiBwb3dlcm1hbmFnbWVudCB0b2xkIHVzIG5vdCB0byBkbyBh bnl0aGluZywgc28gc2xlZXAgbmljZWx5ICovCiAJSURFX0RGTEFHX0JMT0NLRUQJCT0gKDEgPDwg MTcpLAotCS8qIGlkZS1zY3NpIGVtdWxhdGlvbiAqLwotCUlERV9ERkxBR19TQ1NJCQkJPSAoMSA8 PCAxOCksCiAJLyogc2xlZXBpbmcgJiBzbGVlcCBmaWVsZCB2YWxpZCAqLwotCUlERV9ERkxBR19T TEVFUElORwkJPSAoMSA8PCAxOSksCi0JSURFX0RGTEFHX1BPU1RfUkVTRVQJCT0gKDEgPDwgMjAp LAotCUlERV9ERkxBR19VRE1BMzNfV0FSTkVECQk9ICgxIDw8IDIxKSwKLQlJREVfREZMQUdfTEJB NDgJCQk9ICgxIDw8IDIyKSwKKwlJREVfREZMQUdfU0xFRVBJTkcJCT0gKDEgPDwgMTgpLAorCUlE RV9ERkxBR19QT1NUX1JFU0VUCQk9ICgxIDw8IDE5KSwKKwlJREVfREZMQUdfVURNQTMzX1dBUk5F RAkJPSAoMSA8PCAyMCksCisJSURFX0RGTEFHX0xCQTQ4CQkJPSAoMSA8PCAyMSksCiAJLyogc3Rh dHVzIG9mIHdyaXRlIGNhY2hlICovCi0JSURFX0RGTEFHX1dDQUNIRQkJPSAoMSA8PCAyMyksCisJ SURFX0RGTEFHX1dDQUNIRQkJPSAoMSA8PCAyMiksCiAJLyogdXNlZCBmb3IgaWdub3JpbmcgQVRB X0RGICovCi0JSURFX0RGTEFHX05PV0VSUgkJPSAoMSA8PCAyNCksCisJSURFX0RGTEFHX05PV0VS UgkJPSAoMSA8PCAyMyksCiAJLyogcmV0cnlpbmcgaW4gUElPICovCi0JSURFX0RGTEFHX0RNQV9Q SU9fUkVUUlkJCT0gKDEgPDwgMjUpLAotCUlERV9ERkxBR19MQkEJCQk9ICgxIDw8IDI2KSwKKwlJ REVfREZMQUdfRE1BX1BJT19SRVRSWQkJPSAoMSA8PCAyNCksCisJSURFX0RGTEFHX0xCQQkJCT0g KDEgPDwgMjUpLAogCS8qIGRvbid0IHVubG9hZCBoZWFkcyAqLwotCUlERV9ERkxBR19OT19VTkxP QUQJCT0gKDEgPDwgMjcpLAorCUlERV9ERkxBR19OT19VTkxPQUQJCT0gKDEgPDwgMjYpLAogCS8q IGhlYWRzIHVubG9hZGVkLCBwbGVhc2UgZG9uJ3QgcmVzZXQgcG9ydCAqLwotCUlERV9ERkxBR19Q QVJLRUQJCT0gKDEgPDwgMjgpLAotCUlERV9ERkxBR19NRURJQV9DSEFOR0VECQk9ICgxIDw8IDI5 KSwKKwlJREVfREZMQUdfUEFSS0VECQk9ICgxIDw8IDI3KSwKKwlJREVfREZMQUdfTUVESUFfQ0hB TkdFRAkJPSAoMSA8PCAyOCksCiAJLyogd3JpdGUgcHJvdGVjdCAqLwotCUlERV9ERkxBR19XUAkJ CT0gKDEgPDwgMzApLAotCUlERV9ERkxBR19GT1JNQVRfSU5fUFJPR1JFU1MJPSAoMSA8PCAzMSks CisJSURFX0RGTEFHX1dQCQkJPSAoMSA8PCAyOSksCisJSURFX0RGTEFHX0ZPUk1BVF9JTl9QUk9H UkVTUwk9ICgxIDw8IDMwKSwKIH07CiAKIHN0cnVjdCBpZGVfZHJpdmVfcyB7CkBAIC02MTAsOCAr NjAyLDYgQEAgc3RydWN0IGlkZV9kcml2ZV9zIHsKIAl1bnNpZ25lZCBsb25nIGRldl9mbGFnczsK IAogCXVuc2lnbmVkIGxvbmcgc2xlZXA7CQkvKiBzbGVlcCB1bnRpbCB0aGlzIHRpbWUgKi8KLQl1 bnNpZ25lZCBsb25nIHNlcnZpY2Vfc3RhcnQ7CS8qIHRpbWUgd2Ugc3RhcnRlZCBsYXN0IHJlcXVl c3QgKi8KLQl1bnNpZ25lZCBsb25nIHNlcnZpY2VfdGltZTsJLyogc2VydmljZSB0aW1lIG9mIGxh c3QgcmVxdWVzdCAqLwogCXVuc2lnbmVkIGxvbmcgdGltZW91dDsJCS8qIG1heCB0aW1lIHRvIHdh aXQgZm9yIGlycSAqLwogCiAJc3BlY2lhbF90CXNwZWNpYWw7CS8qIHNwZWNpYWwgYWN0aW9uIGZs YWdzICovCkBAIC04NzksOCArODY5LDYgQEAgdHlwZWRlZiBzdHJ1Y3QgaHdncm91cF9zIHsKIAog CQkvKiBCT09MOiBwcm90ZWN0cyBhbGwgZmllbGRzIGJlbG93ICovCiAJdm9sYXRpbGUgaW50IGJ1 c3k7Ci0JCS8qIEJPT0w6IHdha2UgdXMgdXAgb24gdGltZXIgZXhwaXJ5ICovCi0JdW5zaWduZWQg aW50IHNsZWVwaW5nCTogMTsKIAkJLyogQk9PTDogcG9sbGluZyBhY3RpdmUgJiBwb2xsX3RpbWVv dXQgZmllbGQgdmFsaWQgKi8KIAl1bnNpZ25lZCBpbnQgcG9sbGluZwk6IDE7CiAKQEAgLTEyNTgs MTQgKzEyNDYsMTEgQEAgaW50IGlkZV9zZXRfbWVkaWFfbG9jayhpZGVfZHJpdmVfdCAqLCBzdHJ1 Y3QgZ2VuZGlzayAqLCBpbnQpOwogdm9pZCBpZGVfY3JlYXRlX3JlcXVlc3Rfc2Vuc2VfY21kKGlk ZV9kcml2ZV90ICosIHN0cnVjdCBpZGVfYXRhcGlfcGMgKik7CiB2b2lkIGlkZV9yZXRyeV9wYyhp ZGVfZHJpdmVfdCAqLCBzdHJ1Y3QgZ2VuZGlzayAqKTsKIAotc3RhdGljIGlubGluZSB1bnNpZ25l ZCBsb25nIGlkZV9zY3NpX2dldF90aW1lb3V0KHN0cnVjdCBpZGVfYXRhcGlfcGMgKnBjKQotewot CXJldHVybiBtYXhfdCh1bnNpZ25lZCBsb25nLCBXQUlUX0NNRCwgcGMtPnRpbWVvdXQgLSBqaWZm aWVzKTsKLX0KK2ludCBpZGVfY2RfZXhwaXJ5KGlkZV9kcml2ZV90ICopOwogCi1pbnQgaWRlX3Nj c2lfZXhwaXJ5KGlkZV9kcml2ZV90ICopOworaW50IGlkZV9jZF9nZXRfeGZlcmxlbihzdHJ1Y3Qg cmVxdWVzdCAqKTsKIAotaWRlX3N0YXJ0c3RvcF90IGlkZV9pc3N1ZV9wYyhpZGVfZHJpdmVfdCAq LCB1bnNpZ25lZCBpbnQsIGlkZV9leHBpcnlfdCAqKTsKK2lkZV9zdGFydHN0b3BfdCBpZGVfaXNz dWVfcGMoaWRlX2RyaXZlX3QgKik7CiAKIGlkZV9zdGFydHN0b3BfdCBkb19yd190YXNrZmlsZShp ZGVfZHJpdmVfdCAqLCBpZGVfdGFza190ICopOwogCkBAIC0xMjg3LDYgKzEyNzIsMjYgQEAgZXh0 ZXJuIHZvaWQgaWRlX3N0YWxsX3F1ZXVlKGlkZV9kcml2ZV90ICpkcml2ZSwgdW5zaWduZWQgbG9u ZyB0aW1lb3V0KTsKIAogZXh0ZXJuIHZvaWQgaWRlX3RpbWVyX2V4cGlyeSh1bnNpZ25lZCBsb25n KTsKIGV4dGVybiBpcnFyZXR1cm5fdCBpZGVfaW50cihpbnQgaXJxLCB2b2lkICpkZXZfaWQpOwor CitzdGF0aWMgaW5saW5lIGludCBpZGVfbG9ja19od2dyb3VwKGlkZV9od2dyb3VwX3QgKmh3Z3Jv dXApCit7CisJaWYgKGh3Z3JvdXAtPmJ1c3kpCisJCXJldHVybiAxOworCisJaHdncm91cC0+YnVz eSA9IDE7CisJLyogZm9yIGF0YXJpIG9ubHkgKi8KKwlpZGVfZ2V0X2xvY2soaWRlX2ludHIsIGh3 Z3JvdXApOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBpZGVfdW5sb2Nr X2h3Z3JvdXAoaWRlX2h3Z3JvdXBfdCAqaHdncm91cCkKK3sKKwkvKiBmb3IgYXRhcmkgb25seSAq LworCWlkZV9yZWxlYXNlX2xvY2soKTsKKwlod2dyb3VwLT5idXN5ID0gMDsKK30KKwogZXh0ZXJu IHZvaWQgZG9faWRlX3JlcXVlc3Qoc3RydWN0IHJlcXVlc3RfcXVldWUgKik7CiAKIHZvaWQgaWRl X2luaXRfZGlzayhzdHJ1Y3QgZ2VuZGlzayAqLCBpZGVfZHJpdmVfdCAqKTsKQEAgLTE1MzMsNiAr MTUzOCw3IEBAIHZvaWQgaWRlX3VucmVnaXN0ZXJfcmVnaW9uKHN0cnVjdCBnZW5kaXNrICopOwog dm9pZCBpZGVfdW5kZWNvZGVkX3NsYXZlKGlkZV9kcml2ZV90ICopOwogCiB2b2lkIGlkZV9wb3J0 X2FwcGx5X3BhcmFtcyhpZGVfaHdpZl90ICopOworaW50IGlkZV9zeXNmc19yZWdpc3Rlcl9wb3J0 KGlkZV9od2lmX3QgKik7CiAKIHN0cnVjdCBpZGVfaG9zdCAqaWRlX2hvc3RfYWxsb2MoY29uc3Qg c3RydWN0IGlkZV9wb3J0X2luZm8gKiwgaHdfcmVnc190ICoqKTsKIHZvaWQgaWRlX2hvc3RfZnJl ZShzdHJ1Y3QgaWRlX2hvc3QgKik7CkBAIC0xNjI3LDYgKzE2MzMsOSBAQCBleHRlcm4gc3RydWN0 IG11dGV4IGlkZV9jZmdfbXR4OwogCiAjZGVmaW5lIGxvY2FsX2lycV9zZXQoZmxhZ3MpCWRvIHsg bG9jYWxfc2F2ZV9mbGFncygoZmxhZ3MpKTsgbG9jYWxfaXJxX2VuYWJsZV9pbl9oYXJkaXJxKCk7 IH0gd2hpbGUgKDApCiAKK2NoYXIgKmlkZV9tZWRpYV9zdHJpbmcoaWRlX2RyaXZlX3QgKik7CisK K2V4dGVybiBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSBpZGVfZGV2X2F0dHJzW107CiBleHRlcm4g c3RydWN0IGJ1c190eXBlIGlkZV9idXNfdHlwZTsKIGV4dGVybiBzdHJ1Y3QgY2xhc3MgKmlkZV9w b3J0X2NsYXNzOwogCgAK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1758180AbZABRBP (ORCPT ); Fri, 2 Jan 2009 12:01:15 -0500 Received: (majordomo@vger.kernel.org) by vger.kernel.org id S1756991AbZABRAy (ORCPT ); Fri, 2 Jan 2009 12:00:54 -0500 Received: from mu-out-0910.google.com ([209.85.134.191]:53035 "EHLO mu-out-0910.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750911AbZABRAs (ORCPT ); Fri, 2 Jan 2009 12:00:48 -0500 DomainKey-Signature: a=rsa-sha1; c=nofws; d=gmail.com; s=gamma; h=from:to:subject:user-agent:cc:mime-version:content-disposition:date :message-id:content-type:content-transfer-encoding; b=hkXjXNSUwd4ZtkEVtEEa1RYOXuxw5fIxn5BRZQIH3Sp+7nP9cXHj5n8V3x6lQ2rCP/ OKtJWLbZWyuYVhR7arOyFGkOyTf1MLA3+ZQYLUyBQdZ4zdBSlu60kvOlB1MOYlhGQRwZ GBCY7CF1PCUI00o3FKNasA9029WPE2U+2K8hw= From: Bartlomiej Zolnierkiewicz To: Linus Torvalds Subject: [git pull] IDE updates part 2 User-Agent: KMail/1.9.9 Cc: Andrew Morton , Stephen Rothwell , linux-ide@vger.kernel.org, linux-kernel@vger.kernel.org MIME-Version: 1.0 Content-Disposition: inline Date: Fri, 2 Jan 2009 17:59:45 +0100 Message-Id: <200901021759.46260.bzolnier@gmail.com> Content-Type: text/plain; charset="iso-8859-1" Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from base64 to 8bit by alpha id n02H1bwM015617 First IDE updates in 2009, this time: * Fix IDE to not process commands in IRQ-context and than switch the subsystem to use per-device request queue locks instead of (ab)using hwgroup locks for this purpose. Besides being obvious IRQ-latency and scalability improvement this decreases complexity of core code greatly (~100 LOC of very tricky code gone) and makes maintainance work much easier. [ Thanks to Elias Oltmanns for his work on reviewing these changes and catching some issues early. ] * Scheduled removal of deprecated ide-scsi device driver. We've been discouraging using ide-scsi since early 2.5.x days as the driver contains unfixable problems with error handling and lifetimes of IDE/SCSI objects. There is now consensus between IDE/SCSI people that both (recently rewritten) native ide-{cd,gd,tape} drivers from IDE side and proper ATA-SCSI emulation (libata) from SCSI side offer a better alternative. The driver has been officially orphaned for a year and then scheduled for removal for the last 4 months so this shouldn't come as surprise (I didn't got a single user complaint about this and ide-scsi has even been broken by some unrelated kernel changes for few kernel releases in the past without anybody noticing). (from FUJITA Tomonori and Borislav Petkov) * Fix multiple nested big stack usage in ide-floppy.c. (from Linus himself, testing/merging handled by Borislav) * Preparations to switch ide-cd device driver to use generic ATAPI code which will happen in the next IDE updates pull request. (from Borislav) * Misc fixups/cleanups. All above changes have been in linux-next for some time now... Linus, please pull from: master.kernel.org:/pub/scm/linux/kernel/git/bart/ide-2.6.git/ to receive the following updates: Documentation/feature-removal-schedule.txt | 9 - MAINTAINERS | 5 - drivers/ide/Kconfig | 18 +- drivers/ide/Makefile | 2 +- drivers/ide/ide-atapi.c | 248 +++++---- drivers/ide/ide-cd.c | 99 +--- drivers/ide/ide-cd.h | 12 +- drivers/ide/ide-floppy.c | 28 +- drivers/ide/ide-floppy_ioctl.c | 58 +- drivers/ide/ide-io.c | 282 +++------- drivers/ide/ide-ioctls.c | 3 +- drivers/ide/ide-park.c | 13 +- drivers/ide/ide-probe.c | 223 +++----- drivers/ide/ide-sysfs.c | 125 ++++ drivers/ide/ide-tape.c | 2 +- drivers/ide/ide.c | 72 +--- drivers/ide/tx4938ide.c | 11 +- drivers/ide/tx4939ide.c | 43 +- drivers/scsi/Kconfig | 8 +- drivers/scsi/Makefile | 1 - drivers/scsi/ide-scsi.c | 840 ---------------------------- include/linux/ide.h | 121 +++-- 22 files changed, 614 insertions(+), 1609 deletions(-) create mode 100644 drivers/ide/ide-sysfs.c delete mode 100644 drivers/scsi/ide-scsi.c Bartlomiej Zolnierkiewicz (10): tx493x: fix indentation ide: remove chipset type fixup from ide_host_register() ide: small ide_register_port() cleanup ide: factor out device type classifying from do_identify() ide: move sysfs support to ide-sysfs.c ide: don't execute the next queued command from the hard-IRQ context (v2) ide: remove IDE PM hack from do_ide_request() ide: remove "paranoia" checks for hwgroup->busy ide: add ide_[un]lock_hwgroup() helpers ide: use per-device request queue locks (v2) Borislav Petkov (20): ide-cd: move debug defines into header ide: make IDE_AFLAG_.. numbering continuous again ide-atapi: add a dev_is_idecd-inline ide-atapi: combine drive-specific assignments ide-atapi: setup dma for ide-cd ide-atapi: accomodate transfer length calculation for ide-cd ide-atapi: teach ide atapi about drive->waiting_for_dma ide-cd: move cdrom_timer_expiry to ide-atapi.c ide-atapi: remove ide-scsi remnants from ide_issue_pc ide-atapi: remove ide-scsi remnants from ide_transfer_pc() ide-atapi: remove ide-scsi remnants from ide_pc_intr() ide: remove the last ide-scsi remnants ide-atapi: compute cmd_len based on device type in ide_transfer_pc ide-atapi: assign expiry and timeout based on device type ide-atapi: split drive-specific functionality in ide_issue_pc ide-cd: remove xferlen arg to cdrom_start_packet_command ide-cd: remove handler wrappers ide-atapi: remove timeout arg to ide_issue_pc ide-atapi: put the rest of non-ide-cd code into the else-clause of ide_transfer_pc ide-atapi: start dma in a drive-specific way FUJITA Tomonori (1): remove ide-scsi Linus Torvalds (1): ide-floppy: allocate only toplevel packet commands diff --git a/Documentation/feature-removal-schedule.txt b/Documentation/feature-removal-schedule.txtindex dc7c681..df18d87 100644--- a/Documentation/feature-removal-schedule.txt+++ b/Documentation/feature-removal-schedule.txt@@ -310,15 +310,6 @@ Who: Krzysztof Piotr Oledzki --------------------------- -What: ide-scsi (BLK_DEV_IDESCSI)-When: 2.6.29-Why: The 2.6 kernel supports direct writing to ide CD drives, which- eliminates the need for ide-scsi. The new method is more- efficient in every way.-Who: FUJITA Tomonori ------------------------------ What: i2c_attach_client(), i2c_detach_client(), i2c_driver->detach_client() When: 2.6.29 (ideally) or 2.6.30 (more likely) Why: Deprecated by the new (standard) device driver binding model. Usediff --git a/MAINTAINERS b/MAINTAINERSindex ceb32ee..144766c 100644--- a/MAINTAINERS+++ b/MAINTAINERS@@ -2146,11 +2146,6 @@ M: Gadi Oxman L: linux-kernel@vger.kernel.org S: Maintained -IDE-SCSI DRIVER-L: linux-ide@vger.kernel.org-L: linux-scsi@vger.kernel.org-S: Orphan- IDLE-I7300 P: Andy Henroid M: andrew.d.henroid@intel.comdiff --git a/drivers/ide/Kconfig b/drivers/ide/Kconfigindex c9f21e3..4ee85fc 100644--- a/drivers/ide/Kconfig+++ b/drivers/ide/Kconfig@@ -137,6 +137,7 @@ config BLK_DEV_DELKIN config BLK_DEV_IDECD tristate "Include IDE/ATAPI CDROM support"+ select IDE_ATAPI ---help--- If you have a CD-ROM drive using the ATAPI protocol, say Y. ATAPI is a newer protocol used by IDE CD-ROM and TAPE drives, similar to the@@ -185,23 +186,6 @@ config BLK_DEV_IDETAPE To compile this driver as a module, choose M here: the module will be called ide-tape. -config BLK_DEV_IDESCSI- tristate "SCSI emulation support (DEPRECATED)"- depends on SCSI- select IDE_ATAPI- ---help---- WARNING: ide-scsi is no longer needed for cd writing applications!- The 2.6 kernel supports direct writing to ide-cd, which eliminates- the need for ide-scsi + the entire scsi stack just for writing a- cd. The new method is more efficient in every way.-- This will provide SCSI host adapter emulation for IDE ATAPI devices,- and will allow you to use a SCSI device driver instead of a native- ATAPI driver.-- If both this SCSI emulation and native ATAPI support are compiled- into the kernel, the native support will be used.- config BLK_DEV_IDEACPI bool "IDE ACPI support" depends on ACPIdiff --git a/drivers/ide/Makefile b/drivers/ide/Makefileindex 177e3f8..4107289 100644--- a/drivers/ide/Makefile+++ b/drivers/ide/Makefile@@ -5,7 +5,7 @@ EXTRA_CFLAGS += -Idrivers/ide ide-core-y += ide.o ide-ioctls.o ide-io.o ide-iops.o ide-lib.o ide-probe.o \- ide-taskfile.o ide-pm.o ide-park.o ide-pio-blacklist.o+ ide-taskfile.o ide-pm.o ide-park.o ide-pio-blacklist.o ide-sysfs.o # core IDE code ide-core-$(CONFIG_IDE_TIMINGS) += ide-timings.odiff --git a/drivers/ide/ide-atapi.c b/drivers/ide/ide-atapi.cindex 4e58b9e..e8688c0 100644--- a/drivers/ide/ide-atapi.c+++ b/drivers/ide/ide-atapi.c@@ -3,6 +3,7 @@ */ #include +#include #include #include #include @@ -14,6 +15,13 @@ #define debug_log(fmt, args...) do {} while (0) #endif +#define ATAPI_MIN_CDB_BYTES 12++static inline int dev_is_idecd(ide_drive_t *drive)+{+ return drive->media == ide_cdrom || drive->media == ide_optical;+}+ /* * Check whether we can support a device, * based on the ATAPI IDENTIFY command results.@@ -233,18 +241,49 @@ void ide_retry_pc(ide_drive_t *drive, struct gendisk *disk) } EXPORT_SYMBOL_GPL(ide_retry_pc); -int ide_scsi_expiry(ide_drive_t *drive)+int ide_cd_expiry(ide_drive_t *drive) {- struct ide_atapi_pc *pc = drive->pc;+ struct request *rq = HWGROUP(drive)->rq;+ unsigned long wait = 0; - debug_log("%s called for %lu at %lu\n", __func__,- pc->scsi_cmd->serial_number, jiffies);+ debug_log("%s: rq->cmd[0]: 0x%x\n", __func__, rq->cmd[0]); - pc->flags |= PC_FLAG_TIMEDOUT;+ /*+ * Some commands are *slow* and normally take a long time to complete.+ * Usually we can use the ATAPI "disconnect" to bypass this, but not all+ * commands/drives support that. Let ide_timer_expiry keep polling us+ * for these.+ */+ switch (rq->cmd[0]) {+ case GPCMD_BLANK:+ case GPCMD_FORMAT_UNIT:+ case GPCMD_RESERVE_RZONE_TRACK:+ case GPCMD_CLOSE_TRACK:+ case GPCMD_FLUSH_CACHE:+ wait = ATAPI_WAIT_PC;+ break;+ default:+ if (!(rq->cmd_flags & REQ_QUIET))+ printk(KERN_INFO "cmd 0x%x timed out\n",+ rq->cmd[0]);+ wait = 0;+ break;+ }+ return wait;+}+EXPORT_SYMBOL_GPL(ide_cd_expiry); - return 0; /* we do not want the IDE subsystem to retry */+int ide_cd_get_xferlen(struct request *rq)+{+ if (blk_fs_request(rq))+ return 32768;+ else if (blk_sense_request(rq) || blk_pc_request(rq) ||+ rq->cmd_type == REQ_TYPE_ATA_PC)+ return rq->data_len;+ else+ return 0; }-EXPORT_SYMBOL_GPL(ide_scsi_expiry);+EXPORT_SYMBOL_GPL(ide_cd_get_xferlen); /* * This is the usual interrupt handler which will be called during a packet@@ -258,21 +297,14 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive) struct request *rq = hwif->hwgroup->rq; const struct ide_tp_ops *tp_ops = hwif->tp_ops; xfer_func_t *xferfunc;- ide_expiry_t *expiry; unsigned int timeout, temp; u16 bcount;- u8 stat, ireason, scsi = !!(drive->dev_flags & IDE_DFLAG_SCSI), dsc = 0;+ u8 stat, ireason, dsc = 0; debug_log("Enter %s - interrupt handler\n", __func__); - if (scsi) {- timeout = ide_scsi_get_timeout(pc);- expiry = ide_scsi_expiry;- } else {- timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD- : WAIT_TAPE_CMD;- expiry = NULL;- }+ timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD+ : WAIT_TAPE_CMD; if (pc->flags & PC_FLAG_TIMEDOUT) { drive->pc_callback(drive, 0);@@ -284,8 +316,8 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive) if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) { if (hwif->dma_ops->dma_end(drive) ||- (drive->media == ide_tape && !scsi && (stat & ATA_ERR))) {- if (drive->media == ide_floppy && !scsi)+ (drive->media == ide_tape && (stat & ATA_ERR))) {+ if (drive->media == ide_floppy) printk(KERN_ERR "%s: DMA %s error\n", drive->name, rq_data_dir(pc->rq) ? "write" : "read");@@ -307,7 +339,7 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive) local_irq_enable_in_hardirq(); - if (drive->media == ide_tape && !scsi &&+ if (drive->media == ide_tape && (stat & ATA_ERR) && rq->cmd[0] == REQUEST_SENSE) stat &= ~ATA_ERR; @@ -315,11 +347,8 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive) /* Error detected */ debug_log("%s: I/O error\n", drive->name); - if (drive->media != ide_tape || scsi) {+ if (drive->media != ide_tape) pc->rq->errors++;- if (scsi)- goto cmd_finished;- } if (rq->cmd[0] == REQUEST_SENSE) { printk(KERN_ERR "%s: I/O error in request sense"@@ -335,7 +364,6 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive) /* queued, but not started */ return ide_stopped; }-cmd_finished: pc->error = 0; if ((pc->flags & PC_FLAG_WAIT_FOR_DSC) && (stat & ATA_DSC) == 0)@@ -382,25 +410,8 @@ cmd_finished: "us more data than expected - " "discarding data\n", drive->name);- if (scsi)- temp = pc->buf_size - pc->xferred;- else- temp = 0;- if (temp) {- if (pc->sg)- drive->pc_io_buffers(drive, pc,- temp, 0);- else- tp_ops->input_data(drive, NULL,- pc->cur_pos, temp);- printk(KERN_ERR "%s: transferred %d of "- "%d bytes\n",- drive->name,- temp, bcount);- }- pc->xferred += temp;- pc->cur_pos += temp;- ide_pad_transfer(drive, 0, bcount - temp);++ ide_pad_transfer(drive, 0, bcount); goto next_irq; } debug_log("The device wants to send us more data than "@@ -410,14 +421,13 @@ cmd_finished: } else xferfunc = tp_ops->output_data; - if ((drive->media == ide_floppy && !scsi && !pc->buf) ||- (drive->media == ide_tape && !scsi && pc->bh) ||- (scsi && pc->sg)) {+ if ((drive->media == ide_floppy && !pc->buf) ||+ (drive->media == ide_tape && pc->bh)) { int done = drive->pc_io_buffers(drive, pc, bcount, !!(pc->flags & PC_FLAG_WRITING)); /* FIXME: don't do partial completions */- if (drive->media == ide_floppy && !scsi)+ if (drive->media == ide_floppy) ide_end_request(drive, 1, done >> 9); } else xferfunc(drive, NULL, pc->cur_pos, bcount);@@ -430,7 +440,7 @@ cmd_finished: rq->cmd[0], bcount); next_irq: /* And set the interrupt handler again */- ide_set_handler(drive, ide_pc_intr, timeout, expiry);+ ide_set_handler(drive, ide_pc_intr, timeout, NULL); return ide_started; } @@ -479,11 +489,12 @@ static int ide_delayed_transfer_pc(ide_drive_t *drive) static ide_startstop_t ide_transfer_pc(ide_drive_t *drive) {- struct ide_atapi_pc *pc = drive->pc;+ struct ide_atapi_pc *uninitialized_var(pc); ide_hwif_t *hwif = drive->hwif; struct request *rq = hwif->hwgroup->rq; ide_expiry_t *expiry; unsigned int timeout;+ int cmd_len; ide_startstop_t startstop; u8 ireason; @@ -493,101 +504,124 @@ static ide_startstop_t ide_transfer_pc(ide_drive_t *drive) return startstop; } - ireason = ide_read_ireason(drive);- if (drive->media == ide_tape &&- (drive->dev_flags & IDE_DFLAG_SCSI) == 0)- ireason = ide_wait_ireason(drive, ireason);-- if ((ireason & ATAPI_COD) == 0 || (ireason & ATAPI_IO)) {- printk(KERN_ERR "%s: (IO,CoD) != (0,1) while issuing "- "a packet command\n", drive->name);- return ide_do_reset(drive);+ if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {+ if (drive->dma)+ drive->waiting_for_dma = 1; } - /*- * If necessary schedule the packet transfer to occur 'timeout'- * miliseconds later in ide_delayed_transfer_pc() after the device- * says it's ready for a packet.- */- if (drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) {- timeout = drive->pc_delay;- expiry = &ide_delayed_transfer_pc;+ if (dev_is_idecd(drive)) {+ /* ATAPI commands get padded out to 12 bytes minimum */+ cmd_len = COMMAND_SIZE(rq->cmd[0]);+ if (cmd_len < ATAPI_MIN_CDB_BYTES)+ cmd_len = ATAPI_MIN_CDB_BYTES;++ timeout = rq->timeout;+ expiry = ide_cd_expiry; } else {- if (drive->dev_flags & IDE_DFLAG_SCSI) {- timeout = ide_scsi_get_timeout(pc);- expiry = ide_scsi_expiry;+ pc = drive->pc;++ cmd_len = ATAPI_MIN_CDB_BYTES;++ /*+ * If necessary schedule the packet transfer to occur 'timeout'+ * miliseconds later in ide_delayed_transfer_pc() after the+ * device says it's ready for a packet.+ */+ if (drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) {+ timeout = drive->pc_delay;+ expiry = &ide_delayed_transfer_pc; } else { timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD : WAIT_TAPE_CMD; expiry = NULL; }++ ireason = ide_read_ireason(drive);+ if (drive->media == ide_tape)+ ireason = ide_wait_ireason(drive, ireason);++ if ((ireason & ATAPI_COD) == 0 || (ireason & ATAPI_IO)) {+ printk(KERN_ERR "%s: (IO,CoD) != (0,1) while issuing "+ "a packet command\n", drive->name);++ return ide_do_reset(drive);+ } } /* Set the interrupt routine */ ide_set_handler(drive, ide_pc_intr, timeout, expiry); /* Begin DMA, if necessary */- if (pc->flags & PC_FLAG_DMA_OK) {- pc->flags |= PC_FLAG_DMA_IN_PROGRESS;- hwif->dma_ops->dma_start(drive);+ if (dev_is_idecd(drive)) {+ if (drive->dma)+ hwif->dma_ops->dma_start(drive);+ } else {+ if (pc->flags & PC_FLAG_DMA_OK) {+ pc->flags |= PC_FLAG_DMA_IN_PROGRESS;+ hwif->dma_ops->dma_start(drive);+ } } /* Send the actual packet */ if ((drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) == 0)- hwif->tp_ops->output_data(drive, NULL, rq->cmd, 12);+ hwif->tp_ops->output_data(drive, NULL, rq->cmd, cmd_len); return ide_started; } -ide_startstop_t ide_issue_pc(ide_drive_t *drive, unsigned int timeout,- ide_expiry_t *expiry)+ide_startstop_t ide_issue_pc(ide_drive_t *drive) {- struct ide_atapi_pc *pc = drive->pc;+ struct ide_atapi_pc *pc; ide_hwif_t *hwif = drive->hwif;+ ide_expiry_t *expiry = NULL;+ unsigned int timeout; u32 tf_flags; u16 bcount;- u8 scsi = !!(drive->dev_flags & IDE_DFLAG_SCSI); - /* We haven't transferred any data yet */- pc->xferred = 0;- pc->cur_pos = pc->buf;+ if (dev_is_idecd(drive)) {+ tf_flags = IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL;+ bcount = ide_cd_get_xferlen(hwif->hwgroup->rq);+ expiry = ide_cd_expiry;+ timeout = ATAPI_WAIT_PC; - /* Request to transfer the entire buffer at once */- if (drive->media == ide_tape && scsi == 0)- bcount = pc->req_xfer;- else- bcount = min(pc->req_xfer, 63 * 1024);+ if (drive->dma)+ drive->dma = !hwif->dma_ops->dma_setup(drive);+ } else {+ pc = drive->pc; - if (pc->flags & PC_FLAG_DMA_ERROR) {- pc->flags &= ~PC_FLAG_DMA_ERROR;- ide_dma_off(drive);- }+ /* We haven't transferred any data yet */+ pc->xferred = 0;+ pc->cur_pos = pc->buf; - if ((pc->flags & PC_FLAG_DMA_OK) &&- (drive->dev_flags & IDE_DFLAG_USING_DMA)) {- if (scsi)- hwif->sg_mapped = 1;- drive->dma = !hwif->dma_ops->dma_setup(drive);- if (scsi)- hwif->sg_mapped = 0;- }+ tf_flags = IDE_TFLAG_OUT_DEVICE;+ bcount = ((drive->media == ide_tape) ?+ pc->req_xfer :+ min(pc->req_xfer, 63 * 1024)); - if (!drive->dma)- pc->flags &= ~PC_FLAG_DMA_OK;+ if (pc->flags & PC_FLAG_DMA_ERROR) {+ pc->flags &= ~PC_FLAG_DMA_ERROR;+ ide_dma_off(drive);+ } - if (scsi)- tf_flags = 0;- else if (drive->media == ide_cdrom || drive->media == ide_optical)- tf_flags = IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL;- else- tf_flags = IDE_TFLAG_OUT_DEVICE;+ if ((pc->flags & PC_FLAG_DMA_OK) &&+ (drive->dev_flags & IDE_DFLAG_USING_DMA))+ drive->dma = !hwif->dma_ops->dma_setup(drive);++ if (!drive->dma)+ pc->flags &= ~PC_FLAG_DMA_OK;++ timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD+ : WAIT_TAPE_CMD;+ } ide_pktcmd_tf_load(drive, tf_flags, bcount, drive->dma); /* Issue the packet command */ if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {+ if (drive->dma)+ drive->waiting_for_dma = 0; ide_execute_command(drive, ATA_CMD_PACKET, ide_transfer_pc,- timeout, NULL);+ timeout, expiry); return ide_started; } else { ide_execute_pkt_cmd(drive);diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.cindex 5daa4dd..1a7410f 100644--- a/drivers/ide/ide-cd.c+++ b/drivers/ide/ide-cd.c@@ -53,14 +53,6 @@ #include "ide-cd.h" -#define IDECD_DEBUG_LOG 1--#if IDECD_DEBUG_LOG-#define ide_debug_log(lvl, fmt, args...) __ide_debug_log(lvl, fmt, args)-#else-#define ide_debug_log(lvl, fmt, args...) do {} while (0)-#endif- static DEFINE_MUTEX(idecd_ref_mutex); static void ide_cd_release(struct kref *);@@ -519,37 +511,8 @@ end_request: return 1; } -static int cdrom_timer_expiry(ide_drive_t *drive)-{- struct request *rq = HWGROUP(drive)->rq;- unsigned long wait = 0;-- ide_debug_log(IDE_DBG_RQ, "Call %s: rq->cmd[0]: 0x%x\n", __func__,- rq->cmd[0]);-- /*- * Some commands are *slow* and normally take a long time to complete.- * Usually we can use the ATAPI "disconnect" to bypass this, but not all- * commands/drives support that. Let ide_timer_expiry keep polling us- * for these.- */- switch (rq->cmd[0]) {- case GPCMD_BLANK:- case GPCMD_FORMAT_UNIT:- case GPCMD_RESERVE_RZONE_TRACK:- case GPCMD_CLOSE_TRACK:- case GPCMD_FLUSH_CACHE:- wait = ATAPI_WAIT_PC;- break;- default:- if (!(rq->cmd_flags & REQ_QUIET))- printk(KERN_INFO PFX "cmd 0x%x timed out\n",- rq->cmd[0]);- wait = 0;- break;- }- return wait;-}+static ide_startstop_t cdrom_transfer_packet_command(ide_drive_t *);+static ide_startstop_t cdrom_newpc_intr(ide_drive_t *); /* * Set up the device registers for transferring a packet command on DEV,@@ -559,11 +522,13 @@ static int cdrom_timer_expiry(ide_drive_t *drive) * called when the interrupt from the drive arrives. Otherwise, HANDLER * will be called immediately after the drive is prepared for the transfer. */-static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,- int xferlen,- ide_handler_t *handler)+static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive) { ide_hwif_t *hwif = drive->hwif;+ struct request *rq = hwif->hwgroup->rq;+ int xferlen;++ xferlen = ide_cd_get_xferlen(rq); ide_debug_log(IDE_DBG_PC, "Call %s, xferlen: %d\n", __func__, xferlen); @@ -581,13 +546,14 @@ static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive, drive->waiting_for_dma = 0; /* packet command */- ide_execute_command(drive, ATA_CMD_PACKET, handler,- ATAPI_WAIT_PC, cdrom_timer_expiry);+ ide_execute_command(drive, ATA_CMD_PACKET,+ cdrom_transfer_packet_command,+ ATAPI_WAIT_PC, ide_cd_expiry); return ide_started; } else { ide_execute_pkt_cmd(drive); - return (*handler) (drive);+ return cdrom_transfer_packet_command(drive); } } @@ -598,11 +564,10 @@ static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive, * there's data ready. */ #define ATAPI_MIN_CDB_BYTES 12-static ide_startstop_t cdrom_transfer_packet_command(ide_drive_t *drive,- struct request *rq,- ide_handler_t *handler)+static ide_startstop_t cdrom_transfer_packet_command(ide_drive_t *drive) { ide_hwif_t *hwif = drive->hwif;+ struct request *rq = hwif->hwgroup->rq; int cmd_len; ide_startstop_t startstop; @@ -629,7 +594,7 @@ static ide_startstop_t cdrom_transfer_packet_command(ide_drive_t *drive, } /* arm the interrupt handler */- ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);+ ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, ide_cd_expiry); /* ATAPI commands get padded out to 12 bytes minimum */ cmd_len = COMMAND_SIZE(rq->cmd[0]);@@ -717,8 +682,6 @@ static int ide_cd_check_transfer_size(ide_drive_t *drive, int len) return 1; } -static ide_startstop_t cdrom_newpc_intr(ide_drive_t *);- static ide_startstop_t ide_cd_prepare_rw_request(ide_drive_t *drive, struct request *rq) {@@ -761,20 +724,6 @@ static ide_startstop_t ide_cd_prepare_rw_request(ide_drive_t *drive, } /*- * Routine to send a read/write packet command to the drive. This is usually- * called directly from cdrom_start_{read,write}(). However, for drq_interrupt- * devices, it is called from an interrupt when the drive is ready to accept- * the command.- */-static ide_startstop_t cdrom_start_rw_cont(ide_drive_t *drive)-{- struct request *rq = drive->hwif->hwgroup->rq;-- /* send the command to the drive and return */- return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);-}--/* * Fix up a possibly partially-processed request so that we can start it over * entirely, or even put it back on the request queue. */@@ -1096,7 +1045,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive) } else { timeout = ATAPI_WAIT_PC; if (!blk_fs_request(rq))- expiry = cdrom_timer_expiry;+ expiry = ide_cd_expiry; } ide_set_handler(drive, cdrom_newpc_intr, timeout, expiry);@@ -1163,13 +1112,6 @@ static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq) return ide_started; } -static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)-{- struct request *rq = HWGROUP(drive)->rq;-- return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);-}- static void cdrom_do_block_pc(ide_drive_t *drive, struct request *rq) { @@ -1214,18 +1156,12 @@ static void cdrom_do_block_pc(ide_drive_t *drive, struct request *rq) static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq, sector_t block) {- ide_handler_t *fn;- int xferlen;- ide_debug_log(IDE_DBG_RQ, "Call %s, rq->cmd[0]: 0x%x, " "rq->cmd_type: 0x%x, block: %llu\n", __func__, rq->cmd[0], rq->cmd_type, (unsigned long long)block); if (blk_fs_request(rq)) {- xferlen = 32768;- fn = cdrom_start_rw_cont;- if (cdrom_start_rw(drive, rq) == ide_stopped) return ide_stopped; @@ -1233,9 +1169,6 @@ static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq, return ide_stopped; } else if (blk_sense_request(rq) || blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) {- xferlen = rq->data_len;- fn = cdrom_do_newpc_cont;- if (!rq->timeout) rq->timeout = ATAPI_WAIT_PC; @@ -1250,7 +1183,7 @@ static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq, return ide_stopped; } - return cdrom_start_packet_command(drive, xferlen, fn);+ return cdrom_start_packet_command(drive); } /*diff --git a/drivers/ide/ide-cd.h b/drivers/ide/ide-cd.hindex d5ce336..bf676b2 100644--- a/drivers/ide/ide-cd.h+++ b/drivers/ide/ide-cd.h@@ -8,10 +8,14 @@ #include #include -/*- * typical timeout for packet command- */-#define ATAPI_WAIT_PC (60 * HZ)+#define IDECD_DEBUG_LOG 0++#if IDECD_DEBUG_LOG+#define ide_debug_log(lvl, fmt, args...) __ide_debug_log(lvl, fmt, args)+#else+#define ide_debug_log(lvl, fmt, args...) do {} while (0)+#endif+ #define ATAPI_WAIT_WRITE_BUSY (10 * HZ) /************************************************************************/diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.cindex aeb1ad7..0a48e2d 100644--- a/drivers/ide/ide-floppy.c+++ b/drivers/ide/ide-floppy.c@@ -197,7 +197,7 @@ static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive, pc->retries++; - return ide_issue_pc(drive, WAIT_FLOPPY_CMD, NULL);+ return ide_issue_pc(drive); } void ide_floppy_create_read_capacity_cmd(struct ide_atapi_pc *pc)@@ -342,38 +342,38 @@ static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive, * Look at the flexible disk page parameters. We ignore the CHS capacity * parameters and use the LBA parameters instead. */-static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)+static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive,+ struct ide_atapi_pc *pc) { struct ide_disk_obj *floppy = drive->driver_data; struct gendisk *disk = floppy->disk;- struct ide_atapi_pc pc; u8 *page; int capacity, lba_capacity; u16 transfer_rate, sector_size, cyls, rpm; u8 heads, sectors; - ide_floppy_create_mode_sense_cmd(&pc, IDEFLOPPY_FLEXIBLE_DISK_PAGE);+ ide_floppy_create_mode_sense_cmd(pc, IDEFLOPPY_FLEXIBLE_DISK_PAGE); - if (ide_queue_pc_tail(drive, disk, &pc)) {+ if (ide_queue_pc_tail(drive, disk, pc)) { printk(KERN_ERR PFX "Can't get flexible disk page params\n"); return 1; } - if (pc.buf[3] & 0x80)+ if (pc->buf[3] & 0x80) drive->dev_flags |= IDE_DFLAG_WP; else drive->dev_flags &= ~IDE_DFLAG_WP; set_disk_ro(disk, !!(drive->dev_flags & IDE_DFLAG_WP)); - page = &pc.buf[8];+ page = &pc->buf[8]; - transfer_rate = be16_to_cpup((__be16 *)&pc.buf[8 + 2]);- sector_size = be16_to_cpup((__be16 *)&pc.buf[8 + 6]);- cyls = be16_to_cpup((__be16 *)&pc.buf[8 + 8]);- rpm = be16_to_cpup((__be16 *)&pc.buf[8 + 28]);- heads = pc.buf[8 + 4];- sectors = pc.buf[8 + 5];+ transfer_rate = be16_to_cpup((__be16 *)&pc->buf[8 + 2]);+ sector_size = be16_to_cpup((__be16 *)&pc->buf[8 + 6]);+ cyls = be16_to_cpup((__be16 *)&pc->buf[8 + 8]);+ rpm = be16_to_cpup((__be16 *)&pc->buf[8 + 28]);+ heads = pc->buf[8 + 4];+ sectors = pc->buf[8 + 5]; capacity = cyls * heads * sectors * sector_size; @@ -499,7 +499,7 @@ static int ide_floppy_get_capacity(ide_drive_t *drive) /* Clik! disk does not support get_flexible_disk_page */ if (!(drive->atapi_flags & IDE_AFLAG_CLIK_DRIVE))- (void) ide_floppy_get_flexible_disk_page(drive);+ (void) ide_floppy_get_flexible_disk_page(drive, &pc); return rc; }diff --git a/drivers/ide/ide-floppy_ioctl.c b/drivers/ide/ide-floppy_ioctl.cindex 2bc51ff..8f8be85 100644--- a/drivers/ide/ide-floppy_ioctl.c+++ b/drivers/ide/ide-floppy_ioctl.c@@ -31,10 +31,11 @@ * On exit we set nformats to the number of records we've actually initialized. */ -static int ide_floppy_get_format_capacities(ide_drive_t *drive, int __user *arg)+static int ide_floppy_get_format_capacities(ide_drive_t *drive,+ struct ide_atapi_pc *pc,+ int __user *arg) { struct ide_disk_obj *floppy = drive->driver_data;- struct ide_atapi_pc pc; u8 header_len, desc_cnt; int i, blocks, length, u_array_size, u_index; int __user *argp;@@ -45,13 +46,13 @@ static int ide_floppy_get_format_capacities(ide_drive_t *drive, int __user *arg) if (u_array_size <= 0) return -EINVAL; - ide_floppy_create_read_capacity_cmd(&pc);- if (ide_queue_pc_tail(drive, floppy->disk, &pc)) {+ ide_floppy_create_read_capacity_cmd(pc);+ if (ide_queue_pc_tail(drive, floppy->disk, pc)) { printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n"); return -EIO; } - header_len = pc.buf[3];+ header_len = pc->buf[3]; desc_cnt = header_len / 8; /* capacity descriptor of 8 bytes */ u_index = 0;@@ -68,8 +69,8 @@ static int ide_floppy_get_format_capacities(ide_drive_t *drive, int __user *arg) if (u_index >= u_array_size) break; /* User-supplied buffer too small */ - blocks = be32_to_cpup((__be32 *)&pc.buf[desc_start]);- length = be16_to_cpup((__be16 *)&pc.buf[desc_start + 6]);+ blocks = be32_to_cpup((__be32 *)&pc->buf[desc_start]);+ length = be16_to_cpup((__be16 *)&pc->buf[desc_start + 6]); if (put_user(blocks, argp)) return -EFAULT;@@ -111,29 +112,28 @@ static void ide_floppy_create_format_unit_cmd(struct ide_atapi_pc *pc, int b, pc->flags |= PC_FLAG_WRITING; } -static int ide_floppy_get_sfrp_bit(ide_drive_t *drive)+static int ide_floppy_get_sfrp_bit(ide_drive_t *drive, struct ide_atapi_pc *pc) { struct ide_disk_obj *floppy = drive->driver_data;- struct ide_atapi_pc pc; drive->atapi_flags &= ~IDE_AFLAG_SRFP; - ide_floppy_create_mode_sense_cmd(&pc, IDEFLOPPY_CAPABILITIES_PAGE);- pc.flags |= PC_FLAG_SUPPRESS_ERROR;+ ide_floppy_create_mode_sense_cmd(pc, IDEFLOPPY_CAPABILITIES_PAGE);+ pc->flags |= PC_FLAG_SUPPRESS_ERROR; - if (ide_queue_pc_tail(drive, floppy->disk, &pc))+ if (ide_queue_pc_tail(drive, floppy->disk, pc)) return 1; - if (pc.buf[8 + 2] & 0x40)+ if (pc->buf[8 + 2] & 0x40) drive->atapi_flags |= IDE_AFLAG_SRFP; return 0; } -static int ide_floppy_format_unit(ide_drive_t *drive, int __user *arg)+static int ide_floppy_format_unit(ide_drive_t *drive, struct ide_atapi_pc *pc,+ int __user *arg) { struct ide_disk_obj *floppy = drive->driver_data;- struct ide_atapi_pc pc; int blocks, length, flags, err = 0; if (floppy->openers > 1) {@@ -166,10 +166,10 @@ static int ide_floppy_format_unit(ide_drive_t *drive, int __user *arg) goto out; } - (void)ide_floppy_get_sfrp_bit(drive);- ide_floppy_create_format_unit_cmd(&pc, blocks, length, flags);+ ide_floppy_get_sfrp_bit(drive, pc);+ ide_floppy_create_format_unit_cmd(pc, blocks, length, flags); - if (ide_queue_pc_tail(drive, floppy->disk, &pc))+ if (ide_queue_pc_tail(drive, floppy->disk, pc)) err = -EIO; out:@@ -188,15 +188,16 @@ out: * the dsc bit, and return either 0 or 65536. */ -static int ide_floppy_get_format_progress(ide_drive_t *drive, int __user *arg)+static int ide_floppy_get_format_progress(ide_drive_t *drive,+ struct ide_atapi_pc *pc,+ int __user *arg) { struct ide_disk_obj *floppy = drive->driver_data;- struct ide_atapi_pc pc; int progress_indication = 0x10000; if (drive->atapi_flags & IDE_AFLAG_SRFP) {- ide_create_request_sense_cmd(drive, &pc);- if (ide_queue_pc_tail(drive, floppy->disk, &pc))+ ide_create_request_sense_cmd(drive, pc);+ if (ide_queue_pc_tail(drive, floppy->disk, pc)) return -EIO; if (floppy->sense_key == 2 &&@@ -241,20 +242,21 @@ static int ide_floppy_lockdoor(ide_drive_t *drive, struct ide_atapi_pc *pc, return 0; } -static int ide_floppy_format_ioctl(ide_drive_t *drive, fmode_t mode,- unsigned int cmd, void __user *argp)+static int ide_floppy_format_ioctl(ide_drive_t *drive, struct ide_atapi_pc *pc,+ fmode_t mode, unsigned int cmd,+ void __user *argp) { switch (cmd) { case IDEFLOPPY_IOCTL_FORMAT_SUPPORTED: return 0; case IDEFLOPPY_IOCTL_FORMAT_GET_CAPACITY:- return ide_floppy_get_format_capacities(drive, argp);+ return ide_floppy_get_format_capacities(drive, pc, argp); case IDEFLOPPY_IOCTL_FORMAT_START: if (!(mode & FMODE_WRITE)) return -EPERM;- return ide_floppy_format_unit(drive, (int __user *)argp);+ return ide_floppy_format_unit(drive, pc, (int __user *)argp); case IDEFLOPPY_IOCTL_FORMAT_GET_PROGRESS:- return ide_floppy_get_format_progress(drive, argp);+ return ide_floppy_get_format_progress(drive, pc, argp); default: return -ENOTTY; }@@ -270,7 +272,7 @@ int ide_floppy_ioctl(ide_drive_t *drive, struct block_device *bdev, if (cmd == CDROMEJECT || cmd == CDROM_LOCKDOOR) return ide_floppy_lockdoor(drive, &pc, arg, cmd); - err = ide_floppy_format_ioctl(drive, mode, cmd, argp);+ err = ide_floppy_format_ioctl(drive, &pc, mode, cmd, argp); if (err != -ENOTTY) return err; diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.cindex ecacc00..1c36a8e 100644--- a/drivers/ide/ide-io.c+++ b/drivers/ide/ide-io.c@@ -426,9 +426,6 @@ void ide_map_sg(ide_drive_t *drive, struct request *rq) ide_hwif_t *hwif = drive->hwif; struct scatterlist *sg = hwif->sg_table; - if (hwif->sg_mapped) /* needed by ide-scsi */- return;- if (rq->cmd_type != REQ_TYPE_ATA_TASKFILE) { hwif->sg_nents = blk_rq_map_sg(drive->queue, rq, sg); } else {@@ -667,85 +664,10 @@ void ide_stall_queue (ide_drive_t *drive, unsigned long timeout) drive->sleep = timeout + jiffies; drive->dev_flags |= IDE_DFLAG_SLEEPING; }- EXPORT_SYMBOL(ide_stall_queue); -#define WAKEUP(drive) ((drive)->service_start + 2 * (drive)->service_time)--/**- * choose_drive - select a drive to service- * @hwgroup: hardware group to select on- *- * choose_drive() selects the next drive which will be serviced.- * This is necessary because the IDE layer can't issue commands- * to both drives on the same cable, unlike SCSI.- */- -static inline ide_drive_t *choose_drive (ide_hwgroup_t *hwgroup)-{- ide_drive_t *drive, *best;--repeat: - best = NULL;- drive = hwgroup->drive;-- /*- * drive is doing pre-flush, ordered write, post-flush sequence. even- * though that is 3 requests, it must be seen as a single transaction.- * we must not preempt this drive until that is complete- */- if (blk_queue_flushing(drive->queue)) {- /*- * small race where queue could get replugged during- * the 3-request flush cycle, just yank the plug since- * we want it to finish asap- */- blk_remove_plug(drive->queue);- return drive;- }-- do {- u8 dev_s = !!(drive->dev_flags & IDE_DFLAG_SLEEPING);- u8 best_s = (best && !!(best->dev_flags & IDE_DFLAG_SLEEPING));-- if ((dev_s == 0 || time_after_eq(jiffies, drive->sleep)) &&- !elv_queue_empty(drive->queue)) {- if (best == NULL ||- (dev_s && (best_s == 0 || time_before(drive->sleep, best->sleep))) ||- (best_s == 0 && time_before(WAKEUP(drive), WAKEUP(best)))) {- if (!blk_queue_plugged(drive->queue))- best = drive;- }- }- } while ((drive = drive->next) != hwgroup->drive);-- if (best && (best->dev_flags & IDE_DFLAG_NICE1) &&- (best->dev_flags & IDE_DFLAG_SLEEPING) == 0 &&- best != hwgroup->drive && best->service_time > WAIT_MIN_SLEEP) {- long t = (signed long)(WAKEUP(best) - jiffies);- if (t >= WAIT_MIN_SLEEP) {- /*- * We *may* have some time to spare, but first let's see if- * someone can potentially benefit from our nice mood today..- */- drive = best->next;- do {- if ((drive->dev_flags & IDE_DFLAG_SLEEPING) == 0- && time_before(jiffies - best->service_time, WAKEUP(drive))- && time_before(WAKEUP(drive), jiffies + t))- {- ide_stall_queue(best, min_t(long, t, 10 * WAIT_MIN_SLEEP));- goto repeat;- }- } while ((drive = drive->next) != best);- }- }- return best;-}- /* * Issue a new request to a drive from hwgroup- * Caller must have already done spin_lock_irqsave(&hwgroup->lock, ..); * * A hwgroup is a serialized group of IDE interfaces. Usually there is * exactly one hwif (interface) per hwgroup, but buggy controllers (eg. CMD640)@@ -757,8 +679,7 @@ repeat: * possibly along with many other devices. This is especially common in * PCI-based systems with off-board IDE controller cards. *- * The IDE driver uses a per-hwgroup spinlock to protect- * access to the request queues, and to protect the hwgroup->busy flag.+ * The IDE driver uses a per-hwgroup lock to protect the hwgroup->busy flag. * * The first thread into the driver for a particular hwgroup sets the * hwgroup->busy flag to indicate that this hwgroup is now active,@@ -778,69 +699,41 @@ repeat: * the driver. This makes the driver much more friendlier to shared IRQs * than previous designs, while remaining 100% (?) SMP safe and capable. */-static void ide_do_request (ide_hwgroup_t *hwgroup, int masked_irq)+void do_ide_request(struct request_queue *q) {- ide_drive_t *drive;- ide_hwif_t *hwif;+ ide_drive_t *drive = q->queuedata;+ ide_hwif_t *hwif = drive->hwif;+ ide_hwgroup_t *hwgroup = hwif->hwgroup; struct request *rq; ide_startstop_t startstop;- int loops = 0;-- /* caller must own hwgroup->lock */- BUG_ON(!irqs_disabled());-- while (!hwgroup->busy) {- hwgroup->busy = 1;- /* for atari only */- ide_get_lock(ide_intr, hwgroup);- drive = choose_drive(hwgroup);- if (drive == NULL) {- int sleeping = 0;- unsigned long sleep = 0; /* shut up, gcc */- hwgroup->rq = NULL;- drive = hwgroup->drive;- do {- if ((drive->dev_flags & IDE_DFLAG_SLEEPING) &&- (sleeping == 0 ||- time_before(drive->sleep, sleep))) {- sleeping = 1;- sleep = drive->sleep;- }- } while ((drive = drive->next) != hwgroup->drive);- if (sleeping) {++ /*+ * drive is doing pre-flush, ordered write, post-flush sequence. even+ * though that is 3 requests, it must be seen as a single transaction.+ * we must not preempt this drive until that is complete+ */+ if (blk_queue_flushing(q)) /*- * Take a short snooze, and then wake up this hwgroup again.- * This gives other hwgroups on the same a chance to- * play fairly with us, just in case there are big differences- * in relative throughputs.. don't want to hog the cpu too much.+ * small race where queue could get replugged during+ * the 3-request flush cycle, just yank the plug since+ * we want it to finish asap */- if (time_before(sleep, jiffies + WAIT_MIN_SLEEP))- sleep = jiffies + WAIT_MIN_SLEEP;-#if 1- if (timer_pending(&hwgroup->timer))- printk(KERN_CRIT "ide_set_handler: timer already active\n");-#endif- /* so that ide_timer_expiry knows what to do */- hwgroup->sleeping = 1;- hwgroup->req_gen_timer = hwgroup->req_gen;- mod_timer(&hwgroup->timer, sleep);- /* we purposely leave hwgroup->busy==1- * while sleeping */- } else {- /* Ugly, but how can we sleep for the lock- * otherwise? perhaps from tq_disk?- */+ blk_remove_plug(q); - /* for atari only */- ide_release_lock();- hwgroup->busy = 0;- }+ spin_unlock_irq(q->queue_lock);+ spin_lock_irq(&hwgroup->lock);++ if (!ide_lock_hwgroup(hwgroup)) {+repeat:+ hwgroup->rq = NULL; - /* no more work for this hwgroup (for now) */- return;+ if (drive->dev_flags & IDE_DFLAG_SLEEPING) {+ if (time_before(drive->sleep, jiffies)) {+ ide_unlock_hwgroup(hwgroup);+ goto plug_device;+ } }- again:- hwif = HWIF(drive);+ if (hwif != hwgroup->hwif) { /* * set nIEN for previous hwif, drives in the@@ -852,16 +745,20 @@ static void ide_do_request (ide_hwgroup_t *hwgroup, int masked_irq) hwgroup->hwif = hwif; hwgroup->drive = drive; drive->dev_flags &= ~(IDE_DFLAG_SLEEPING | IDE_DFLAG_PARKED);- drive->service_start = jiffies; + spin_unlock_irq(&hwgroup->lock);+ spin_lock_irq(q->queue_lock); /* * we know that the queue isn't empty, but this can happen * if the q->prep_rq_fn() decides to kill a request */ rq = elv_next_request(drive->queue);+ spin_unlock_irq(q->queue_lock);+ spin_lock_irq(&hwgroup->lock);+ if (!rq) {- hwgroup->busy = 0;- break;+ ide_unlock_hwgroup(hwgroup);+ goto out; } /*@@ -876,53 +773,36 @@ static void ide_do_request (ide_hwgroup_t *hwgroup, int masked_irq) * though. I hope that doesn't happen too much, hopefully not * unless the subdriver triggers such a thing in its own PM * state machine.- *- * We count how many times we loop here to make sure we service- * all drives in the hwgroup without looping for ever */ if ((drive->dev_flags & IDE_DFLAG_BLOCKED) && blk_pm_request(rq) == 0 && (rq->cmd_flags & REQ_PREEMPT) == 0) {- drive = drive->next ? drive->next : hwgroup->drive;- if (loops++ < 4 && !blk_queue_plugged(drive->queue))- goto again;- /* We clear busy, there should be no pending ATA command at this point. */- hwgroup->busy = 0;- break;+ /* there should be no pending command at this point */+ ide_unlock_hwgroup(hwgroup);+ goto plug_device; } hwgroup->rq = rq; - /*- * Some systems have trouble with IDE IRQs arriving while- * the driver is still setting things up. So, here we disable- * the IRQ used by this interface while the request is being started.- * This may look bad at first, but pretty much the same thing- * happens anyway when any interrupt comes in, IDE or otherwise- * -- the kernel masks the IRQ while it is being handled.- */- if (masked_irq != IDE_NO_IRQ && hwif->irq != masked_irq)- disable_irq_nosync(hwif->irq);- spin_unlock(&hwgroup->lock);- local_irq_enable_in_hardirq();- /* allow other IRQs while we start this request */+ spin_unlock_irq(&hwgroup->lock); startstop = start_request(drive, rq); spin_lock_irq(&hwgroup->lock);- if (masked_irq != IDE_NO_IRQ && hwif->irq != masked_irq)- enable_irq(hwif->irq);+ if (startstop == ide_stopped)- hwgroup->busy = 0;- }-}+ goto repeat;+ } else+ goto plug_device;+out:+ spin_unlock_irq(&hwgroup->lock);+ spin_lock_irq(q->queue_lock);+ return; -/*- * Passes the stuff to ide_do_request- */-void do_ide_request(struct request_queue *q)-{- ide_drive_t *drive = q->queuedata;+plug_device:+ spin_unlock_irq(&hwgroup->lock);+ spin_lock_irq(q->queue_lock); - ide_do_request(HWGROUP(drive), IDE_NO_IRQ);+ if (!elv_queue_empty(q))+ blk_plug_device(q); } /*@@ -983,6 +863,17 @@ out: return ret; } +static void ide_plug_device(ide_drive_t *drive)+{+ struct request_queue *q = drive->queue;+ unsigned long flags;++ spin_lock_irqsave(q->queue_lock, flags);+ if (!elv_queue_empty(q))+ blk_plug_device(q);+ spin_unlock_irqrestore(q->queue_lock, flags);+}+ /** * ide_timer_expiry - handle lack of an IDE interrupt * @data: timer callback magic (hwgroup)@@ -1000,10 +891,12 @@ out: void ide_timer_expiry (unsigned long data) { ide_hwgroup_t *hwgroup = (ide_hwgroup_t *) data;+ ide_drive_t *uninitialized_var(drive); ide_handler_t *handler; ide_expiry_t *expiry; unsigned long flags; unsigned long wait = -1;+ int plug_device = 0; spin_lock_irqsave(&hwgroup->lock, flags); @@ -1015,22 +908,15 @@ void ide_timer_expiry (unsigned long data) * or we were "sleeping" to give other devices a chance. * Either way, we don't really want to complain about anything. */- if (hwgroup->sleeping) {- hwgroup->sleeping = 0;- hwgroup->busy = 0;- } } else {- ide_drive_t *drive = hwgroup->drive;+ drive = hwgroup->drive; if (!drive) { printk(KERN_ERR "ide_timer_expiry: hwgroup->drive was NULL\n"); hwgroup->handler = NULL; } else { ide_hwif_t *hwif; ide_startstop_t startstop = ide_stopped;- if (!hwgroup->busy) {- hwgroup->busy = 1; /* paranoia */- printk(KERN_ERR "%s: ide_timer_expiry: hwgroup->busy was 0 ??\n", drive->name);- }+ if ((expiry = hwgroup->expiry) != NULL) { /* continue */ if ((wait = expiry(drive)) > 0) {@@ -1071,15 +957,18 @@ void ide_timer_expiry (unsigned long data) ide_error(drive, "irq timeout", hwif->tp_ops->read_status(hwif)); }- drive->service_time = jiffies - drive->service_start; spin_lock_irq(&hwgroup->lock); enable_irq(hwif->irq);- if (startstop == ide_stopped)- hwgroup->busy = 0;+ if (startstop == ide_stopped) {+ ide_unlock_hwgroup(hwgroup);+ plug_device = 1;+ } } }- ide_do_request(hwgroup, IDE_NO_IRQ); spin_unlock_irqrestore(&hwgroup->lock, flags);++ if (plug_device)+ ide_plug_device(drive); } /**@@ -1173,10 +1062,11 @@ irqreturn_t ide_intr (int irq, void *dev_id) unsigned long flags; ide_hwgroup_t *hwgroup = (ide_hwgroup_t *)dev_id; ide_hwif_t *hwif = hwgroup->hwif;- ide_drive_t *drive;+ ide_drive_t *uninitialized_var(drive); ide_handler_t *handler; ide_startstop_t startstop; irqreturn_t irq_ret = IRQ_NONE;+ int plug_device = 0; spin_lock_irqsave(&hwgroup->lock, flags); @@ -1241,10 +1131,6 @@ irqreturn_t ide_intr (int irq, void *dev_id) */ goto out; - if (!hwgroup->busy) {- hwgroup->busy = 1; /* paranoia */- printk(KERN_ERR "%s: ide_intr: hwgroup->busy was 0 ??\n", drive->name);- } hwgroup->handler = NULL; hwgroup->req_gen++; del_timer(&hwgroup->timer);@@ -1267,20 +1153,22 @@ irqreturn_t ide_intr (int irq, void *dev_id) * same irq as is currently being serviced here, and Linux * won't allow another of the same (on any CPU) until we return. */- drive->service_time = jiffies - drive->service_start; if (startstop == ide_stopped) { if (hwgroup->handler == NULL) { /* paranoia */- hwgroup->busy = 0;- ide_do_request(hwgroup, hwif->irq);- } else {- printk(KERN_ERR "%s: ide_intr: huh? expected NULL handler "- "on exit\n", drive->name);- }+ ide_unlock_hwgroup(hwgroup);+ plug_device = 1;+ } else+ printk(KERN_ERR "%s: %s: huh? expected NULL handler "+ "on exit\n", __func__, drive->name); } out_handled: irq_ret = IRQ_HANDLED; out: spin_unlock_irqrestore(&hwgroup->lock, flags);++ if (plug_device)+ ide_plug_device(drive);+ return irq_ret; } diff --git a/drivers/ide/ide-ioctls.c b/drivers/ide/ide-ioctls.cindex 28232c6..1be263e 100644--- a/drivers/ide/ide-ioctls.c+++ b/drivers/ide/ide-ioctls.c@@ -95,8 +95,7 @@ static int ide_set_nice_ioctl(ide_drive_t *drive, unsigned long arg) return -EPERM; if (((arg >> IDE_NICE_DSC_OVERLAP) & 1) &&- (drive->media != ide_tape ||- (drive->dev_flags & IDE_DFLAG_SCSI)))+ (drive->media != ide_tape)) return -EPERM; if ((arg >> IDE_NICE_DSC_OVERLAP) & 1)diff --git a/drivers/ide/ide-park.c b/drivers/ide/ide-park.cindex 63d01c5..678454a 100644--- a/drivers/ide/ide-park.c+++ b/drivers/ide/ide-park.c@@ -16,16 +16,19 @@ static void issue_park_cmd(ide_drive_t *drive, unsigned long timeout) spin_lock_irq(&hwgroup->lock); if (drive->dev_flags & IDE_DFLAG_PARKED) { int reset_timer = time_before(timeout, drive->sleep);+ int start_queue = 0; drive->sleep = timeout; wake_up_all(&ide_park_wq);- if (reset_timer && hwgroup->sleeping &&- del_timer(&hwgroup->timer)) {- hwgroup->sleeping = 0;- hwgroup->busy = 0;+ if (reset_timer && del_timer(&hwgroup->timer))+ start_queue = 1;+ spin_unlock_irq(&hwgroup->lock);++ if (start_queue) {+ spin_lock_irq(q->queue_lock); blk_start_queueing(q);+ spin_unlock_irq(q->queue_lock); }- spin_unlock_irq(&hwgroup->lock); return; } spin_unlock_irq(&hwgroup->lock);diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.cindex a64ec25..c5adb7b 100644--- a/drivers/ide/ide-probe.c+++ b/drivers/ide/ide-probe.c@@ -101,6 +101,82 @@ static void ide_disk_init_mult_count(ide_drive_t *drive) } } +static void ide_classify_ata_dev(ide_drive_t *drive)+{+ u16 *id = drive->id;+ char *m = (char *)&id[ATA_ID_PROD];+ int is_cfa = ata_id_is_cfa(id);++ /* CF devices are *not* removable in Linux definition of the term */+ if (is_cfa == 0 && (id[ATA_ID_CONFIG] & (1 << 7)))+ drive->dev_flags |= IDE_DFLAG_REMOVABLE;++ drive->media = ide_disk;++ if (!ata_id_has_unload(drive->id))+ drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;++ printk(KERN_INFO "%s: %s, %s DISK drive\n", drive->name, m,+ is_cfa ? "CFA" : "ATA");+}++static void ide_classify_atapi_dev(ide_drive_t *drive)+{+ u16 *id = drive->id;+ char *m = (char *)&id[ATA_ID_PROD];+ u8 type = (id[ATA_ID_CONFIG] >> 8) & 0x1f;++ printk(KERN_INFO "%s: %s, ATAPI ", drive->name, m);+ switch (type) {+ case ide_floppy:+ if (!strstr(m, "CD-ROM")) {+ if (!strstr(m, "oppy") &&+ !strstr(m, "poyp") &&+ !strstr(m, "ZIP"))+ printk(KERN_CONT "cdrom or floppy?, assuming ");+ if (drive->media != ide_cdrom) {+ printk(KERN_CONT "FLOPPY");+ drive->dev_flags |= IDE_DFLAG_REMOVABLE;+ break;+ }+ }+ /* Early cdrom models used zero */+ type = ide_cdrom;+ case ide_cdrom:+ drive->dev_flags |= IDE_DFLAG_REMOVABLE;+#ifdef CONFIG_PPC+ /* kludge for Apple PowerBook internal zip */+ if (!strstr(m, "CD-ROM") && strstr(m, "ZIP")) {+ printk(KERN_CONT "FLOPPY");+ type = ide_floppy;+ break;+ }+#endif+ printk(KERN_CONT "CD/DVD-ROM");+ break;+ case ide_tape:+ printk(KERN_CONT "TAPE");+ break;+ case ide_optical:+ printk(KERN_CONT "OPTICAL");+ drive->dev_flags |= IDE_DFLAG_REMOVABLE;+ break;+ default:+ printk(KERN_CONT "UNKNOWN (type %d)", type);+ break;+ }++ printk(KERN_CONT " drive\n");+ drive->media = type;+ /* an ATAPI device ignores DRDY */+ drive->ready_stat = 0;+ if (ata_id_cdb_intr(id))+ drive->atapi_flags |= IDE_AFLAG_DRQ_INTERRUPT;+ drive->dev_flags |= IDE_DFLAG_DOORLOCKING;+ /* we don't do head unloading on ATAPI devices */+ drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;+}+ /** * do_identify - identify a drive * @drive: drive to identify @@ -117,7 +193,7 @@ static void do_identify(ide_drive_t *drive, u8 cmd) u16 *id = drive->id; char *m = (char *)&id[ATA_ID_PROD]; unsigned long flags;- int bswap = 1, is_cfa;+ int bswap = 1; /* local CPU only; some systems need this */ local_irq_save(flags);@@ -154,91 +230,23 @@ static void do_identify(ide_drive_t *drive, u8 cmd) if (strstr(m, "E X A B Y T E N E S T")) goto err_misc; - printk(KERN_INFO "%s: %s, ", drive->name, m);- drive->dev_flags |= IDE_DFLAG_PRESENT; drive->dev_flags &= ~IDE_DFLAG_DEAD; /* * Check for an ATAPI device */- if (cmd == ATA_CMD_ID_ATAPI) {- u8 type = (id[ATA_ID_CONFIG] >> 8) & 0x1f;-- printk(KERN_CONT "ATAPI ");- switch (type) {- case ide_floppy:- if (!strstr(m, "CD-ROM")) {- if (!strstr(m, "oppy") &&- !strstr(m, "poyp") &&- !strstr(m, "ZIP"))- printk(KERN_CONT "cdrom or floppy?, assuming ");- if (drive->media != ide_cdrom) {- printk(KERN_CONT "FLOPPY");- drive->dev_flags |= IDE_DFLAG_REMOVABLE;- break;- }- }- /* Early cdrom models used zero */- type = ide_cdrom;- case ide_cdrom:- drive->dev_flags |= IDE_DFLAG_REMOVABLE;-#ifdef CONFIG_PPC- /* kludge for Apple PowerBook internal zip */- if (!strstr(m, "CD-ROM") && strstr(m, "ZIP")) {- printk(KERN_CONT "FLOPPY");- type = ide_floppy;- break;- }-#endif- printk(KERN_CONT "CD/DVD-ROM");- break;- case ide_tape:- printk(KERN_CONT "TAPE");- break;- case ide_optical:- printk(KERN_CONT "OPTICAL");- drive->dev_flags |= IDE_DFLAG_REMOVABLE;- break;- default:- printk(KERN_CONT "UNKNOWN (type %d)", type);- break;- }- printk(KERN_CONT " drive\n");- drive->media = type;- /* an ATAPI device ignores DRDY */- drive->ready_stat = 0;- if (ata_id_cdb_intr(id))- drive->atapi_flags |= IDE_AFLAG_DRQ_INTERRUPT;- drive->dev_flags |= IDE_DFLAG_DOORLOCKING;- /* we don't do head unloading on ATAPI devices */- drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;- return;- }-+ if (cmd == ATA_CMD_ID_ATAPI)+ ide_classify_atapi_dev(drive);+ else /* * Not an ATAPI device: looks like a "regular" hard disk */-- is_cfa = ata_id_is_cfa(id);-- /* CF devices are *not* removable in Linux definition of the term */- if (is_cfa == 0 && (id[ATA_ID_CONFIG] & (1 << 7)))- drive->dev_flags |= IDE_DFLAG_REMOVABLE;-- drive->media = ide_disk;-- if (!ata_id_has_unload(drive->id))- drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;-- printk(KERN_CONT "%s DISK drive\n", is_cfa ? "CFA" : "ATA");-+ ide_classify_ata_dev(drive); return;- err_misc: kfree(id); drive->dev_flags &= ~IDE_DFLAG_PRESENT;- return; } /**@@ -641,14 +649,9 @@ static int ide_register_port(ide_hwif_t *hwif) /* register with global device tree */ dev_set_name(&hwif->gendev, hwif->name); hwif->gendev.driver_data = hwif;- if (hwif->gendev.parent == NULL) {- if (hwif->dev)- hwif->gendev.parent = hwif->dev;- else- /* Would like to do = &device_legacy */- hwif->gendev.parent = NULL;- }+ hwif->gendev.parent = hwif->dev; hwif->gendev.release = hwif_release_dev;+ ret = device_register(&hwif->gendev); if (ret < 0) { printk(KERN_WARNING "IDE: %s: device_register error: %d\n",@@ -878,8 +881,7 @@ static int ide_init_queue(ide_drive_t *drive) * do not. */ - q = blk_init_queue_node(do_ide_request, &hwif->hwgroup->lock,- hwif_to_node(hwif));+ q = blk_init_queue_node(do_ide_request, NULL, hwif_to_node(hwif)); if (!q) return 1; @@ -1139,8 +1141,6 @@ static struct kobject *ata_probe(dev_t dev, int *part, void *data) if (drive->media == ide_disk) request_module("ide-disk");- if (drive->dev_flags & IDE_DFLAG_SCSI)- request_module("ide-scsi"); if (drive->media == ide_cdrom || drive->media == ide_optical) request_module("ide-cd"); if (drive->media == ide_tape)@@ -1417,58 +1417,6 @@ static void ide_port_cable_detect(ide_hwif_t *hwif) } } -static ssize_t store_delete_devices(struct device *portdev,- struct device_attribute *attr,- const char *buf, size_t n)-{- ide_hwif_t *hwif = dev_get_drvdata(portdev);-- if (strncmp(buf, "1", n))- return -EINVAL;-- ide_port_unregister_devices(hwif);-- return n;-};--static DEVICE_ATTR(delete_devices, S_IWUSR, NULL, store_delete_devices);--static ssize_t store_scan(struct device *portdev,- struct device_attribute *attr,- const char *buf, size_t n)-{- ide_hwif_t *hwif = dev_get_drvdata(portdev);-- if (strncmp(buf, "1", n))- return -EINVAL;-- ide_port_unregister_devices(hwif);- ide_port_scan(hwif);-- return n;-};--static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);--static struct device_attribute *ide_port_attrs[] = {- &dev_attr_delete_devices,- &dev_attr_scan,- NULL-};--static int ide_sysfs_register_port(ide_hwif_t *hwif)-{- int i, uninitialized_var(rc);-- for (i = 0; ide_port_attrs[i]; i++) {- rc = device_create_file(hwif->portdev, ide_port_attrs[i]);- if (rc)- break;- }-- return rc;-}- static unsigned int ide_indexes; /**@@ -1655,9 +1603,6 @@ int ide_host_register(struct ide_host *host, const struct ide_port_info *d, if (hwif == NULL) continue; - if (hwif->chipset == ide_unknown)- hwif->chipset = ide_generic;- if (hwif->present) hwif_register_devices(hwif); }diff --git a/drivers/ide/ide-sysfs.c b/drivers/ide/ide-sysfs.cnew file mode 100644index 0000000..883ffac--- /dev/null+++ b/drivers/ide/ide-sysfs.c@@ -0,0 +1,125 @@+#include +#include ++char *ide_media_string(ide_drive_t *drive)+{+ switch (drive->media) {+ case ide_disk:+ return "disk";+ case ide_cdrom:+ return "cdrom";+ case ide_tape:+ return "tape";+ case ide_floppy:+ return "floppy";+ case ide_optical:+ return "optical";+ default:+ return "UNKNOWN";+ }+}++static ssize_t media_show(struct device *dev, struct device_attribute *attr,+ char *buf)+{+ ide_drive_t *drive = to_ide_device(dev);+ return sprintf(buf, "%s\n", ide_media_string(drive));+}++static ssize_t drivename_show(struct device *dev, struct device_attribute *attr,+ char *buf)+{+ ide_drive_t *drive = to_ide_device(dev);+ return sprintf(buf, "%s\n", drive->name);+}++static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,+ char *buf)+{+ ide_drive_t *drive = to_ide_device(dev);+ return sprintf(buf, "ide:m-%s\n", ide_media_string(drive));+}++static ssize_t model_show(struct device *dev, struct device_attribute *attr,+ char *buf)+{+ ide_drive_t *drive = to_ide_device(dev);+ return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_PROD]);+}++static ssize_t firmware_show(struct device *dev, struct device_attribute *attr,+ char *buf)+{+ ide_drive_t *drive = to_ide_device(dev);+ return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_FW_REV]);+}++static ssize_t serial_show(struct device *dev, struct device_attribute *attr,+ char *buf)+{+ ide_drive_t *drive = to_ide_device(dev);+ return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_SERNO]);+}++struct device_attribute ide_dev_attrs[] = {+ __ATTR_RO(media),+ __ATTR_RO(drivename),+ __ATTR_RO(modalias),+ __ATTR_RO(model),+ __ATTR_RO(firmware),+ __ATTR(serial, 0400, serial_show, NULL),+ __ATTR(unload_heads, 0644, ide_park_show, ide_park_store),+ __ATTR_NULL+};++static ssize_t store_delete_devices(struct device *portdev,+ struct device_attribute *attr,+ const char *buf, size_t n)+{+ ide_hwif_t *hwif = dev_get_drvdata(portdev);++ if (strncmp(buf, "1", n))+ return -EINVAL;++ ide_port_unregister_devices(hwif);++ return n;+};++static DEVICE_ATTR(delete_devices, S_IWUSR, NULL, store_delete_devices);++static ssize_t store_scan(struct device *portdev,+ struct device_attribute *attr,+ const char *buf, size_t n)+{+ ide_hwif_t *hwif = dev_get_drvdata(portdev);++ if (strncmp(buf, "1", n))+ return -EINVAL;++ ide_port_unregister_devices(hwif);+ ide_port_scan(hwif);++ return n;+};++static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);++static struct device_attribute *ide_port_attrs[] = {+ &dev_attr_delete_devices,+ &dev_attr_scan,+ NULL+};++int ide_sysfs_register_port(ide_hwif_t *hwif)+{+ int i, uninitialized_var(rc);++ for (i = 0; ide_port_attrs[i]; i++) {+ rc = device_create_file(hwif->portdev, ide_port_attrs[i]);+ if (rc)+ break;+ }++ return rc;+}diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.cindex a2d470e..5d2aa22 100644--- a/drivers/ide/ide-tape.c+++ b/drivers/ide/ide-tape.c@@ -694,7 +694,7 @@ static ide_startstop_t idetape_issue_pc(ide_drive_t *drive, pc->retries++; - return ide_issue_pc(drive, WAIT_TAPE_CMD, NULL);+ return ide_issue_pc(drive); } /* A mode sense command is used to "sense" tape parameters. */diff --git a/drivers/ide/ide.c b/drivers/ide/ide.cindex f0f09f7..46a2d4c 100644--- a/drivers/ide/ide.c+++ b/drivers/ide/ide.c@@ -440,81 +440,13 @@ static int ide_bus_match(struct device *dev, struct device_driver *drv) return 1; } -static char *media_string(ide_drive_t *drive)-{- switch (drive->media) {- case ide_disk:- return "disk";- case ide_cdrom:- return "cdrom";- case ide_tape:- return "tape";- case ide_floppy:- return "floppy";- case ide_optical:- return "optical";- default:- return "UNKNOWN";- }-}--static ssize_t media_show(struct device *dev, struct device_attribute *attr, char *buf)-{- ide_drive_t *drive = to_ide_device(dev);- return sprintf(buf, "%s\n", media_string(drive));-}--static ssize_t drivename_show(struct device *dev, struct device_attribute *attr, char *buf)-{- ide_drive_t *drive = to_ide_device(dev);- return sprintf(buf, "%s\n", drive->name);-}--static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)-{- ide_drive_t *drive = to_ide_device(dev);- return sprintf(buf, "ide:m-%s\n", media_string(drive));-}--static ssize_t model_show(struct device *dev, struct device_attribute *attr,- char *buf)-{- ide_drive_t *drive = to_ide_device(dev);- return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_PROD]);-}--static ssize_t firmware_show(struct device *dev, struct device_attribute *attr,- char *buf)-{- ide_drive_t *drive = to_ide_device(dev);- return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_FW_REV]);-}--static ssize_t serial_show(struct device *dev, struct device_attribute *attr,- char *buf)-{- ide_drive_t *drive = to_ide_device(dev);- return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_SERNO]);-}--static struct device_attribute ide_dev_attrs[] = {- __ATTR_RO(media),- __ATTR_RO(drivename),- __ATTR_RO(modalias),- __ATTR_RO(model),- __ATTR_RO(firmware),- __ATTR(serial, 0400, serial_show, NULL),- __ATTR(unload_heads, 0644, ide_park_show, ide_park_store),- __ATTR_NULL-};- static int ide_uevent(struct device *dev, struct kobj_uevent_env *env) { ide_drive_t *drive = to_ide_device(dev); - add_uevent_var(env, "MEDIA=%s", media_string(drive));+ add_uevent_var(env, "MEDIA=%s", ide_media_string(drive)); add_uevent_var(env, "DRIVENAME=%s", drive->name);- add_uevent_var(env, "MODALIAS=ide:m-%s", media_string(drive));+ add_uevent_var(env, "MODALIAS=ide:m-%s", ide_media_string(drive)); return 0; } diff --git a/drivers/ide/tx4938ide.c b/drivers/ide/tx4938ide.cindex 13b63e7..b4ef218 100644--- a/drivers/ide/tx4938ide.c+++ b/drivers/ide/tx4938ide.c@@ -216,16 +216,17 @@ static const struct ide_tp_ops tx4938ide_tp_ops = { #endif /* __BIG_ENDIAN */ static const struct ide_port_ops tx4938ide_port_ops = {- .set_pio_mode = tx4938ide_set_pio_mode,+ .set_pio_mode = tx4938ide_set_pio_mode, }; static const struct ide_port_info tx4938ide_port_info __initdata = {- .port_ops = &tx4938ide_port_ops,+ .port_ops = &tx4938ide_port_ops, #ifdef __BIG_ENDIAN- .tp_ops = &tx4938ide_tp_ops,+ .tp_ops = &tx4938ide_tp_ops, #endif- .host_flags = IDE_HFLAG_MMIO | IDE_HFLAG_NO_DMA,- .pio_mask = ATA_PIO5,+ .host_flags = IDE_HFLAG_MMIO | IDE_HFLAG_NO_DMA,+ .pio_mask = ATA_PIO5,+ .chipset = ide_generic, }; static int __init tx4938ide_probe(struct platform_device *pdev)diff --git a/drivers/ide/tx4939ide.c b/drivers/ide/tx4939ide.cindex 97cd9e0..4a8c5a2 100644--- a/drivers/ide/tx4939ide.c+++ b/drivers/ide/tx4939ide.c@@ -623,33 +623,34 @@ static const struct ide_tp_ops tx4939ide_tp_ops = { #endif /* __LITTLE_ENDIAN */ static const struct ide_port_ops tx4939ide_port_ops = {- .set_pio_mode = tx4939ide_set_pio_mode,- .set_dma_mode = tx4939ide_set_dma_mode,- .clear_irq = tx4939ide_clear_irq,- .cable_detect = tx4939ide_cable_detect,+ .set_pio_mode = tx4939ide_set_pio_mode,+ .set_dma_mode = tx4939ide_set_dma_mode,+ .clear_irq = tx4939ide_clear_irq,+ .cable_detect = tx4939ide_cable_detect, }; static const struct ide_dma_ops tx4939ide_dma_ops = {- .dma_host_set = tx4939ide_dma_host_set,- .dma_setup = tx4939ide_dma_setup,- .dma_exec_cmd = ide_dma_exec_cmd,- .dma_start = ide_dma_start,- .dma_end = tx4939ide_dma_end,- .dma_test_irq = tx4939ide_dma_test_irq,- .dma_lost_irq = ide_dma_lost_irq,- .dma_timeout = ide_dma_timeout,+ .dma_host_set = tx4939ide_dma_host_set,+ .dma_setup = tx4939ide_dma_setup,+ .dma_exec_cmd = ide_dma_exec_cmd,+ .dma_start = ide_dma_start,+ .dma_end = tx4939ide_dma_end,+ .dma_test_irq = tx4939ide_dma_test_irq,+ .dma_lost_irq = ide_dma_lost_irq,+ .dma_timeout = ide_dma_timeout, }; static const struct ide_port_info tx4939ide_port_info __initdata = {- .init_hwif = tx4939ide_init_hwif,- .init_dma = tx4939ide_init_dma,- .port_ops = &tx4939ide_port_ops,- .dma_ops = &tx4939ide_dma_ops,- .tp_ops = &tx4939ide_tp_ops,- .host_flags = IDE_HFLAG_MMIO,- .pio_mask = ATA_PIO4,- .mwdma_mask = ATA_MWDMA2,- .udma_mask = ATA_UDMA5,+ .init_hwif = tx4939ide_init_hwif,+ .init_dma = tx4939ide_init_dma,+ .port_ops = &tx4939ide_port_ops,+ .dma_ops = &tx4939ide_dma_ops,+ .tp_ops = &tx4939ide_tp_ops,+ .host_flags = IDE_HFLAG_MMIO,+ .pio_mask = ATA_PIO4,+ .mwdma_mask = ATA_MWDMA2,+ .udma_mask = ATA_UDMA5,+ .chipset = ide_generic, }; static int __init tx4939ide_probe(struct platform_device *pdev)diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfigindex 152d4aa..b732297 100644--- a/drivers/scsi/Kconfig+++ b/drivers/scsi/Kconfig@@ -21,7 +21,7 @@ config SCSI You also need to say Y here if you have a device which speaks the SCSI protocol. Examples of this include the parallel port version of the IOMEGA ZIP drive, USB storage devices, Fibre- Channel, FireWire storage and the IDE-SCSI emulation driver.+ Channel, and FireWire storage. To compile this driver as a module, choose M here and read .@@ -101,9 +101,9 @@ config CHR_DEV_OSST ---help--- The OnStream SC-x0 SCSI tape drives cannot be driven by the standard st driver, but instead need this special osst driver and- use the /dev/osstX char device nodes (major 206). Via usb-storage- and ide-scsi, you may be able to drive the USB-x0 and DI-x0 drives- as well. Note that there is also a second generation of OnStream+ use the /dev/osstX char device nodes (major 206). Via usb-storage,+ you may be able to drive the USB-x0 and DI-x0 drives as well.+ Note that there is also a second generation of OnStream tape drives (ADR-x0) that supports the standard SCSI-2 commands for tapes (QIC-157) and can be driven by the standard driver st. For more information, you may have a look at the SCSI-HOWTOdiff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefileindex 1410697..7461eb0 100644--- a/drivers/scsi/Makefile+++ b/drivers/scsi/Makefile@@ -105,7 +105,6 @@ obj-$(CONFIG_SCSI_GDTH) += gdth.o obj-$(CONFIG_SCSI_INITIO) += initio.o obj-$(CONFIG_SCSI_INIA100) += a100u2w.o obj-$(CONFIG_SCSI_QLOGICPTI) += qlogicpti.o-obj-$(CONFIG_BLK_DEV_IDESCSI) += ide-scsi.o obj-$(CONFIG_SCSI_MESH) += mesh.o obj-$(CONFIG_SCSI_MAC53C94) += mac53c94.o obj-$(CONFIG_BLK_DEV_3W_XXXX_RAID) += 3w-xxxx.odiff --git a/drivers/scsi/ide-scsi.c b/drivers/scsi/ide-scsi.cdeleted file mode 100644index c24140a..0000000--- a/drivers/scsi/ide-scsi.c+++ /dev/null@@ -1,840 +0,0 @@-/*- * Copyright (C) 1996-1999 Gadi Oxman - * Copyright (C) 2004-2005 Bartlomiej Zolnierkiewicz- */--/*- * Emulation of a SCSI host adapter for IDE ATAPI devices.- *- * With this driver, one can use the Linux SCSI drivers instead of the- * native IDE ATAPI drivers.- *- * Ver 0.1 Dec 3 96 Initial version.- * Ver 0.2 Jan 26 97 Fixed bug in cleanup_module() and added emulation- * of MODE_SENSE_6/MODE_SELECT_6 for cdroms. Thanks- * to Janos Farkas for pointing this out.- * Avoid using bitfields in structures for m68k.- * Added Scatter/Gather and DMA support.- * Ver 0.4 Dec 7 97 Add support for ATAPI PD/CD drives.- * Use variable timeout for each command.- * Ver 0.5 Jan 2 98 Fix previous PD/CD support.- * Allow disabling of SCSI-6 to SCSI-10 transformation.- * Ver 0.6 Jan 27 98 Allow disabling of SCSI command translation layer- * for access through /dev/sg.- * Fix MODE_SENSE_6/MODE_SELECT_6/INQUIRY translation.- * Ver 0.7 Dec 04 98 Ignore commands where lun != 0 to avoid multiple- * detection of devices with CONFIG_SCSI_MULTI_LUN- * Ver 0.8 Feb 05 99 Optical media need translation too. Reverse 0.7.- * Ver 0.9 Jul 04 99 Fix a bug in SG_SET_TRANSFORM.- * Ver 0.91 Jun 10 02 Fix "off by one" error in transforms- * Ver 0.92 Dec 31 02 Implement new SCSI mid level API- */--#define IDESCSI_VERSION "0.92"--#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include --#include -#include --#include -#include -#include -#include -#include -#include --#define IDESCSI_DEBUG_LOG 0--#if IDESCSI_DEBUG_LOG-#define debug_log(fmt, args...) \- printk(KERN_INFO "ide-scsi: " fmt, ## args)-#else-#define debug_log(fmt, args...) do {} while (0)-#endif--/*- * SCSI command transformation layer- */-#define IDESCSI_SG_TRANSFORM 1 /* /dev/sg transformation */--/*- * Log flags- */-#define IDESCSI_LOG_CMD 0 /* Log SCSI commands */--typedef struct ide_scsi_obj {- ide_drive_t *drive;- ide_driver_t *driver;- struct gendisk *disk;- struct Scsi_Host *host;-- unsigned long transform; /* SCSI cmd translation layer */- unsigned long log; /* log flags */-} idescsi_scsi_t;--static DEFINE_MUTEX(idescsi_ref_mutex);-/* Set by module param to skip cd */-static int idescsi_nocd;--#define ide_scsi_g(disk) \- container_of((disk)->private_data, struct ide_scsi_obj, driver)--static struct ide_scsi_obj *ide_scsi_get(struct gendisk *disk)-{- struct ide_scsi_obj *scsi = NULL;-- mutex_lock(&idescsi_ref_mutex);- scsi = ide_scsi_g(disk);- if (scsi) {- if (ide_device_get(scsi->drive))- scsi = NULL;- else- scsi_host_get(scsi->host);- }- mutex_unlock(&idescsi_ref_mutex);- return scsi;-}--static void ide_scsi_put(struct ide_scsi_obj *scsi)-{- ide_drive_t *drive = scsi->drive;-- mutex_lock(&idescsi_ref_mutex);- scsi_host_put(scsi->host);- ide_device_put(drive);- mutex_unlock(&idescsi_ref_mutex);-}--static inline idescsi_scsi_t *scsihost_to_idescsi(struct Scsi_Host *host)-{- return (idescsi_scsi_t*) (&host[1]);-}--static inline idescsi_scsi_t *drive_to_idescsi(ide_drive_t *ide_drive)-{- return scsihost_to_idescsi(ide_drive->driver_data);-}--static void ide_scsi_hex_dump(u8 *data, int len)-{- print_hex_dump(KERN_CONT, "", DUMP_PREFIX_NONE, 16, 1, data, len, 0);-}--static int idescsi_end_request(ide_drive_t *, int, int);--static void ide_scsi_callback(ide_drive_t *drive, int dsc)-{- idescsi_scsi_t *scsi = drive_to_idescsi(drive);- struct ide_atapi_pc *pc = drive->pc;-- if (pc->flags & PC_FLAG_TIMEDOUT)- debug_log("%s: got timed out packet %lu at %lu\n", __func__,- pc->scsi_cmd->serial_number, jiffies);- /* end this request now - scsi should retry it*/- else if (test_bit(IDESCSI_LOG_CMD, &scsi->log))- printk(KERN_INFO "Packet command completed, %d bytes"- " transferred\n", pc->xferred);-- idescsi_end_request(drive, 1, 0);-}--static int idescsi_check_condition(ide_drive_t *drive,- struct request *failed_cmd)-{- idescsi_scsi_t *scsi = drive_to_idescsi(drive);- struct ide_atapi_pc *pc;- struct request *rq;- u8 *buf;-- /* stuff a sense request in front of our current request */- pc = kzalloc(sizeof(struct ide_atapi_pc), GFP_ATOMIC);- rq = blk_get_request(drive->queue, READ, GFP_ATOMIC);- buf = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_ATOMIC);- if (!pc || !rq || !buf) {- kfree(buf);- if (rq)- blk_put_request(rq);- kfree(pc);- return -ENOMEM;- }- rq->special = (char *) pc;- pc->rq = rq;- pc->buf = buf;- pc->c[0] = REQUEST_SENSE;- pc->c[4] = pc->req_xfer = pc->buf_size = SCSI_SENSE_BUFFERSIZE;- rq->cmd_type = REQ_TYPE_SENSE;- rq->cmd_flags |= REQ_PREEMPT;- pc->timeout = jiffies + WAIT_READY;- /* NOTE! Save the failed packet command in "rq->buffer" */- rq->buffer = (void *) failed_cmd->special;- pc->scsi_cmd = ((struct ide_atapi_pc *) failed_cmd->special)->scsi_cmd;- if (test_bit(IDESCSI_LOG_CMD, &scsi->log)) {- printk ("ide-scsi: %s: queue cmd = ", drive->name);- ide_scsi_hex_dump(pc->c, 6);- }- rq->rq_disk = scsi->disk;- rq->ref_count++;- memcpy(rq->cmd, pc->c, 12);- ide_do_drive_cmd(drive, rq);- return 0;-}--static ide_startstop_t-idescsi_atapi_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err)-{- ide_hwif_t *hwif = drive->hwif;-- if (hwif->tp_ops->read_status(hwif) & (ATA_BUSY | ATA_DRQ))- /* force an abort */- hwif->tp_ops->exec_command(hwif, ATA_CMD_IDLEIMMEDIATE);-- rq->errors++;-- idescsi_end_request(drive, 0, 0);-- return ide_stopped;-}--static int idescsi_end_request (ide_drive_t *drive, int uptodate, int nrsecs)-{- idescsi_scsi_t *scsi = drive_to_idescsi(drive);- struct request *rq = HWGROUP(drive)->rq;- struct ide_atapi_pc *pc = (struct ide_atapi_pc *) rq->special;- int log = test_bit(IDESCSI_LOG_CMD, &scsi->log);- struct Scsi_Host *host;- int errors = rq->errors;- unsigned long flags;-- if (!blk_special_request(rq) && !blk_sense_request(rq)) {- ide_end_request(drive, uptodate, nrsecs);- return 0;- }- ide_end_drive_cmd (drive, 0, 0);- if (blk_sense_request(rq)) {- struct ide_atapi_pc *opc = (struct ide_atapi_pc *) rq->buffer;- if (log) {- printk ("ide-scsi: %s: wrap up check %lu, rst = ", drive->name, opc->scsi_cmd->serial_number);- ide_scsi_hex_dump(pc->buf, 16);- }- memcpy((void *) opc->scsi_cmd->sense_buffer, pc->buf,- SCSI_SENSE_BUFFERSIZE);- kfree(pc->buf);- kfree(pc);- blk_put_request(rq);- pc = opc;- rq = pc->rq;- pc->scsi_cmd->result = (CHECK_CONDITION << 1) |- (((pc->flags & PC_FLAG_TIMEDOUT) ?- DID_TIME_OUT :- DID_OK) << 16);- } else if (pc->flags & PC_FLAG_TIMEDOUT) {- if (log)- printk (KERN_WARNING "ide-scsi: %s: timed out for %lu\n",- drive->name, pc->scsi_cmd->serial_number);- pc->scsi_cmd->result = DID_TIME_OUT << 16;- } else if (errors >= ERROR_MAX) {- pc->scsi_cmd->result = DID_ERROR << 16;- if (log)- printk ("ide-scsi: %s: I/O error for %lu\n", drive->name, pc->scsi_cmd->serial_number);- } else if (errors) {- if (log)- printk ("ide-scsi: %s: check condition for %lu\n", drive->name, pc->scsi_cmd->serial_number);- if (!idescsi_check_condition(drive, rq))- /* we started a request sense, so we'll be back, exit for now */- return 0;- pc->scsi_cmd->result = (CHECK_CONDITION << 1) | (DID_OK << 16);- } else {- pc->scsi_cmd->result = DID_OK << 16;- }- host = pc->scsi_cmd->device->host;- spin_lock_irqsave(host->host_lock, flags);- pc->done(pc->scsi_cmd);- spin_unlock_irqrestore(host->host_lock, flags);- kfree(pc);- blk_put_request(rq);- drive->pc = NULL;- return 0;-}--static inline int idescsi_set_direction(struct ide_atapi_pc *pc)-{- switch (pc->c[0]) {- case READ_6: case READ_10: case READ_12:- pc->flags &= ~PC_FLAG_WRITING;- return 0;- case WRITE_6: case WRITE_10: case WRITE_12:- pc->flags |= PC_FLAG_WRITING;- return 0;- default:- return 1;- }-}--static int idescsi_map_sg(ide_drive_t *drive, struct ide_atapi_pc *pc)-{- ide_hwif_t *hwif = drive->hwif;- struct scatterlist *sg, *scsi_sg;- int segments;-- if (!pc->req_xfer || pc->req_xfer % 1024)- return 1;-- if (idescsi_set_direction(pc))- return 1;-- sg = hwif->sg_table;- scsi_sg = scsi_sglist(pc->scsi_cmd);- segments = scsi_sg_count(pc->scsi_cmd);-- if (segments > hwif->sg_max_nents)- return 1;-- hwif->sg_nents = segments;- memcpy(sg, scsi_sg, sizeof(*sg) * segments);-- return 0;-}--static ide_startstop_t idescsi_issue_pc(ide_drive_t *drive,- struct ide_atapi_pc *pc)-{- /* Set the current packet command */- drive->pc = pc;-- return ide_issue_pc(drive, ide_scsi_get_timeout(pc), ide_scsi_expiry);-}--/*- * idescsi_do_request is our request handling function.- */-static ide_startstop_t idescsi_do_request (ide_drive_t *drive, struct request *rq, sector_t block)-{- debug_log("dev: %s, cmd: %x, errors: %d\n", rq->rq_disk->disk_name,- rq->cmd[0], rq->errors);- debug_log("sector: %ld, nr_sectors: %ld, current_nr_sectors: %d\n",- rq->sector, rq->nr_sectors, rq->current_nr_sectors);-- if (blk_sense_request(rq) || blk_special_request(rq)) {- struct ide_atapi_pc *pc = (struct ide_atapi_pc *)rq->special;-- if ((drive->dev_flags & IDE_DFLAG_USING_DMA) &&- idescsi_map_sg(drive, pc) == 0)- pc->flags |= PC_FLAG_DMA_OK;-- return idescsi_issue_pc(drive, pc);- }- blk_dump_rq_flags(rq, "ide-scsi: unsup command");- idescsi_end_request (drive, 0, 0);- return ide_stopped;-}--#ifdef CONFIG_IDE_PROC_FS-static ide_proc_entry_t idescsi_proc[] = {- { "capacity", S_IFREG|S_IRUGO, proc_ide_read_capacity, NULL },- { NULL, 0, NULL, NULL }-};--#define ide_scsi_devset_get(name, field) \-static int get_##name(ide_drive_t *drive) \-{ \- idescsi_scsi_t *scsi = drive_to_idescsi(drive); \- return scsi->field; \-}--#define ide_scsi_devset_set(name, field) \-static int set_##name(ide_drive_t *drive, int arg) \-{ \- idescsi_scsi_t *scsi = drive_to_idescsi(drive); \- scsi->field = arg; \- return 0; \-}--#define ide_scsi_devset_rw_field(_name, _field) \-ide_scsi_devset_get(_name, _field); \-ide_scsi_devset_set(_name, _field); \-IDE_DEVSET(_name, DS_SYNC, get_##_name, set_##_name);--ide_devset_rw_field(bios_cyl, bios_cyl);-ide_devset_rw_field(bios_head, bios_head);-ide_devset_rw_field(bios_sect, bios_sect);--ide_scsi_devset_rw_field(transform, transform);-ide_scsi_devset_rw_field(log, log);--static const struct ide_proc_devset idescsi_settings[] = {- IDE_PROC_DEVSET(bios_cyl, 0, 1023),- IDE_PROC_DEVSET(bios_head, 0, 255),- IDE_PROC_DEVSET(bios_sect, 0, 63),- IDE_PROC_DEVSET(log, 0, 1),- IDE_PROC_DEVSET(transform, 0, 3),- { 0 },-};--static ide_proc_entry_t *ide_scsi_proc_entries(ide_drive_t *drive)-{- return idescsi_proc;-}--static const struct ide_proc_devset *ide_scsi_proc_devsets(ide_drive_t *drive)-{- return idescsi_settings;-}-#endif--/*- * Driver initialization.- */-static void idescsi_setup (ide_drive_t *drive, idescsi_scsi_t *scsi)-{- clear_bit(IDESCSI_SG_TRANSFORM, &scsi->transform);-#if IDESCSI_DEBUG_LOG- set_bit(IDESCSI_LOG_CMD, &scsi->log);-#endif /* IDESCSI_DEBUG_LOG */-- drive->pc_callback = ide_scsi_callback;- drive->pc_update_buffers = NULL;- drive->pc_io_buffers = ide_io_buffers;-- ide_proc_register_driver(drive, scsi->driver);-}--static void ide_scsi_remove(ide_drive_t *drive)-{- struct Scsi_Host *scsihost = drive->driver_data;- struct ide_scsi_obj *scsi = scsihost_to_idescsi(scsihost);- struct gendisk *g = scsi->disk;-- scsi_remove_host(scsihost);- ide_proc_unregister_driver(drive, scsi->driver);-- ide_unregister_region(g);-- drive->driver_data = NULL;- g->private_data = NULL;- put_disk(g);-- ide_scsi_put(scsi);-- drive->dev_flags &= ~IDE_DFLAG_SCSI;-}--static int ide_scsi_probe(ide_drive_t *);--static ide_driver_t idescsi_driver = {- .gen_driver = {- .owner = THIS_MODULE,- .name = "ide-scsi",- .bus = &ide_bus_type,- },- .probe = ide_scsi_probe,- .remove = ide_scsi_remove,- .version = IDESCSI_VERSION,- .do_request = idescsi_do_request,- .end_request = idescsi_end_request,- .error = idescsi_atapi_error,-#ifdef CONFIG_IDE_PROC_FS- .proc_entries = ide_scsi_proc_entries,- .proc_devsets = ide_scsi_proc_devsets,-#endif-};--static int idescsi_ide_open(struct block_device *bdev, fmode_t mode)-{- struct ide_scsi_obj *scsi = ide_scsi_get(bdev->bd_disk);-- if (!scsi)- return -ENXIO;-- return 0;-}--static int idescsi_ide_release(struct gendisk *disk, fmode_t mode)-{- ide_scsi_put(ide_scsi_g(disk));- return 0;-}--static int idescsi_ide_ioctl(struct block_device *bdev, fmode_t mode,- unsigned int cmd, unsigned long arg)-{- struct ide_scsi_obj *scsi = ide_scsi_g(bdev->bd_disk);- return generic_ide_ioctl(scsi->drive, bdev, cmd, arg);-}--static struct block_device_operations idescsi_ops = {- .owner = THIS_MODULE,- .open = idescsi_ide_open,- .release = idescsi_ide_release,- .locked_ioctl = idescsi_ide_ioctl,-};--static int idescsi_slave_configure(struct scsi_device * sdp)-{- /* Configure detected device */- sdp->use_10_for_rw = 1;- sdp->use_10_for_ms = 1;- scsi_adjust_queue_depth(sdp, MSG_SIMPLE_TAG, sdp->host->cmd_per_lun);- return 0;-}--static const char *idescsi_info (struct Scsi_Host *host)-{- return "SCSI host adapter emulation for IDE ATAPI devices";-}--static int idescsi_ioctl (struct scsi_device *dev, int cmd, void __user *arg)-{- idescsi_scsi_t *scsi = scsihost_to_idescsi(dev->host);-- if (cmd == SG_SET_TRANSFORM) {- if (arg)- set_bit(IDESCSI_SG_TRANSFORM, &scsi->transform);- else- clear_bit(IDESCSI_SG_TRANSFORM, &scsi->transform);- return 0;- } else if (cmd == SG_GET_TRANSFORM)- return put_user(test_bit(IDESCSI_SG_TRANSFORM, &scsi->transform), (int __user *) arg);- return -EINVAL;-}--static int idescsi_queue (struct scsi_cmnd *cmd,- void (*done)(struct scsi_cmnd *))-{- struct Scsi_Host *host = cmd->device->host;- idescsi_scsi_t *scsi = scsihost_to_idescsi(host);- ide_drive_t *drive = scsi->drive;- struct request *rq = NULL;- struct ide_atapi_pc *pc = NULL;- int write = cmd->sc_data_direction == DMA_TO_DEVICE;-- if (!drive) {- scmd_printk (KERN_ERR, cmd, "drive not present\n");- goto abort;- }- scsi = drive_to_idescsi(drive);- pc = kmalloc(sizeof(struct ide_atapi_pc), GFP_ATOMIC);- rq = blk_get_request(drive->queue, write, GFP_ATOMIC);- if (rq == NULL || pc == NULL) {- printk (KERN_ERR "ide-scsi: %s: out of memory\n", drive->name);- goto abort;- }-- memset (pc->c, 0, 12);- pc->flags = 0;- if (cmd->sc_data_direction == DMA_TO_DEVICE)- pc->flags |= PC_FLAG_WRITING;- pc->rq = rq;- memcpy (pc->c, cmd->cmnd, cmd->cmd_len);- pc->buf = NULL;- pc->sg = scsi_sglist(cmd);- pc->sg_cnt = scsi_sg_count(cmd);- pc->b_count = 0;- pc->req_xfer = pc->buf_size = scsi_bufflen(cmd);- pc->scsi_cmd = cmd;- pc->done = done;- pc->timeout = jiffies + cmd->request->timeout;-- if (test_bit(IDESCSI_LOG_CMD, &scsi->log)) {- printk ("ide-scsi: %s: que %lu, cmd = ", drive->name, cmd->serial_number);- ide_scsi_hex_dump(cmd->cmnd, cmd->cmd_len);- if (memcmp(pc->c, cmd->cmnd, cmd->cmd_len)) {- printk ("ide-scsi: %s: que %lu, tsl = ", drive->name, cmd->serial_number);- ide_scsi_hex_dump(pc->c, 12);- }- }-- rq->special = (char *) pc;- rq->cmd_type = REQ_TYPE_SPECIAL;- spin_unlock_irq(host->host_lock);- rq->ref_count++;- memcpy(rq->cmd, pc->c, 12);- blk_execute_rq_nowait(drive->queue, scsi->disk, rq, 0, NULL);- spin_lock_irq(host->host_lock);- return 0;-abort:- kfree (pc);- if (rq)- blk_put_request(rq);- cmd->result = DID_ERROR << 16;- done(cmd);- return 0;-}--static int idescsi_eh_abort (struct scsi_cmnd *cmd)-{- idescsi_scsi_t *scsi = scsihost_to_idescsi(cmd->device->host);- ide_drive_t *drive = scsi->drive;- ide_hwif_t *hwif;- ide_hwgroup_t *hwgroup;- int busy;- int ret = FAILED;-- struct ide_atapi_pc *pc;-- /* In idescsi_eh_abort we try to gently pry our command from the ide subsystem */-- if (test_bit(IDESCSI_LOG_CMD, &scsi->log))- printk (KERN_WARNING "ide-scsi: abort called for %lu\n", cmd->serial_number);-- if (!drive) {- printk (KERN_WARNING "ide-scsi: Drive not set in idescsi_eh_abort\n");- WARN_ON(1);- goto no_drive;- }-- hwif = drive->hwif;- hwgroup = hwif->hwgroup;-- /* First give it some more time, how much is "right" is hard to say :-(- FIXME - uses mdelay which causes latency? */- busy = ide_wait_not_busy(hwif, 100);- if (test_bit(IDESCSI_LOG_CMD, &scsi->log))- printk (KERN_WARNING "ide-scsi: drive did%s become ready\n", busy?" not":"");-- spin_lock_irq(&hwgroup->lock);-- /* If there is no pc running we're done (our interrupt took care of it) */- pc = drive->pc;- if (pc == NULL) {- ret = SUCCESS;- goto ide_unlock;- }-- /* It's somewhere in flight. Does ide subsystem agree? */- if (pc->scsi_cmd->serial_number == cmd->serial_number && !busy &&- elv_queue_empty(drive->queue) && HWGROUP(drive)->rq != pc->rq) {- /*- * FIXME - not sure this condition can ever occur- */- printk (KERN_ERR "ide-scsi: cmd aborted!\n");-- if (blk_sense_request(pc->rq))- kfree(pc->buf);- /* we need to call blk_put_request twice. */- blk_put_request(pc->rq);- blk_put_request(pc->rq);- kfree(pc);- drive->pc = NULL;-- ret = SUCCESS;- }--ide_unlock:- spin_unlock_irq(&hwgroup->lock);-no_drive:- if (test_bit(IDESCSI_LOG_CMD, &scsi->log))- printk (KERN_WARNING "ide-scsi: abort returns %s\n", ret == SUCCESS?"success":"failed");-- return ret;-}--static int idescsi_eh_reset (struct scsi_cmnd *cmd)-{- struct request *req;- idescsi_scsi_t *scsi = scsihost_to_idescsi(cmd->device->host);- ide_drive_t *drive = scsi->drive;- ide_hwgroup_t *hwgroup;- int ready = 0;- int ret = SUCCESS;-- struct ide_atapi_pc *pc;-- /* In idescsi_eh_reset we forcefully remove the command from the ide subsystem and reset the device. */-- if (test_bit(IDESCSI_LOG_CMD, &scsi->log))- printk (KERN_WARNING "ide-scsi: reset called for %lu\n", cmd->serial_number);-- if (!drive) {- printk (KERN_WARNING "ide-scsi: Drive not set in idescsi_eh_reset\n");- WARN_ON(1);- return FAILED;- }-- hwgroup = drive->hwif->hwgroup;-- spin_lock_irq(cmd->device->host->host_lock);- spin_lock(&hwgroup->lock);-- pc = drive->pc;- if (pc)- req = pc->rq;-- if (pc == NULL || req != hwgroup->rq || hwgroup->handler == NULL) {- printk (KERN_WARNING "ide-scsi: No active request in idescsi_eh_reset\n");- spin_unlock(&hwgroup->lock);- spin_unlock_irq(cmd->device->host->host_lock);- return FAILED;- }-- /* kill current request */- if (__blk_end_request(req, -EIO, 0))- BUG();- if (blk_sense_request(req))- kfree(pc->buf);- kfree(pc);- drive->pc = NULL;- blk_put_request(req);-- /* now nuke the drive queue */- while ((req = elv_next_request(drive->queue))) {- if (__blk_end_request(req, -EIO, 0))- BUG();- }-- hwgroup->rq = NULL;- hwgroup->handler = NULL;- hwgroup->busy = 1; /* will set this to zero when ide reset finished */- spin_unlock(&hwgroup->lock);-- ide_do_reset(drive);-- /* ide_do_reset starts a polling handler which restarts itself every 50ms until the reset finishes */-- do {- spin_unlock_irq(cmd->device->host->host_lock);- msleep(50);- spin_lock_irq(cmd->device->host->host_lock);- } while ( HWGROUP(drive)->handler );-- ready = drive_is_ready(drive);- HWGROUP(drive)->busy--;- if (!ready) {- printk (KERN_ERR "ide-scsi: reset failed!\n");- ret = FAILED;- }-- spin_unlock_irq(cmd->device->host->host_lock);- return ret;-}--static int idescsi_bios(struct scsi_device *sdev, struct block_device *bdev,- sector_t capacity, int *parm)-{- idescsi_scsi_t *idescsi = scsihost_to_idescsi(sdev->host);- ide_drive_t *drive = idescsi->drive;-- if (drive->bios_cyl && drive->bios_head && drive->bios_sect) {- parm[0] = drive->bios_head;- parm[1] = drive->bios_sect;- parm[2] = drive->bios_cyl;- }- return 0;-}--static struct scsi_host_template idescsi_template = {- .module = THIS_MODULE,- .name = "idescsi",- .info = idescsi_info,- .slave_configure = idescsi_slave_configure,- .ioctl = idescsi_ioctl,- .queuecommand = idescsi_queue,- .eh_abort_handler = idescsi_eh_abort,- .eh_host_reset_handler = idescsi_eh_reset,- .bios_param = idescsi_bios,- .can_queue = 40,- .this_id = -1,- .sg_tablesize = 256,- .cmd_per_lun = 5,- .max_sectors = 128,- .use_clustering = DISABLE_CLUSTERING,- .emulated = 1,- .proc_name = "ide-scsi",-};--static int ide_scsi_probe(ide_drive_t *drive)-{- idescsi_scsi_t *idescsi;- struct Scsi_Host *host;- struct gendisk *g;- static int warned;- int err = -ENOMEM;- u16 last_lun;-- if (!warned && drive->media == ide_cdrom) {- printk(KERN_WARNING "ide-scsi is deprecated for cd burning! Use ide-cd and give dev=/dev/hdX as device\n");- warned = 1;- }-- if (idescsi_nocd && drive->media == ide_cdrom)- return -ENODEV;-- if (!strstr("ide-scsi", drive->driver_req) ||- drive->media == ide_disk ||- !(host = scsi_host_alloc(&idescsi_template,sizeof(idescsi_scsi_t))))- return -ENODEV;-- drive->dev_flags |= IDE_DFLAG_SCSI;-- g = alloc_disk(1 << PARTN_BITS);- if (!g)- goto out_host_put;-- ide_init_disk(g, drive);-- host->max_id = 1;-- last_lun = drive->id[ATA_ID_LAST_LUN];- if (last_lun)- debug_log("%s: last_lun=%u\n", drive->name, last_lun);-- if ((last_lun & 7) != 7)- host->max_lun = (last_lun & 7) + 1;- else- host->max_lun = 1;-- drive->driver_data = host;- idescsi = scsihost_to_idescsi(host);- idescsi->drive = drive;- idescsi->driver = &idescsi_driver;- idescsi->host = host;- idescsi->disk = g;- g->private_data = &idescsi->driver;- err = 0;- idescsi_setup(drive, idescsi);- g->fops = &idescsi_ops;- ide_register_region(g);- err = scsi_add_host(host, &drive->gendev);- if (!err) {- scsi_scan_host(host);- return 0;- }- /* fall through on error */- ide_unregister_region(g);- ide_proc_unregister_driver(drive, &idescsi_driver);-- put_disk(g);-out_host_put:- drive->dev_flags &= ~IDE_DFLAG_SCSI;- scsi_host_put(host);- return err;-}--static int __init init_idescsi_module(void)-{- return driver_register(&idescsi_driver.gen_driver);-}--static void __exit exit_idescsi_module(void)-{- driver_unregister(&idescsi_driver.gen_driver);-}--module_param(idescsi_nocd, int, 0600);-MODULE_PARM_DESC(idescsi_nocd, "Disable handling of CD-ROMs so they may be driven by ide-cd");-module_init(init_idescsi_module);-module_exit(exit_idescsi_module);-MODULE_LICENSE("GPL");diff --git a/include/linux/ide.h b/include/linux/ide.hindex e99c56d..db5ef8a 100644--- a/include/linux/ide.h+++ b/include/linux/ide.h@@ -32,13 +32,6 @@ # define SUPPORT_VLB_SYNC 1 #endif -/*- * Used to indicate "no IRQ", should be a value that cannot be an IRQ- * number.- */- -#define IDE_NO_IRQ (-1)- typedef unsigned char byte; /* used everywhere */ /*@@ -403,6 +396,7 @@ enum { * This is used for several packet commands (not for READ/WRITE commands). */ #define IDE_PC_BUFFER_SIZE 256+#define ATAPI_WAIT_PC (60 * HZ) struct ide_atapi_pc { /* actual packet bytes */@@ -480,53 +474,53 @@ enum { /* ide-cd */ /* Drive cannot eject the disc. */- IDE_AFLAG_NO_EJECT = (1 << 3),+ IDE_AFLAG_NO_EJECT = (1 << 1), /* Drive is a pre ATAPI 1.2 drive. */- IDE_AFLAG_PRE_ATAPI12 = (1 << 4),+ IDE_AFLAG_PRE_ATAPI12 = (1 << 2), /* TOC addresses are in BCD. */- IDE_AFLAG_TOCADDR_AS_BCD = (1 << 5),+ IDE_AFLAG_TOCADDR_AS_BCD = (1 << 3), /* TOC track numbers are in BCD. */- IDE_AFLAG_TOCTRACKS_AS_BCD = (1 << 6),+ IDE_AFLAG_TOCTRACKS_AS_BCD = (1 << 4), /* * Drive does not provide data in multiples of SECTOR_SIZE * when more than one interrupt is needed. */- IDE_AFLAG_LIMIT_NFRAMES = (1 << 7),+ IDE_AFLAG_LIMIT_NFRAMES = (1 << 5), /* Saved TOC information is current. */- IDE_AFLAG_TOC_VALID = (1 << 9),+ IDE_AFLAG_TOC_VALID = (1 << 6), /* We think that the drive door is locked. */- IDE_AFLAG_DOOR_LOCKED = (1 << 10),+ IDE_AFLAG_DOOR_LOCKED = (1 << 7), /* SET_CD_SPEED command is unsupported. */- IDE_AFLAG_NO_SPEED_SELECT = (1 << 11),- IDE_AFLAG_VERTOS_300_SSD = (1 << 12),- IDE_AFLAG_VERTOS_600_ESD = (1 << 13),- IDE_AFLAG_SANYO_3CD = (1 << 14),- IDE_AFLAG_FULL_CAPS_PAGE = (1 << 15),- IDE_AFLAG_PLAY_AUDIO_OK = (1 << 16),- IDE_AFLAG_LE_SPEED_FIELDS = (1 << 17),+ IDE_AFLAG_NO_SPEED_SELECT = (1 << 8),+ IDE_AFLAG_VERTOS_300_SSD = (1 << 9),+ IDE_AFLAG_VERTOS_600_ESD = (1 << 10),+ IDE_AFLAG_SANYO_3CD = (1 << 11),+ IDE_AFLAG_FULL_CAPS_PAGE = (1 << 12),+ IDE_AFLAG_PLAY_AUDIO_OK = (1 << 13),+ IDE_AFLAG_LE_SPEED_FIELDS = (1 << 14), /* ide-floppy */ /* Avoid commands not supported in Clik drive */- IDE_AFLAG_CLIK_DRIVE = (1 << 19),+ IDE_AFLAG_CLIK_DRIVE = (1 << 15), /* Requires BH algorithm for packets */- IDE_AFLAG_ZIP_DRIVE = (1 << 20),+ IDE_AFLAG_ZIP_DRIVE = (1 << 16), /* Supports format progress report */- IDE_AFLAG_SRFP = (1 << 22),+ IDE_AFLAG_SRFP = (1 << 17), /* ide-tape */- IDE_AFLAG_IGNORE_DSC = (1 << 23),+ IDE_AFLAG_IGNORE_DSC = (1 << 18), /* 0 When the tape position is unknown */- IDE_AFLAG_ADDRESS_VALID = (1 << 24),+ IDE_AFLAG_ADDRESS_VALID = (1 << 19), /* Device already opened */- IDE_AFLAG_BUSY = (1 << 25),+ IDE_AFLAG_BUSY = (1 << 20), /* Attempt to auto-detect the current user block size */- IDE_AFLAG_DETECT_BS = (1 << 26),+ IDE_AFLAG_DETECT_BS = (1 << 21), /* Currently on a filemark */- IDE_AFLAG_FILEMARK = (1 << 27),+ IDE_AFLAG_FILEMARK = (1 << 22), /* 0 = no tape is loaded, so we don't rewind after ejecting */- IDE_AFLAG_MEDIUM_PRESENT = (1 << 28),+ IDE_AFLAG_MEDIUM_PRESENT = (1 << 23), - IDE_AFLAG_NO_AUTOCLOSE = (1 << 29),+ IDE_AFLAG_NO_AUTOCLOSE = (1 << 24), }; /* device flags */@@ -565,28 +559,26 @@ enum { IDE_DFLAG_NODMA = (1 << 16), /* powermanagment told us not to do anything, so sleep nicely */ IDE_DFLAG_BLOCKED = (1 << 17),- /* ide-scsi emulation */- IDE_DFLAG_SCSI = (1 << 18), /* sleeping & sleep field valid */- IDE_DFLAG_SLEEPING = (1 << 19),- IDE_DFLAG_POST_RESET = (1 << 20),- IDE_DFLAG_UDMA33_WARNED = (1 << 21),- IDE_DFLAG_LBA48 = (1 << 22),+ IDE_DFLAG_SLEEPING = (1 << 18),+ IDE_DFLAG_POST_RESET = (1 << 19),+ IDE_DFLAG_UDMA33_WARNED = (1 << 20),+ IDE_DFLAG_LBA48 = (1 << 21), /* status of write cache */- IDE_DFLAG_WCACHE = (1 << 23),+ IDE_DFLAG_WCACHE = (1 << 22), /* used for ignoring ATA_DF */- IDE_DFLAG_NOWERR = (1 << 24),+ IDE_DFLAG_NOWERR = (1 << 23), /* retrying in PIO */- IDE_DFLAG_DMA_PIO_RETRY = (1 << 25),- IDE_DFLAG_LBA = (1 << 26),+ IDE_DFLAG_DMA_PIO_RETRY = (1 << 24),+ IDE_DFLAG_LBA = (1 << 25), /* don't unload heads */- IDE_DFLAG_NO_UNLOAD = (1 << 27),+ IDE_DFLAG_NO_UNLOAD = (1 << 26), /* heads unloaded, please don't reset port */- IDE_DFLAG_PARKED = (1 << 28),- IDE_DFLAG_MEDIA_CHANGED = (1 << 29),+ IDE_DFLAG_PARKED = (1 << 27),+ IDE_DFLAG_MEDIA_CHANGED = (1 << 28), /* write protect */- IDE_DFLAG_WP = (1 << 30),- IDE_DFLAG_FORMAT_IN_PROGRESS = (1 << 31),+ IDE_DFLAG_WP = (1 << 29),+ IDE_DFLAG_FORMAT_IN_PROGRESS = (1 << 30), }; struct ide_drive_s {@@ -610,8 +602,6 @@ struct ide_drive_s { unsigned long dev_flags; unsigned long sleep; /* sleep until this time */- unsigned long service_start; /* time we started last request */- unsigned long service_time; /* service time of last request */ unsigned long timeout; /* max time to wait for irq */ special_t special; /* special action flags */@@ -879,8 +869,6 @@ typedef struct hwgroup_s { /* BOOL: protects all fields below */ volatile int busy;- /* BOOL: wake us up on timer expiry */- unsigned int sleeping : 1; /* BOOL: polling active & poll_timeout field valid */ unsigned int polling : 1; @@ -1258,14 +1246,11 @@ int ide_set_media_lock(ide_drive_t *, struct gendisk *, int); void ide_create_request_sense_cmd(ide_drive_t *, struct ide_atapi_pc *); void ide_retry_pc(ide_drive_t *, struct gendisk *); -static inline unsigned long ide_scsi_get_timeout(struct ide_atapi_pc *pc)-{- return max_t(unsigned long, WAIT_CMD, pc->timeout - jiffies);-}+int ide_cd_expiry(ide_drive_t *); -int ide_scsi_expiry(ide_drive_t *);+int ide_cd_get_xferlen(struct request *); -ide_startstop_t ide_issue_pc(ide_drive_t *, unsigned int, ide_expiry_t *);+ide_startstop_t ide_issue_pc(ide_drive_t *); ide_startstop_t do_rw_taskfile(ide_drive_t *, ide_task_t *); @@ -1287,6 +1272,26 @@ extern void ide_stall_queue(ide_drive_t *drive, unsigned long timeout); extern void ide_timer_expiry(unsigned long); extern irqreturn_t ide_intr(int irq, void *dev_id);++static inline int ide_lock_hwgroup(ide_hwgroup_t *hwgroup)+{+ if (hwgroup->busy)+ return 1;++ hwgroup->busy = 1;+ /* for atari only */+ ide_get_lock(ide_intr, hwgroup);++ return 0;+}++static inline void ide_unlock_hwgroup(ide_hwgroup_t *hwgroup)+{+ /* for atari only */+ ide_release_lock();+ hwgroup->busy = 0;+}+ extern void do_ide_request(struct request_queue *); void ide_init_disk(struct gendisk *, ide_drive_t *);@@ -1533,6 +1538,7 @@ void ide_unregister_region(struct gendisk *); void ide_undecoded_slave(ide_drive_t *); void ide_port_apply_params(ide_hwif_t *);+int ide_sysfs_register_port(ide_hwif_t *); struct ide_host *ide_host_alloc(const struct ide_port_info *, hw_regs_t **); void ide_host_free(struct ide_host *);@@ -1627,6 +1633,9 @@ extern struct mutex ide_cfg_mtx; #define local_irq_set(flags) do { local_save_flags((flags)); local_irq_enable_in_hardirq(); } while (0) +char *ide_media_string(ide_drive_t *);++extern struct device_attribute ide_dev_attrs[]; extern struct bus_type ide_bus_type; extern struct class *ide_port_class; {.n++%ݶw{.n+{G{ayʇڙ,jfhz_(階ݢj"mG?&~iOzv^m ?I