From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-11.1 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,MIME_BASE64_TEXT,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, UNPARSEABLE_RELAY,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 64C8CC433E1 for ; Tue, 18 Aug 2020 07:15:11 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 1956120658 for ; Tue, 18 Aug 2020 07:15:11 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="BXQ1jqGf" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726806AbgHRHPH (ORCPT ); Tue, 18 Aug 2020 03:15:07 -0400 Received: from mailgw02.mediatek.com ([210.61.82.184]:26578 "EHLO mailgw02.mediatek.com" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1726451AbgHRHO7 (ORCPT ); Tue, 18 Aug 2020 03:14:59 -0400 X-UUID: aec5409d07ba411c8f7842eb143193f2-20200818 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=agOiGUWOjxDew40igvpbtiYlL977voFJJ+jPDiFQ9G0=; b=BXQ1jqGfqH9ansVgxDUDSr8s0ofSpQUJxu6NjURVEbGKqIrZmm/pav7RG5/GELtFf69X7PNbawvRYJq8TU0D6cSq8vN5axRf7hvb8tCgRDCeAi0tO7EwwP5CwboRUzK6fvUDzwVnnk3Q90rhishjwKJ06A0enI8kO8o7uSIA3V8=; X-UUID: aec5409d07ba411c8f7842eb143193f2-20200818 Received: from mtkexhb01.mediatek.inc [(172.21.101.102)] by mailgw02.mediatek.com (envelope-from ) (Cellopoint E-mail Firewall v4.1.10 Build 0809 with TLS) with ESMTP id 1859041943; Tue, 18 Aug 2020 15:14:41 +0800 Received: from mtkcas07.mediatek.inc (172.21.101.84) by mtkmbs07n1.mediatek.inc (172.21.101.16) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Tue, 18 Aug 2020 15:14:38 +0800 Received: from mtksdccf07.mediatek.inc (172.21.84.99) by mtkcas07.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Tue, 18 Aug 2020 15:14:39 +0800 From: Landen Chao To: , , , , , CC: , , , , , , , , , Landen Chao Subject: [PATCH net-next v2 5/7] net: dsa: mt7530: Add the support of MT7531 switch Date: Tue, 18 Aug 2020 15:14:10 +0800 Message-ID: X-Mailer: git-send-email 2.18.0 In-Reply-To: References: MIME-Version: 1.0 Content-Type: text/plain X-MTK: N Content-Transfer-Encoding: base64 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org QWRkIG5ldyBzdXBwb3J0IGZvciBNVDc1MzE6DQoNCk1UNzUzMSBpcyB0aGUgbmV4dCBnZW5lcmF0 aW9uIG9mIE1UNzUzMC4gSXQgaXMgYWxzbyBhIDctcG9ydHMgc3dpdGNoIHdpdGgNCjUgZ2lnYSBl bWJlZGRlZCBwaHlzLCAyIGNwdSBwb3J0cywgYW5kIHRoZSBzYW1lIE1BQyBsb2dpYyBvZiBNVDc1 MzAuIENwdQ0KcG9ydCA2IG9ubHkgc3VwcG9ydHMgU0dNSUkgaW50ZXJmYWNlLiBDcHUgcG9ydCA1 IHN1cHBvcnRzIGVpdGhlciBSR01JSQ0Kb3IgU0dNSUkgaW4gZGlmZmVyZW50IEhXIHNrdS4gRHVl IHRvIFNHTUlJIGludGVyZmFjZSBzdXBwb3J0LCBwbGwsIGFuZA0KcGFkIHNldHRpbmcgYXJlIGRp ZmZlcmVudCBmcm9tIE1UNzUzMC4gVGhpcyBwYXRjaCBhZGRzIGRpZmZlcmVudCBpbml0aWFsDQpz ZXR0aW5nLCBhbmQgU0dNSUkgcGh5bGluayBoYW5kbGVycyBvZiBNVDc1MzEuDQoNCk1UNzUzMSBT R01JSSBpbnRlcmZhY2UgY2FuIGJlIGNvbmZpZ3VyZWQgaW4gZm9sbG93aW5nIG1vZGU6DQotICdT R01JSSBBTiBtb2RlJyB3aXRoIGluLWJhbmQgbmVnb3RpYXRpb24gY2FwYWJpbGl0eQ0KICAgIHdo aWNoIGlzIGNvbXBhdGlibGUgd2l0aCBQSFlfSU5URVJGQUNFX01PREVfU0dNSUkuDQotICdTR01J SSBmb3JjZSBtb2RlJyB3aXRob3V0IGluLWJuYWQgbmVnb3RpYXRpb24NCiAgICB3aGljaCBpcyBj b21wYXRpYmxlIHdpdGggMTBCLzhCIGVuY29kaW5nIG9mDQogICAgUEhZX0lOVEVSRkFDRV9NT0RF XzEwMDBCQVNFWCB3aXRoIGZpeGVkIGZ1bGwtZHVwbGV4IGFuZCBmaXhlZCBwYXVzZS4NCi0gMi41 IHRpbWVzIGZhc3RlciBjbG9ja2VkICdTR01JSSBmb3JjZSBtb2RlJyB3aXRob3V0IGluLWJuYWQg bmVnb3RpYXRpb24NCiAgICB3aGljaCBpcyBjb21wYXRpYmxlIHdpdGggMTBCLzhCIGVuY29kaW5n IG9mDQogICAgUEhZX0lOVEVSRkFDRV9NT0RFXzI1MDBCQVNFWCB3aXRoIGZpeGVkIGZ1bGwtZHVw bGV4IGFuZCBmaXhlZCBwYXVzZS4NCg0KU2lnbmVkLW9mZi1ieTogTGFuZGVuIENoYW8gPGxhbmRl bi5jaGFvQG1lZGlhdGVrLmNvbT4NClNpZ25lZC1vZmYtYnk6IFNlYW4gV2FuZyA8c2Vhbi53YW5n QG1lZGlhdGVrLmNvbT4NCi0tLQ0KIGRyaXZlcnMvbmV0L2RzYS9LY29uZmlnICB8ICAgNiArLQ0K IGRyaXZlcnMvbmV0L2RzYS9tdDc1MzAuYyB8IDkwOCArKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrLS0NCiBkcml2ZXJzL25ldC9kc2EvbXQ3NTMwLmggfCAyMjIgKysrKysrKysr Kw0KIDMgZmlsZXMgY2hhbmdlZCwgMTEwOSBpbnNlcnRpb25zKCspLCAyNyBkZWxldGlvbnMoLSkN Cg0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2RzYS9LY29uZmlnIGIvZHJpdmVycy9uZXQvZHNh L0tjb25maWcNCmluZGV4IDY2Nzg0NDEyYjY4My4uZTc3NzgxZDc5MWE5IDEwMDY0NA0KLS0tIGEv ZHJpdmVycy9uZXQvZHNhL0tjb25maWcNCisrKyBiL2RyaXZlcnMvbmV0L2RzYS9LY29uZmlnDQpA QCAtMzMsMTIgKzMzLDEyIEBAIGNvbmZpZyBORVRfRFNBX0xBTlRJUV9HU1dJUA0KIAkgIHRoZSB4 cngyMDAgLyBWUjkgU29DLg0KIA0KIGNvbmZpZyBORVRfRFNBX01UNzUzMA0KLQl0cmlzdGF0ZSAi TWVkaWFUZWsgTVQ3NTMwIGFuZCBNVDc2MjEgRXRoZXJuZXQgc3dpdGNoIHN1cHBvcnQiDQorCXRy aXN0YXRlICJNZWRpYVRlayBNVDc1M3ggYW5kIE1UNzYyMSBFdGhlcm5ldCBzd2l0Y2ggc3VwcG9y dCINCiAJZGVwZW5kcyBvbiBORVRfRFNBDQogCXNlbGVjdCBORVRfRFNBX1RBR19NVEsNCiAJaGVs cA0KLQkgIFRoaXMgZW5hYmxlcyBzdXBwb3J0IGZvciB0aGUgTWVkaWFUZWsgTVQ3NTMwIGFuZCBN VDc2MjEgRXRoZXJuZXQNCi0JICBzd2l0Y2ggY2hpcC4NCisJICBUaGlzIGVuYWJsZXMgc3VwcG9y dCBmb3IgdGhlIE1lZGlhVGVrIE1UNzUzMCwgTVQ3NTMxLCBhbmQgTVQ3NjIxDQorCSAgRXRoZXJu ZXQgc3dpdGNoIGNoaXBzLg0KIA0KIGNvbmZpZyBORVRfRFNBX01WODhFNjA2MA0KIAl0cmlzdGF0 ZSAiTWFydmVsbCA4OEU2MDYwIGV0aGVybmV0IHN3aXRjaCBjaGlwIHN1cHBvcnQiDQpkaWZmIC0t Z2l0IGEvZHJpdmVycy9uZXQvZHNhL210NzUzMC5jIGIvZHJpdmVycy9uZXQvZHNhL210NzUzMC5j DQppbmRleCBkMzBiNDE3MjViNGQuLmE2M2EzMTkwODlmNyAxMDA2NDQNCi0tLSBhL2RyaXZlcnMv bmV0L2RzYS9tdDc1MzAuYw0KKysrIGIvZHJpdmVycy9uZXQvZHNhL210NzUzMC5jDQpAQCAtMjMz LDYgKzIzMywxMiBAQCBtdDc1MzBfd3JpdGUoc3RydWN0IG10NzUzMF9wcml2ICpwcml2LCB1MzIg cmVnLCB1MzIgdmFsKQ0KIAltdXRleF91bmxvY2soJmJ1cy0+bWRpb19sb2NrKTsNCiB9DQogDQor c3RhdGljIHUzMg0KK19tdDc1MzBfdW5sb2NrZWRfcmVhZChzdHJ1Y3QgbXQ3NTMwX2R1bW15X3Bv bGwgKnApDQorew0KKwlyZXR1cm4gbXQ3NTMwX21paV9yZWFkKHAtPnByaXYsIHAtPnJlZyk7DQor fQ0KKw0KIHN0YXRpYyB1MzINCiBfbXQ3NTMwX3JlYWQoc3RydWN0IG10NzUzMF9kdW1teV9wb2xs ICpwKQ0KIHsNCkBAIC00ODMsNiArNDg5LDEwOCBAQCBtdDc1MzBfcGFkX2Nsa19zZXR1cChzdHJ1 Y3QgZHNhX3N3aXRjaCAqZHMsIHBoeV9pbnRlcmZhY2VfdCBpbnRlcmZhY2UpDQogCXJldHVybiAw Ow0KIH0NCiANCitzdGF0aWMgYm9vbCBtdDc1MzFfZHVhbF9zZ21paV9zdXBwb3J0ZWQoc3RydWN0 IG10NzUzMF9wcml2ICpwcml2KQ0KK3sNCisJdTMyIHZhbDsNCisNCisJdmFsID0gbXQ3NTMwX3Jl YWQocHJpdiwgTVQ3NTMxX1RPUF9TSUdfU1IpOw0KKw0KKwlyZXR1cm4gKHZhbCAmIFBBRF9EVUFM X1NHTUlJX0VOKSAhPSAwOw0KK30NCisNCitzdGF0aWMgaW50DQorbXQ3NTMxX3BhZF9zZXR1cChz dHJ1Y3QgZHNhX3N3aXRjaCAqZHMsIHBoeV9pbnRlcmZhY2VfdCBpbnRlcmZhY2UpDQorew0KKwlz dHJ1Y3QgbXQ3NTMwX3ByaXYgKnByaXYgPSBkcy0+cHJpdjsNCisJdTMyIHZhbDsNCisJdTMyIHRv cF9zaWc7DQorCXUzMiBod3N0cmFwOw0KKwl1MzIgeHRhbDsNCisNCisJaWYgKG10NzUzMV9kdWFs X3NnbWlpX3N1cHBvcnRlZChwcml2KSkNCisJCXJldHVybiAwOw0KKw0KKwl2YWwgPSBtdDc1MzBf cmVhZChwcml2LCBNVDc1MzFfQ1JFVik7DQorCXRvcF9zaWcgPSBtdDc1MzBfcmVhZChwcml2LCBN VDc1MzFfVE9QX1NJR19TUik7DQorCWh3c3RyYXAgPSBtdDc1MzBfcmVhZChwcml2LCBNVDc1MzFf SFdUUkFQKTsNCisJaWYgKCh2YWwgJiBDSElQX1JFVl9NKSA+IDApDQorCQl4dGFsID0gKHRvcF9z aWcgJiBQQURfTUNNX1NNSV9FTikgPyBIV1RSQVBfWFRBTF9GU0VMXzQwTUhaIDoNCisJCQkJCQkg ICAgSFdUUkFQX1hUQUxfRlNFTF8yNU1IWjsNCisJZWxzZQ0KKwkJeHRhbCA9IGh3c3RyYXAgJiBI V1RSQVBfWFRBTF9GU0VMX01BU0s7DQorDQorCS8qIFN0ZXAgMSA6IERpc2FibGUgTVQ3NTMxIENP UkVQTEwgKi8NCisJdmFsID0gbXQ3NTMwX3JlYWQocHJpdiwgTVQ3NTMxX1BMTEdQX0VOKTsNCisJ dmFsICY9IH5FTl9DT1JFUExMOw0KKwltdDc1MzBfd3JpdGUocHJpdiwgTVQ3NTMxX1BMTEdQX0VO LCB2YWwpOw0KKw0KKwkvKiBTdGVwIDI6IHN3aXRjaCB0byBYVEFMIG91dHB1dCAqLw0KKwl2YWwg PSBtdDc1MzBfcmVhZChwcml2LCBNVDc1MzFfUExMR1BfRU4pOw0KKwl2YWwgfD0gU1dfQ0xLU1c7 DQorCW10NzUzMF93cml0ZShwcml2LCBNVDc1MzFfUExMR1BfRU4sIHZhbCk7DQorDQorCXZhbCA9 IG10NzUzMF9yZWFkKHByaXYsIE1UNzUzMV9QTExHUF9DUjApOw0KKwl2YWwgJj0gflJHX0NPUkVQ TExfRU47DQorCW10NzUzMF93cml0ZShwcml2LCBNVDc1MzFfUExMR1BfQ1IwLCB2YWwpOw0KKw0K KwkvKiBTdGVwIDM6IGRpc2FibGUgUExMR1AgYW5kIGVuYWJsZSBwcm9ncmFtIFBMTEdQICovDQor CXZhbCA9IG10NzUzMF9yZWFkKHByaXYsIE1UNzUzMV9QTExHUF9FTik7DQorCXZhbCB8PSBTV19Q TExHUDsNCisJbXQ3NTMwX3dyaXRlKHByaXYsIE1UNzUzMV9QTExHUF9FTiwgdmFsKTsNCisNCisJ LyogU3RlcCA0OiBwcm9ncmFtIENPUkVQTEwgb3V0cHV0IGZyZXF1ZW5jeSB0byA1MDBNSHogKi8N CisJdmFsID0gbXQ3NTMwX3JlYWQocHJpdiwgTVQ3NTMxX1BMTEdQX0NSMCk7DQorCXZhbCAmPSB+ UkdfQ09SRVBMTF9QT1NESVZfTTsNCisJdmFsIHw9IDIgPDwgUkdfQ09SRVBMTF9QT1NESVZfUzsN CisJbXQ3NTMwX3dyaXRlKHByaXYsIE1UNzUzMV9QTExHUF9DUjAsIHZhbCk7DQorCXVzbGVlcF9y YW5nZSgyNSwgMzUpOw0KKw0KKwlzd2l0Y2ggKHh0YWwpIHsNCisJY2FzZSBIV1RSQVBfWFRBTF9G U0VMXzI1TUhaOg0KKwkJdmFsID0gbXQ3NTMwX3JlYWQocHJpdiwgTVQ3NTMxX1BMTEdQX0NSMCk7 DQorCQl2YWwgJj0gflJHX0NPUkVQTExfU0RNX1BDV19NOw0KKwkJdmFsIHw9IDB4MTQwMDAwIDw8 IFJHX0NPUkVQTExfU0RNX1BDV19TOw0KKwkJbXQ3NTMwX3dyaXRlKHByaXYsIE1UNzUzMV9QTExH UF9DUjAsIHZhbCk7DQorCQlicmVhazsNCisJY2FzZSBIV1RSQVBfWFRBTF9GU0VMXzQwTUhaOg0K KwkJdmFsID0gbXQ3NTMwX3JlYWQocHJpdiwgTVQ3NTMxX1BMTEdQX0NSMCk7DQorCQl2YWwgJj0g flJHX0NPUkVQTExfU0RNX1BDV19NOw0KKwkJdmFsIHw9IDB4MTkwMDAwIDw8IFJHX0NPUkVQTExf U0RNX1BDV19TOw0KKwkJbXQ3NTMwX3dyaXRlKHByaXYsIE1UNzUzMV9QTExHUF9DUjAsIHZhbCk7 DQorCQlicmVhazsNCisJfTsNCisNCisJLyogU2V0IGZlZWRiYWNrIGRpdmlkZSByYXRpbyB1cGRh dGUgc2lnbmFsIHRvIGhpZ2ggKi8NCisJdmFsID0gbXQ3NTMwX3JlYWQocHJpdiwgTVQ3NTMxX1BM TEdQX0NSMCk7DQorCXZhbCB8PSBSR19DT1JFUExMX1NETV9QQ1dfQ0hHOw0KKwltdDc1MzBfd3Jp dGUocHJpdiwgTVQ3NTMxX1BMTEdQX0NSMCwgdmFsKTsNCisJLyogV2FpdCBmb3IgYXQgbGVhc3Qg MTYgWFRBTCBjbG9ja3MgKi8NCisJdXNsZWVwX3JhbmdlKDEwLCAyMCk7DQorDQorCS8qIFN0ZXAg NTogc2V0IGZlZWRiYWNrIGRpdmlkZSByYXRpbyB1cGRhdGUgc2lnbmFsIHRvIGxvdyAqLw0KKwl2 YWwgPSBtdDc1MzBfcmVhZChwcml2LCBNVDc1MzFfUExMR1BfQ1IwKTsNCisJdmFsICY9IH5SR19D T1JFUExMX1NETV9QQ1dfQ0hHOw0KKwltdDc1MzBfd3JpdGUocHJpdiwgTVQ3NTMxX1BMTEdQX0NS MCwgdmFsKTsNCisNCisJLyogRW5hYmxlIDMyNU0gY2xvY2sgZm9yIFNHTUlJICovDQorCW10NzUz MF93cml0ZShwcml2LCBNVDc1MzFfQU5BX1BMTEdQX0NSNSwgMHhhZDAwMDApOw0KKw0KKwkvKiBF bmFibGUgMjUwU1NDIGNsb2NrIGZvciBSR01JSSAqLw0KKwltdDc1MzBfd3JpdGUocHJpdiwgTVQ3 NTMxX0FOQV9QTExHUF9DUjIsIDB4NGY0MDAwMCk7DQorDQorCS8qIFN0ZXAgNjogRW5hYmxlIE1U NzUzMSBQTEwgKi8NCisJdmFsID0gbXQ3NTMwX3JlYWQocHJpdiwgTVQ3NTMxX1BMTEdQX0NSMCk7 DQorCXZhbCB8PSBSR19DT1JFUExMX0VOOw0KKwltdDc1MzBfd3JpdGUocHJpdiwgTVQ3NTMxX1BM TEdQX0NSMCwgdmFsKTsNCisNCisJdmFsID0gbXQ3NTMwX3JlYWQocHJpdiwgTVQ3NTMxX1BMTEdQ X0VOKTsNCisJdmFsIHw9IEVOX0NPUkVQTEw7DQorCW10NzUzMF93cml0ZShwcml2LCBNVDc1MzFf UExMR1BfRU4sIHZhbCk7DQorCXVzbGVlcF9yYW5nZSgyNSwgMzUpOw0KKw0KKwlyZXR1cm4gMDsN Cit9DQorDQogc3RhdGljIHZvaWQNCiBtdDc1MzBfbWliX3Jlc2V0KHN0cnVjdCBkc2Ffc3dpdGNo ICpkcykNCiB7DQpAQCAtNTA3LDYgKzYxNSwyMTcgQEAgc3RhdGljIGludCBtdDc1MzBfcGh5X3dy aXRlKHN0cnVjdCBkc2Ffc3dpdGNoICpkcywgaW50IHBvcnQsIGludCByZWdudW0sDQogCXJldHVy biBtZGlvYnVzX3dyaXRlX25lc3RlZChwcml2LT5idXMsIHBvcnQsIHJlZ251bSwgdmFsKTsNCiB9 DQogDQorc3RhdGljIGludA0KK210NzUzMV9pbmRfYzQ1X3BoeV9yZWFkKHN0cnVjdCBtdDc1MzBf cHJpdiAqcHJpdiwgaW50IHBvcnQsIGludCBkZXZhZCwNCisJCQlpbnQgcmVnbnVtKQ0KK3sNCisJ c3RydWN0IG1paV9idXMgKmJ1cyA9IHByaXYtPmJ1czsNCisJc3RydWN0IG10NzUzMF9kdW1teV9w b2xsIHA7DQorCXUzMiByZWcsIHZhbDsNCisJaW50IHJldDsNCisNCisJSU5JVF9NVDc1MzBfRFVN TVlfUE9MTCgmcCwgcHJpdiwgTVQ3NTMxX1BIWV9JQUMpOw0KKw0KKwltdXRleF9sb2NrX25lc3Rl ZCgmYnVzLT5tZGlvX2xvY2ssIE1ESU9fTVVURVhfTkVTVEVEKTsNCisNCisJcmV0ID0gcmVhZHhf cG9sbF90aW1lb3V0KF9tdDc1MzBfdW5sb2NrZWRfcmVhZCwgJnAsIHZhbCwNCisJCQkJICEodmFs ICYgTVQ3NTMxX1BIWV9BQ1NfU1QpLCAyMCwgMTAwMDAwKTsNCisJaWYgKHJldCA8IDApIHsNCisJ CWRldl9lcnIocHJpdi0+ZGV2LCAicG9sbCB0aW1lb3V0XG4iKTsNCisJCWdvdG8gb3V0Ow0KKwl9 DQorDQorCXJlZyA9IE1UNzUzMV9NRElPX0NMNDVfQUREUiB8IE1UNzUzMV9NRElPX1BIWV9BRERS KHBvcnQpIHwNCisJICAgICAgTVQ3NTMxX01ESU9fREVWX0FERFIoZGV2YWQpIHwgcmVnbnVtOw0K KwltdDc1MzBfbWlpX3dyaXRlKHByaXYsIE1UNzUzMV9QSFlfSUFDLCByZWcgfCBNVDc1MzFfUEhZ X0FDU19TVCk7DQorDQorCXJldCA9IHJlYWR4X3BvbGxfdGltZW91dChfbXQ3NTMwX3VubG9ja2Vk X3JlYWQsICZwLCB2YWwsDQorCQkJCSAhKHZhbCAmIE1UNzUzMV9QSFlfQUNTX1NUKSwgMjAsIDEw MDAwMCk7DQorCWlmIChyZXQgPCAwKSB7DQorCQlkZXZfZXJyKHByaXYtPmRldiwgInBvbGwgdGlt ZW91dFxuIik7DQorCQlnb3RvIG91dDsNCisJfQ0KKw0KKwlyZWcgPSBNVDc1MzFfTURJT19DTDQ1 X1JFQUQgfCBNVDc1MzFfTURJT19QSFlfQUREUihwb3J0KSB8DQorCSAgICAgIE1UNzUzMV9NRElP X0RFVl9BRERSKGRldmFkKTsNCisJbXQ3NTMwX21paV93cml0ZShwcml2LCBNVDc1MzFfUEhZX0lB QywgcmVnIHwgTVQ3NTMxX1BIWV9BQ1NfU1QpOw0KKw0KKwlyZXQgPSByZWFkeF9wb2xsX3RpbWVv dXQoX210NzUzMF91bmxvY2tlZF9yZWFkLCAmcCwgdmFsLA0KKwkJCQkgISh2YWwgJiBNVDc1MzFf UEhZX0FDU19TVCksIDIwLCAxMDAwMDApOw0KKwlpZiAocmV0IDwgMCkgew0KKwkJZGV2X2Vycihw cml2LT5kZXYsICJwb2xsIHRpbWVvdXRcbiIpOw0KKwkJZ290byBvdXQ7DQorCX0NCisNCisJcmV0 ID0gdmFsICYgTVQ3NTMxX01ESU9fUldfREFUQV9NQVNLOw0KK291dDoNCisJbXV0ZXhfdW5sb2Nr KCZidXMtPm1kaW9fbG9jayk7DQorDQorCXJldHVybiByZXQ7DQorfQ0KKw0KK3N0YXRpYyBpbnQN CittdDc1MzFfaW5kX2M0NV9waHlfd3JpdGUoc3RydWN0IG10NzUzMF9wcml2ICpwcml2LCBpbnQg cG9ydCwgaW50IGRldmFkLA0KKwkJCSBpbnQgcmVnbnVtLCB1MzIgZGF0YSkNCit7DQorCXN0cnVj dCBtaWlfYnVzICpidXMgPSBwcml2LT5idXM7DQorCXN0cnVjdCBtdDc1MzBfZHVtbXlfcG9sbCBw Ow0KKwl1MzIgdmFsLCByZWc7DQorCWludCByZXQ7DQorDQorCUlOSVRfTVQ3NTMwX0RVTU1ZX1BP TEwoJnAsIHByaXYsIE1UNzUzMV9QSFlfSUFDKTsNCisNCisJbXV0ZXhfbG9ja19uZXN0ZWQoJmJ1 cy0+bWRpb19sb2NrLCBNRElPX01VVEVYX05FU1RFRCk7DQorDQorCXJldCA9IHJlYWR4X3BvbGxf dGltZW91dChfbXQ3NTMwX3VubG9ja2VkX3JlYWQsICZwLCB2YWwsDQorCQkJCSAhKHZhbCAmIE1U NzUzMV9QSFlfQUNTX1NUKSwgMjAsIDEwMDAwMCk7DQorCWlmIChyZXQgPCAwKSB7DQorCQlkZXZf ZXJyKHByaXYtPmRldiwgInBvbGwgdGltZW91dFxuIik7DQorCQlnb3RvIG91dDsNCisJfQ0KKw0K KwlyZWcgPSBNVDc1MzFfTURJT19DTDQ1X0FERFIgfCBNVDc1MzFfTURJT19QSFlfQUREUihwb3J0 KSB8DQorCSAgICAgIE1UNzUzMV9NRElPX0RFVl9BRERSKGRldmFkKSB8IHJlZ251bTsNCisJbXQ3 NTMwX21paV93cml0ZShwcml2LCBNVDc1MzFfUEhZX0lBQywgcmVnIHwgTVQ3NTMxX1BIWV9BQ1Nf U1QpOw0KKw0KKwlyZXQgPSByZWFkeF9wb2xsX3RpbWVvdXQoX210NzUzMF91bmxvY2tlZF9yZWFk LCAmcCwgdmFsLA0KKwkJCQkgISh2YWwgJiBNVDc1MzFfUEhZX0FDU19TVCksIDIwLCAxMDAwMDAp Ow0KKwlpZiAocmV0IDwgMCkgew0KKwkJZGV2X2Vycihwcml2LT5kZXYsICJwb2xsIHRpbWVvdXRc biIpOw0KKwkJZ290byBvdXQ7DQorCX0NCisNCisJcmVnID0gTVQ3NTMxX01ESU9fQ0w0NV9XUklU RSB8IE1UNzUzMV9NRElPX1BIWV9BRERSKHBvcnQpIHwNCisJICAgICAgTVQ3NTMxX01ESU9fREVW X0FERFIoZGV2YWQpIHwgZGF0YTsNCisJbXQ3NTMwX21paV93cml0ZShwcml2LCBNVDc1MzFfUEhZ X0lBQywgcmVnIHwgTVQ3NTMxX1BIWV9BQ1NfU1QpOw0KKw0KKwlyZXQgPSByZWFkeF9wb2xsX3Rp bWVvdXQoX210NzUzMF91bmxvY2tlZF9yZWFkLCAmcCwgdmFsLA0KKwkJCQkgISh2YWwgJiBNVDc1 MzFfUEhZX0FDU19TVCksIDIwLCAxMDAwMDApOw0KKwlpZiAocmV0IDwgMCkgew0KKwkJZGV2X2Vy cihwcml2LT5kZXYsICJwb2xsIHRpbWVvdXRcbiIpOw0KKwkJZ290byBvdXQ7DQorCX0NCisNCitv dXQ6DQorCW11dGV4X3VubG9jaygmYnVzLT5tZGlvX2xvY2spOw0KKw0KKwlyZXR1cm4gcmV0Ow0K K30NCisNCitzdGF0aWMgaW50DQorbXQ3NTMxX2luZF9jMjJfcGh5X3JlYWQoc3RydWN0IG10NzUz MF9wcml2ICpwcml2LCBpbnQgcG9ydCwgaW50IHJlZ251bSkNCit7DQorCXN0cnVjdCBtaWlfYnVz ICpidXMgPSBwcml2LT5idXM7DQorCXN0cnVjdCBtdDc1MzBfZHVtbXlfcG9sbCBwOw0KKwlpbnQg cmV0Ow0KKwl1MzIgdmFsOw0KKw0KKwlJTklUX01UNzUzMF9EVU1NWV9QT0xMKCZwLCBwcml2LCBN VDc1MzFfUEhZX0lBQyk7DQorDQorCW11dGV4X2xvY2tfbmVzdGVkKCZidXMtPm1kaW9fbG9jaywg TURJT19NVVRFWF9ORVNURUQpOw0KKw0KKwlyZXQgPSByZWFkeF9wb2xsX3RpbWVvdXQoX210NzUz MF91bmxvY2tlZF9yZWFkLCAmcCwgdmFsLA0KKwkJCQkgISh2YWwgJiBNVDc1MzFfUEhZX0FDU19T VCksIDIwLCAxMDAwMDApOw0KKwlpZiAocmV0IDwgMCkgew0KKwkJZGV2X2Vycihwcml2LT5kZXYs ICJwb2xsIHRpbWVvdXRcbiIpOw0KKwkJZ290byBvdXQ7DQorCX0NCisNCisJdmFsID0gTVQ3NTMx X01ESU9fQ0wyMl9SRUFEIHwgTVQ3NTMxX01ESU9fUEhZX0FERFIocG9ydCkgfA0KKwkgICAgICBN VDc1MzFfTURJT19SRUdfQUREUihyZWdudW0pOw0KKw0KKwltdDc1MzBfbWlpX3dyaXRlKHByaXYs IE1UNzUzMV9QSFlfSUFDLCB2YWwgfCBNVDc1MzFfUEhZX0FDU19TVCk7DQorDQorCXJldCA9IHJl YWR4X3BvbGxfdGltZW91dChfbXQ3NTMwX3VubG9ja2VkX3JlYWQsICZwLCB2YWwsDQorCQkJCSAh KHZhbCAmIE1UNzUzMV9QSFlfQUNTX1NUKSwgMjAsIDEwMDAwMCk7DQorCWlmIChyZXQgPCAwKSB7 DQorCQlkZXZfZXJyKHByaXYtPmRldiwgInBvbGwgdGltZW91dFxuIik7DQorCQlnb3RvIG91dDsN CisJfQ0KKw0KKwlyZXQgPSB2YWwgJiBNVDc1MzFfTURJT19SV19EQVRBX01BU0s7DQorb3V0Og0K KwltdXRleF91bmxvY2soJmJ1cy0+bWRpb19sb2NrKTsNCisNCisJcmV0dXJuIHJldDsNCit9DQor DQorc3RhdGljIGludA0KK210NzUzMV9pbmRfYzIyX3BoeV93cml0ZShzdHJ1Y3QgbXQ3NTMwX3By aXYgKnByaXYsIGludCBwb3J0LCBpbnQgcmVnbnVtLA0KKwkJCSB1MTYgZGF0YSkNCit7DQorCXN0 cnVjdCBtaWlfYnVzICpidXMgPSBwcml2LT5idXM7DQorCXN0cnVjdCBtdDc1MzBfZHVtbXlfcG9s bCBwOw0KKwlpbnQgcmV0Ow0KKwl1MzIgcmVnOw0KKw0KKwlJTklUX01UNzUzMF9EVU1NWV9QT0xM KCZwLCBwcml2LCBNVDc1MzFfUEhZX0lBQyk7DQorDQorCW11dGV4X2xvY2tfbmVzdGVkKCZidXMt Pm1kaW9fbG9jaywgTURJT19NVVRFWF9ORVNURUQpOw0KKw0KKwlyZXQgPSByZWFkeF9wb2xsX3Rp bWVvdXQoX210NzUzMF91bmxvY2tlZF9yZWFkLCAmcCwgcmVnLA0KKwkJCQkgIShyZWcgJiBNVDc1 MzFfUEhZX0FDU19TVCksIDIwLCAxMDAwMDApOw0KKwlpZiAocmV0IDwgMCkgew0KKwkJZGV2X2Vy cihwcml2LT5kZXYsICJwb2xsIHRpbWVvdXRcbiIpOw0KKwkJZ290byBvdXQ7DQorCX0NCisNCisJ cmVnID0gTVQ3NTMxX01ESU9fQ0wyMl9XUklURSB8IE1UNzUzMV9NRElPX1BIWV9BRERSKHBvcnQp IHwNCisJICAgICAgTVQ3NTMxX01ESU9fUkVHX0FERFIocmVnbnVtKSB8IGRhdGE7DQorDQorCW10 NzUzMF9taWlfd3JpdGUocHJpdiwgTVQ3NTMxX1BIWV9JQUMsIHJlZyB8IE1UNzUzMV9QSFlfQUNT X1NUKTsNCisNCisJcmV0ID0gcmVhZHhfcG9sbF90aW1lb3V0KF9tdDc1MzBfdW5sb2NrZWRfcmVh ZCwgJnAsIHJlZywNCisJCQkJICEocmVnICYgTVQ3NTMxX1BIWV9BQ1NfU1QpLCAyMCwgMTAwMDAw KTsNCisJaWYgKHJldCA8IDApIHsNCisJCWRldl9lcnIocHJpdi0+ZGV2LCAicG9sbCB0aW1lb3V0 XG4iKTsNCisJCWdvdG8gb3V0Ow0KKwl9DQorDQorb3V0Og0KKwltdXRleF91bmxvY2soJmJ1cy0+ bWRpb19sb2NrKTsNCisNCisJcmV0dXJuIHJldDsNCit9DQorDQorc3RhdGljIGludA0KK210NzUz MV9pbmRfcGh5X3JlYWQoc3RydWN0IGRzYV9zd2l0Y2ggKmRzLCBpbnQgcG9ydCwgaW50IHJlZ251 bSkNCit7DQorCXN0cnVjdCBtdDc1MzBfcHJpdiAqcHJpdiA9IGRzLT5wcml2Ow0KKwlpbnQgZGV2 YWQ7DQorCWludCByZXQ7DQorDQorCWlmIChyZWdudW0gJiBNSUlfQUREUl9DNDUpIHsNCisJCWRl dmFkID0gKHJlZ251bSA+PiBNSUlfREVWQUREUl9DNDVfU0hJRlQpICYgMHgxZjsNCisJCXJldCA9 IG10NzUzMV9pbmRfYzQ1X3BoeV9yZWFkKHByaXYsIHBvcnQsIGRldmFkLA0KKwkJCQkJICAgICAg cmVnbnVtICYgTUlJX1JFR0FERFJfQzQ1X01BU0spOw0KKwl9IGVsc2Ugew0KKwkJcmV0ID0gbXQ3 NTMxX2luZF9jMjJfcGh5X3JlYWQocHJpdiwgcG9ydCwgcmVnbnVtKTsNCisJfQ0KKw0KKwlyZXR1 cm4gcmV0Ow0KK30NCisNCitzdGF0aWMgaW50DQorbXQ3NTMxX2luZF9waHlfd3JpdGUoc3RydWN0 IGRzYV9zd2l0Y2ggKmRzLCBpbnQgcG9ydCwgaW50IHJlZ251bSwNCisJCSAgICAgdTE2IGRhdGEp DQorew0KKwlzdHJ1Y3QgbXQ3NTMwX3ByaXYgKnByaXYgPSBkcy0+cHJpdjsNCisJaW50IGRldmFk Ow0KKwlpbnQgcmV0Ow0KKw0KKwlpZiAocmVnbnVtICYgTUlJX0FERFJfQzQ1KSB7DQorCQlkZXZh ZCA9IChyZWdudW0gPj4gTUlJX0RFVkFERFJfQzQ1X1NISUZUKSAmIDB4MWY7DQorCQlyZXQgPSBt dDc1MzFfaW5kX2M0NV9waHlfd3JpdGUocHJpdiwgcG9ydCwgZGV2YWQsDQorCQkJCQkgICAgICAg cmVnbnVtICYgTUlJX1JFR0FERFJfQzQ1X01BU0ssDQorCQkJCQkgICAgICAgZGF0YSk7DQorCX0g ZWxzZSB7DQorCQlyZXQgPSBtdDc1MzFfaW5kX2MyMl9waHlfd3JpdGUocHJpdiwgcG9ydCwgcmVn bnVtLCBkYXRhKTsNCisJfQ0KKw0KKwlyZXR1cm4gcmV0Ow0KK30NCisNCiBzdGF0aWMgdm9pZA0K IG10NzUzMF9nZXRfc3RyaW5ncyhzdHJ1Y3QgZHNhX3N3aXRjaCAqZHMsIGludCBwb3J0LCB1MzIg c3RyaW5nc2V0LA0KIAkJICAgdWludDhfdCAqZGF0YSkNCkBAIC02MjMsOSArOTQyLDE0IEBAIHN0 YXRpYyB2b2lkIG10NzUzMF9zZXR1cF9wb3J0NShzdHJ1Y3QgZHNhX3N3aXRjaCAqZHMsIHBoeV9p bnRlcmZhY2VfdCBpbnRlcmZhY2UpDQogfQ0KIA0KIHN0YXRpYyBpbnQNCi1tdDc1MzBfY3B1X3Bv cnRfZW5hYmxlKHN0cnVjdCBtdDc1MzBfcHJpdiAqcHJpdiwNCi0JCSAgICAgICBpbnQgcG9ydCkN CittdDc1M3hfY3B1X3BvcnRfZW5hYmxlKHN0cnVjdCBkc2Ffc3dpdGNoICpkcywgaW50IHBvcnQp DQogew0KKwlzdHJ1Y3QgbXQ3NTMwX3ByaXYgKnByaXYgPSBkcy0+cHJpdjsNCisNCisJLyogU2V0 dXAgbWF4IGNhcGFiaWxpdHkgb2YgQ1BVIHBvcnQgYXQgZmlyc3QgKi8NCisJaWYgKHByaXYtPmlu Zm8tPmNwdV9wb3J0X2NvbmZpZykNCisJCXByaXYtPmluZm8tPmNwdV9wb3J0X2NvbmZpZyhkcywg cG9ydCk7DQorDQogCS8qIEVuYWJsZSBNZWRpYXRlayBoZWFkZXIgbW9kZSBvbiB0aGUgY3B1IHBv cnQgKi8NCiAJbXQ3NTMwX3dyaXRlKHByaXYsIE1UNzUzMF9QVkNfUChwb3J0KSwNCiAJCSAgICAg UE9SVF9TUEVDX1RBRyk7DQpAQCAtNjM4LDcgKzk2Miw3IEBAIG10NzUzMF9jcHVfcG9ydF9lbmFi bGUoc3RydWN0IG10NzUzMF9wcml2ICpwcml2LA0KIAkJbXQ3NTMwX3Jtdyhwcml2LCBNVDc1MzBf TUZDLCBDUFVfTUFTSywgQ1BVX0VOIHwgQ1BVX1BPUlQocG9ydCkpOw0KIA0KIAkvKiBDUFUgcG9y dCBnZXRzIGNvbm5lY3RlZCB0byBhbGwgdXNlciBwb3J0cyBvZg0KLQkgKiB0aGUgc3dpdGNoDQor CSAqIHRoZSBzd2l0Y2guDQogCSAqLw0KIAltdDc1MzBfd3JpdGUocHJpdiwgTVQ3NTMwX1BDUl9Q KHBvcnQpLA0KIAkJICAgICBQQ1JfTUFUUklYKGRzYV91c2VyX3BvcnRzKHByaXYtPmRzKSkpOw0K QEAgLTExMzIsMjcgKzE0NTYsNDIgQEAgbXQ3NTMwX3BvcnRfdmxhbl9kZWwoc3RydWN0IGRzYV9z d2l0Y2ggKmRzLCBpbnQgcG9ydCwNCiAJcmV0dXJuIDA7DQogfQ0KIA0KLXN0YXRpYyBpbnQgbXQ3 NTMwX3BvcnRfbWlycm9yX2FkZChzdHJ1Y3QgZHNhX3N3aXRjaCAqZHMsIGludCBwb3J0LA0KK3N0 YXRpYyBpbnQgbXQ3NTN4X21pcnJvcl9wb3J0X2dldCh1bnNpZ25lZCBpbnQgaWQsIHUzMiB2YWwp DQorew0KKwlyZXR1cm4gKGlkID09IElEX01UNzUzMSkgPyBNVDc1MzFfTUlSUk9SX1BPUlRfR0VU KHZhbCkgOg0KKwkJCQkgICBNSVJST1JfUE9SVCh2YWwpOw0KK30NCisNCitzdGF0aWMgaW50IG10 NzUzeF9taXJyb3JfcG9ydF9zZXQodW5zaWduZWQgaW50IGlkLCB1MzIgdmFsKQ0KK3sNCisJcmV0 dXJuIChpZCA9PSBJRF9NVDc1MzEpID8gTVQ3NTMxX01JUlJPUl9QT1JUX1NFVCh2YWwpIDoNCisJ CQkJICAgTUlSUk9SX1BPUlQodmFsKTsNCit9DQorDQorc3RhdGljIGludCBtdDc1M3hfcG9ydF9t aXJyb3JfYWRkKHN0cnVjdCBkc2Ffc3dpdGNoICpkcywgaW50IHBvcnQsDQogCQkJCSAgc3RydWN0 IGRzYV9tYWxsX21pcnJvcl90Y19lbnRyeSAqbWlycm9yLA0KIAkJCQkgIGJvb2wgaW5ncmVzcykN CiB7DQogCXN0cnVjdCBtdDc1MzBfcHJpdiAqcHJpdiA9IGRzLT5wcml2Ow0KKwlpbnQgbW9uaXRv cl9wb3J0Ow0KIAl1MzIgdmFsOw0KIA0KIAkvKiBDaGVjayBmb3IgZXhpc3RlbnQgZW50cnkgKi8N CiAJaWYgKChpbmdyZXNzID8gcHJpdi0+bWlycm9yX3J4IDogcHJpdi0+bWlycm9yX3R4KSAmIEJJ VChwb3J0KSkNCiAJCXJldHVybiAtRUVYSVNUOw0KIA0KLQl2YWwgPSBtdDc1MzBfcmVhZChwcml2 LCBNVDc1MzBfTUZDKTsNCisJdmFsID0gbXQ3NTMwX3JlYWQocHJpdiwgTVQ3NTNYX01JUlJPUl9S RUcocHJpdi0+aWQpKTsNCiANCiAJLyogTVQ3NTMwIG9ubHkgc3VwcG9ydHMgb25lIG1vbml0b3Ig cG9ydCAqLw0KLQlpZiAodmFsICYgTUlSUk9SX0VOICYmIE1JUlJPUl9QT1JUKHZhbCkgIT0gbWly cm9yLT50b19sb2NhbF9wb3J0KQ0KKwltb25pdG9yX3BvcnQgPSBtdDc1M3hfbWlycm9yX3BvcnRf Z2V0KHByaXYtPmlkLCB2YWwpOw0KKwlpZiAodmFsICYgTVQ3NTNYX01JUlJPUl9FTihwcml2LT5p ZCkgJiYNCisJICAgIG1vbml0b3JfcG9ydCAhPSBtaXJyb3ItPnRvX2xvY2FsX3BvcnQpDQogCQly ZXR1cm4gLUVFWElTVDsNCiANCi0JdmFsIHw9IE1JUlJPUl9FTjsNCi0JdmFsICY9IH5NSVJST1Jf TUFTSzsNCi0JdmFsIHw9IG1pcnJvci0+dG9fbG9jYWxfcG9ydDsNCi0JbXQ3NTMwX3dyaXRlKHBy aXYsIE1UNzUzMF9NRkMsIHZhbCk7DQorCXZhbCB8PSBNVDc1M1hfTUlSUk9SX0VOKHByaXYtPmlk KTsNCisJdmFsICY9IH5NVDc1M1hfTUlSUk9SX01BU0socHJpdi0+aWQpOw0KKwl2YWwgfD0gbXQ3 NTN4X21pcnJvcl9wb3J0X3NldChwcml2LT5pZCwgbWlycm9yLT50b19sb2NhbF9wb3J0KTsNCisJ bXQ3NTMwX3dyaXRlKHByaXYsIE1UNzUzWF9NSVJST1JfUkVHKHByaXYtPmlkKSwgdmFsKTsNCiAN CiAJdmFsID0gbXQ3NTMwX3JlYWQocHJpdiwgTVQ3NTMwX1BDUl9QKHBvcnQpKTsNCiAJaWYgKGlu Z3Jlc3MpIHsNCkBAIC0xMTY3LDcgKzE1MDYsNyBAQCBzdGF0aWMgaW50IG10NzUzMF9wb3J0X21p cnJvcl9hZGQoc3RydWN0IGRzYV9zd2l0Y2ggKmRzLCBpbnQgcG9ydCwNCiAJcmV0dXJuIDA7DQog fQ0KIA0KLXN0YXRpYyB2b2lkIG10NzUzMF9wb3J0X21pcnJvcl9kZWwoc3RydWN0IGRzYV9zd2l0 Y2ggKmRzLCBpbnQgcG9ydCwNCitzdGF0aWMgdm9pZCBtdDc1M3hfcG9ydF9taXJyb3JfZGVsKHN0 cnVjdCBkc2Ffc3dpdGNoICpkcywgaW50IHBvcnQsDQogCQkJCSAgIHN0cnVjdCBkc2FfbWFsbF9t aXJyb3JfdGNfZW50cnkgKm1pcnJvcikNCiB7DQogCXN0cnVjdCBtdDc1MzBfcHJpdiAqcHJpdiA9 IGRzLT5wcml2Ow0KQEAgLTExODQsOSArMTUyMyw5IEBAIHN0YXRpYyB2b2lkIG10NzUzMF9wb3J0 X21pcnJvcl9kZWwoc3RydWN0IGRzYV9zd2l0Y2ggKmRzLCBpbnQgcG9ydCwNCiAJbXQ3NTMwX3dy aXRlKHByaXYsIE1UNzUzMF9QQ1JfUChwb3J0KSwgdmFsKTsNCiANCiAJaWYgKCFwcml2LT5taXJy b3JfcnggJiYgIXByaXYtPm1pcnJvcl90eCkgew0KLQkJdmFsID0gbXQ3NTMwX3JlYWQocHJpdiwg TVQ3NTMwX01GQyk7DQotCQl2YWwgJj0gfk1JUlJPUl9FTjsNCi0JCW10NzUzMF93cml0ZShwcml2 LCBNVDc1MzBfTUZDLCB2YWwpOw0KKwkJdmFsID0gbXQ3NTMwX3JlYWQocHJpdiwgTVQ3NTNYX01J UlJPUl9SRUcocHJpdi0+aWQpKTsNCisJCXZhbCAmPSB+TVQ3NTNYX01JUlJPUl9FTihwcml2LT5p ZCk7DQorCQltdDc1MzBfd3JpdGUocHJpdiwgTVQ3NTNYX01JUlJPUl9SRUcocHJpdi0+aWQpLCB2 YWwpOw0KIAl9DQogfQ0KIA0KQEAgLTEyOTMsNyArMTYzMiw3IEBAIG10NzUzMF9zZXR1cChzdHJ1 Y3QgZHNhX3N3aXRjaCAqZHMpDQogCQkJICAgUENSX01BVFJJWF9DTFIpOw0KIA0KIAkJaWYgKGRz YV9pc19jcHVfcG9ydChkcywgaSkpDQotCQkJbXQ3NTMwX2NwdV9wb3J0X2VuYWJsZShwcml2LCBp KTsNCisJCQltdDc1M3hfY3B1X3BvcnRfZW5hYmxlKGRzLCBpKTsNCiAJCWVsc2UNCiAJCQltdDc1 MzBfcG9ydF9kaXNhYmxlKGRzLCBpKTsNCiANCkBAIC0xMzUxLDYgKzE2OTAsMTE4IEBAIG10NzUz MF9zZXR1cChzdHJ1Y3QgZHNhX3N3aXRjaCAqZHMpDQogCXJldHVybiAwOw0KIH0NCiANCitzdGF0 aWMgaW50DQorbXQ3NTMxX3NldHVwKHN0cnVjdCBkc2Ffc3dpdGNoICpkcykNCit7DQorCXN0cnVj dCBtdDc1MzBfcHJpdiAqcHJpdiA9IGRzLT5wcml2Ow0KKwlzdHJ1Y3QgbXQ3NTMwX2R1bW15X3Bv bGwgcDsNCisJdTMyIHZhbCwgaWQ7DQorCWludCByZXQsIGk7DQorDQorCS8qIFJlc2V0IHdob2xl IGNoaXAgdGhyb3VnaCBncGlvIHBpbiBvciBtZW1vcnktbWFwcGVkIHJlZ2lzdGVycyBmb3INCisJ ICogZGlmZmVyZW50IHR5cGUgb2YgaGFyZHdhcmUNCisJICovDQorCWlmIChwcml2LT5tY20pIHsN CisJCXJlc2V0X2NvbnRyb2xfYXNzZXJ0KHByaXYtPnJzdGMpOw0KKwkJdXNsZWVwX3JhbmdlKDEw MDAsIDExMDApOw0KKwkJcmVzZXRfY29udHJvbF9kZWFzc2VydChwcml2LT5yc3RjKTsNCisJfSBl bHNlIHsNCisJCWdwaW9kX3NldF92YWx1ZV9jYW5zbGVlcChwcml2LT5yZXNldCwgMCk7DQorCQl1 c2xlZXBfcmFuZ2UoMTAwMCwgMTEwMCk7DQorCQlncGlvZF9zZXRfdmFsdWVfY2Fuc2xlZXAocHJp di0+cmVzZXQsIDEpOw0KKwl9DQorDQorCS8qIFdhaXRpbmcgZm9yIE1UNzUzMCBnb3QgdG8gc3Rh YmxlICovDQorCUlOSVRfTVQ3NTMwX0RVTU1ZX1BPTEwoJnAsIHByaXYsIE1UNzUzMF9IV1RSQVAp Ow0KKwlyZXQgPSByZWFkeF9wb2xsX3RpbWVvdXQoX210NzUzMF9yZWFkLCAmcCwgdmFsLCB2YWwg IT0gMCwNCisJCQkJIDIwLCAxMDAwMDAwKTsNCisJaWYgKHJldCA8IDApIHsNCisJCWRldl9lcnIo cHJpdi0+ZGV2LCAicmVzZXQgdGltZW91dFxuIik7DQorCQlyZXR1cm4gcmV0Ow0KKwl9DQorDQor CWlkID0gbXQ3NTMwX3JlYWQocHJpdiwgTVQ3NTMxX0NSRVYpOw0KKwlpZCA+Pj0gQ0hJUF9OQU1F X1NISUZUOw0KKw0KKwlpZiAoaWQgIT0gTVQ3NTMxX0lEKSB7DQorCQlkZXZfZXJyKHByaXYtPmRl diwgImNoaXAgJXggY2FuJ3QgYmUgc3VwcG9ydGVkXG4iLCBpZCk7DQorCQlyZXR1cm4gLUVOT0RF VjsNCisJfQ0KKw0KKwkvKiBSZXNldCB0aGUgc3dpdGNoIHRocm91Z2ggaW50ZXJuYWwgcmVzZXQg Ki8NCisJbXQ3NTMwX3dyaXRlKHByaXYsIE1UNzUzMF9TWVNfQ1RSTCwNCisJCSAgICAgU1lTX0NU UkxfUEhZX1JTVCB8IFNZU19DVFJMX1NXX1JTVCB8DQorCQkgICAgIFNZU19DVFJMX1JFR19SU1Qp Ow0KKw0KKwlpZiAobXQ3NTMxX2R1YWxfc2dtaWlfc3VwcG9ydGVkKHByaXYpKSB7DQorCQlwcml2 LT5wNV9pbnRmX3NlbCA9IFA1X0lOVEZfU0VMX0dNQUM1X1NHTUlJOw0KKw0KKwkJLyogTGV0IGRz LT5zbGF2ZV9taWlfYnVzIGJlIGFibGUgdG8gYWNjZXNzIGV4dGVybmFsIHBoeS4gKi8NCisJCW10 NzUzMF9ybXcocHJpdiwgTVQ3NTMxX0dQSU9fTU9ERTEsIE1UNzUzMV9HUElPMTFfUkdfUlhEMl9N QVNLLA0KKwkJCSAgIE1UNzUzMV9FWFRfUF9NRENfMTEpOw0KKwkJbXQ3NTMwX3Jtdyhwcml2LCBN VDc1MzFfR1BJT19NT0RFMSwgTVQ3NTMxX0dQSU8xMl9SR19SWEQzX01BU0ssDQorCQkJICAgTVQ3 NTMxX0VYVF9QX01ESU9fMTIpOw0KKwl9IGVsc2Ugew0KKwkJcHJpdi0+cDVfaW50Zl9zZWwgPSBQ NV9JTlRGX1NFTF9HTUFDNTsNCisJfQ0KKwlkZXZfZGJnKGRzLT5kZXYsICJQNSBzdXBwb3J0ICVz IGludGVyZmFjZVxuIiwNCisJCXA1X2ludGZfbW9kZXMocHJpdi0+cDVfaW50Zl9zZWwpKTsNCisN CisJbXQ3NTMwX3Jtdyhwcml2LCBNVDc1MzFfR1BJT19NT0RFMCwgTVQ3NTMxX0dQSU8wX01BU0ss DQorCQkgICBNVDc1MzFfR1BJTzBfSU5URVJSVVBUKTsNCisNCisJLyogTGV0IHBoeWxpbmsgZGVj aWRlIHRoZSBpbnRlcmZhY2UgbGF0ZXIuICovDQorCXByaXYtPnA1X2ludGVyZmFjZSA9IFBIWV9J TlRFUkZBQ0VfTU9ERV9OQTsNCisJcHJpdi0+cDZfaW50ZXJmYWNlID0gUEhZX0lOVEVSRkFDRV9N T0RFX05BOw0KKw0KKwkvKiBFbmFibGUgUEhZIGNvcmUgUExMLCBzaW5jZSBwaHlfZGV2aWNlIGhh cyBub3QgeWV0IGJlZW4gY3JlYXRlZA0KKwkgKiBwcm92aWRlZCBmb3IgcGh5X1tyZWFkLHdyaXRl XV9tbWRfaW5kaXJlY3QgaXMgY2FsbGVkLCB3ZSBwcm92aWRlDQorCSAqIG91ciBvd24gbXQ3NTMx X2luZF9tbWRfcGh5X1tyZWFkLHdyaXRlXSB0byBjb21wbGV0ZSB0aGlzDQorCSAqIGZ1bmN0aW9u Lg0KKwkgKi8NCisJdmFsID0gbXQ3NTMxX2luZF9jNDVfcGh5X3JlYWQocHJpdiwgTVQ3NTNYX0NU UkxfUEhZX0FERFIsDQorCQkJCSAgICAgIE1ESU9fTU1EX1ZFTkQyLCBDT1JFX1BMTF9HUk9VUDQp Ow0KKwl2YWwgfD0gTVQ3NTMxX1BIWV9QTExfQllQQVNTX01PREU7DQorCXZhbCAmPSB+TVQ3NTMx X1BIWV9QTExfT0ZGOw0KKwltdDc1MzFfaW5kX2M0NV9waHlfd3JpdGUocHJpdiwgTVQ3NTNYX0NU UkxfUEhZX0FERFIsIE1ESU9fTU1EX1ZFTkQyLA0KKwkJCQkgQ09SRV9QTExfR1JPVVA0LCB2YWwp Ow0KKw0KKwkvKiBCUERVIHRvIENQVSBwb3J0ICovDQorCW10NzUzMF9ybXcocHJpdiwgTVQ3NTMx X0NGQywgTVQ3NTMxX0NQVV9QTUFQX01BU0ssDQorCQkgICBCSVQoTVQ3NTMwX0NQVV9QT1JUKSk7 DQorCW10NzUzMF9ybXcocHJpdiwgTVQ3NTNYX0JQQywgTVQ3NTNYX0JQRFVfUE9SVF9GV19NQVNL LA0KKwkJICAgTVQ3NTNYX0JQRFVfQ1BVX09OTFkpOw0KKw0KKwkvKiBFbmFibGUgYW5kIHJlc2V0 IE1JQiBjb3VudGVycyAqLw0KKwltdDc1MzBfbWliX3Jlc2V0KGRzKTsNCisNCisJZm9yIChpID0g MDsgaSA8IE1UNzUzMF9OVU1fUE9SVFM7IGkrKykgew0KKwkJLyogRGlzYWJsZSBmb3J3YXJkaW5n IGJ5IGRlZmF1bHQgb24gYWxsIHBvcnRzICovDQorCQltdDc1MzBfcm13KHByaXYsIE1UNzUzMF9Q Q1JfUChpKSwgUENSX01BVFJJWF9NQVNLLA0KKwkJCSAgIFBDUl9NQVRSSVhfQ0xSKTsNCisNCisJ CW10NzUzMF9zZXQocHJpdiwgTVQ3NTMxX0RCR19DTlQoaSksIE1UNzUzMV9ESVNfQ0xSKTsNCisN CisJCWlmIChkc2FfaXNfY3B1X3BvcnQoZHMsIGkpKQ0KKwkJCW10NzUzeF9jcHVfcG9ydF9lbmFi bGUoZHMsIGkpOw0KKwkJZWxzZQ0KKwkJCW10NzUzMF9wb3J0X2Rpc2FibGUoZHMsIGkpOw0KKw0K KwkJLyogRW5hYmxlIGNvbnNpc3RlbnQgZWdyZXNzIHRhZyAqLw0KKwkJbXQ3NTMwX3Jtdyhwcml2 LCBNVDc1MzBfUFZDX1AoaSksIFBWQ19FR19UQUdfTUFTSywNCisJCQkgICBQVkNfRUdfVEFHKE1U NzUzMF9WTEFOX0VHX0NPTlNJU1RFTlQpKTsNCisJfQ0KKw0KKwlkcy0+Y29uZmlndXJlX3ZsYW5f d2hpbGVfbm90X2ZpbHRlcmluZyA9IHRydWU7DQorDQorCS8qIEZsdXNoIHRoZSBGREIgdGFibGUg Ki8NCisJcmV0ID0gbXQ3NTMwX2ZkYl9jbWQocHJpdiwgTVQ3NTMwX0ZEQl9GTFVTSCwgTlVMTCk7 DQorCWlmIChyZXQgPCAwKQ0KKwkJcmV0dXJuIHJldDsNCisNCisJcmV0dXJuIDA7DQorfQ0KKw0K IHN0YXRpYyBib29sDQogbXQ3NTMwX3BoeV9tb2RlX3N1cHBvcnRlZChzdHJ1Y3QgZHNhX3N3aXRj aCAqZHMsIGludCBwb3J0LA0KIAkJCSAgY29uc3Qgc3RydWN0IHBoeWxpbmtfbGlua19zdGF0ZSAq c3RhdGUpDQpAQCAtMTM4OSw2ICsxODQwLDQ3IEBAIG10NzUzMF9waHlfbW9kZV9zdXBwb3J0ZWQo c3RydWN0IGRzYV9zd2l0Y2ggKmRzLCBpbnQgcG9ydCwNCiAJcmV0dXJuIGZhbHNlOw0KIH0NCiAN CitzdGF0aWMgYm9vbCBtdDc1MzFfaXNfcmdtaWlfcG9ydChzdHJ1Y3QgbXQ3NTMwX3ByaXYgKnBy aXYsIHUzMiBwb3J0KQ0KK3sNCisJcmV0dXJuIChwb3J0ID09IDUpICYmIChwcml2LT5wNV9pbnRm X3NlbCAhPSBQNV9JTlRGX1NFTF9HTUFDNV9TR01JSSk7DQorfQ0KKw0KK3N0YXRpYyBib29sDQor bXQ3NTMxX3BoeV9zdXBwb3J0ZWQoc3RydWN0IGRzYV9zd2l0Y2ggKmRzLCBpbnQgcG9ydCwNCisJ CSAgICAgY29uc3Qgc3RydWN0IHBoeWxpbmtfbGlua19zdGF0ZSAqc3RhdGUpDQorew0KKwlzdHJ1 Y3QgbXQ3NTMwX3ByaXYgKnByaXYgPSBkcy0+cHJpdjsNCisNCisJc3dpdGNoIChwb3J0KSB7DQor CWNhc2UgMDogLyogSW50ZXJuYWwgcGh5ICovDQorCWNhc2UgMToNCisJY2FzZSAyOg0KKwljYXNl IDM6DQorCWNhc2UgNDoNCisJCWlmIChzdGF0ZS0+aW50ZXJmYWNlICE9IFBIWV9JTlRFUkZBQ0Vf TU9ERV9HTUlJKQ0KKwkJCWdvdG8gdW5zdXBwb3J0ZWQ7DQorCQlicmVhazsNCisJY2FzZSA1OiAv KiAybmQgY3B1IHBvcnQgc3VwcG9ydHMgZWl0aGVyIHJnbWlpIG9yIHNnbWlpLzgwMjN6ICovDQor CQlpZiAobXQ3NTMxX2lzX3JnbWlpX3BvcnQocHJpdiwgcG9ydCkpDQorCQkJcmV0dXJuIHBoeV9p bnRlcmZhY2VfbW9kZV9pc19yZ21paShzdGF0ZS0+aW50ZXJmYWNlKTsNCisJCWZhbGx0aHJvdWdo Ow0KKwljYXNlIDY6IC8qIDFzdCBjcHUgcG9ydCBzdXBwb3J0cyBzZ21paS84MDIzeiBvbmx5ICov DQorCQlpZiAoc3RhdGUtPmludGVyZmFjZSAhPSBQSFlfSU5URVJGQUNFX01PREVfU0dNSUkgJiYN CisJCSAgICAhcGh5X2ludGVyZmFjZV9tb2RlX2lzXzgwMjN6KHN0YXRlLT5pbnRlcmZhY2UpKQ0K KwkJCWdvdG8gdW5zdXBwb3J0ZWQ7DQorCQlicmVhazsNCisJZGVmYXVsdDoNCisJCWRldl9lcnIo cHJpdi0+ZGV2LCAiJXM6IHVuc3VwcG9ydGVkIHBvcnQ6ICVpXG4iLCBfX2Z1bmNfXywNCisJCQlw b3J0KTsNCisJCWdvdG8gdW5zdXBwb3J0ZWQ7DQorCX0NCisNCisJcmV0dXJuIHRydWU7DQorDQor dW5zdXBwb3J0ZWQ6DQorCXJldHVybiBmYWxzZTsNCit9DQorDQogc3RhdGljIGJvb2wNCiBtdDc1 M3hfcGh5X21vZGVfc3VwcG9ydGVkKHN0cnVjdCBkc2Ffc3dpdGNoICpkcywgaW50IHBvcnQsDQog CQkJICBjb25zdCBzdHJ1Y3QgcGh5bGlua19saW5rX3N0YXRlICpzdGF0ZSkNCkBAIC0xNDIxLDYg KzE5MTMsMjE3IEBAIG10NzUzMF9tYWNfY29uZmlnKHN0cnVjdCBkc2Ffc3dpdGNoICpkcywgaW50 IHBvcnQsIHVuc2lnbmVkIGludCBtb2RlLA0KIAlyZXR1cm4gMDsNCiB9DQogDQorc3RhdGljIGlu dCBtdDc1MzFfcmdtaWlfc2V0dXAoc3RydWN0IG10NzUzMF9wcml2ICpwcml2LCB1MzIgcG9ydCwN CisJCQkgICAgICBwaHlfaW50ZXJmYWNlX3QgaW50ZXJmYWNlKQ0KK3sNCisJdTMyIHZhbDsNCisN CisJaWYgKCFtdDc1MzFfaXNfcmdtaWlfcG9ydChwcml2LCBwb3J0KSkgew0KKwkJZGV2X2Vycihw cml2LT5kZXYsICJSR01JSSBtb2RlIGlzIG5vdCBhdmFpbGFibGUgZm9yIHBvcnQgJWRcbiIsDQor CQkJcG9ydCk7DQorCQlyZXR1cm4gLUVJTlZBTDsNCisJfQ0KKw0KKwl2YWwgPSBtdDc1MzBfcmVh ZChwcml2LCBNVDc1MzFfQ0xLR0VOX0NUUkwpOw0KKwl2YWwgfD0gR1BfQ0xLX0VOOw0KKwl2YWwg Jj0gfkdQX01PREVfTUFTSzsNCisJdmFsIHw9IEdQX01PREUoTVQ3NTMxX0dQX01PREVfUkdNSUkp Ow0KKwl2YWwgJj0gfihUWENMS19OT19SRVZFUlNFIHwgUlhDTEtfTk9fREVMQVkpOw0KKwlzd2l0 Y2ggKGludGVyZmFjZSkgew0KKwljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9SR01JSToNCisJCXZh bCB8PSBUWENMS19OT19SRVZFUlNFOw0KKwkJdmFsIHw9IFJYQ0xLX05PX0RFTEFZOw0KKwkJYnJl YWs7DQorCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX1JHTUlJX1JYSUQ6DQorCQl2YWwgfD0gVFhD TEtfTk9fUkVWRVJTRTsNCisJCWJyZWFrOw0KKwljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9SR01J SV9UWElEOg0KKwkJdmFsIHw9IFJYQ0xLX05PX0RFTEFZOw0KKwkJYnJlYWs7DQorCWNhc2UgUEhZ X0lOVEVSRkFDRV9NT0RFX1JHTUlJX0lEOg0KKwkJYnJlYWs7DQorCWRlZmF1bHQ6DQorCQlyZXR1 cm4gLUVJTlZBTDsNCisJfQ0KKwl2YWwgJj0gfkNMS19TS0VXX0lOX01BU0s7DQorCXZhbCB8PSBD TEtfU0tFV19JTihNVDc1MzFfQ0xLX1NLRVdfTk9fQ0hHKTsNCisJdmFsICY9IH5DTEtfU0tFV19P VVRfTUFTSzsNCisJdmFsIHw9IENMS19TS0VXX09VVChNVDc1MzFfQ0xLX1NLRVdfTk9fQ0hHKTsN CisJbXQ3NTMwX3dyaXRlKHByaXYsIE1UNzUzMV9DTEtHRU5fQ1RSTCwgdmFsKTsNCisNCisJcmV0 dXJuIDA7DQorfQ0KKw0KK3N0YXRpYyB2b2lkIG10NzUzMV9zZ21paV92YWxpZGF0ZShzdHJ1Y3Qg bXQ3NTMwX3ByaXYgKnByaXYsIGludCBwb3J0LA0KKwkJCQkgIHVuc2lnbmVkIGxvbmcgKnN1cHBv cnRlZCkNCit7DQorCS8qIFBvcnQ1IHN1cHBvcnRzIGV0aGllciBSR01JSSBvciBTR01JSS4NCisJ ICogUG9ydDYgc3VwcG9ydHMgU0dNSUkgb25seS4NCisJICovDQorCXN3aXRjaCAocG9ydCkgew0K KwljYXNlIDU6DQorCQlpZiAobXQ3NTMxX2lzX3JnbWlpX3BvcnQocHJpdiwgcG9ydCkpDQorCQkJ YnJlYWs7DQorCQlmYWxsdGhyb3VnaDsNCisJY2FzZSA2Og0KKwkJcGh5bGlua19zZXQoc3VwcG9y dGVkLCAxMDAwYmFzZVhfRnVsbCk7DQorCQlwaHlsaW5rX3NldChzdXBwb3J0ZWQsIDI1MDBiYXNl WF9GdWxsKTsNCisJCXBoeWxpbmtfc2V0KHN1cHBvcnRlZCwgMjUwMGJhc2VUX0Z1bGwpOw0KKwl9 DQorfQ0KKw0KK3ZvaWQNCittdDc1MzFfc2dtaWlfbGlua191cF9mb3JjZShzdHJ1Y3QgZHNhX3N3 aXRjaCAqZHMsIGludCBwb3J0LA0KKwkJCSAgIHVuc2lnbmVkIGludCBtb2RlLCBwaHlfaW50ZXJm YWNlX3QgaW50ZXJmYWNlLA0KKwkJCSAgIGludCBzcGVlZCwgaW50IGR1cGxleCkNCit7DQorCXN0 cnVjdCBtdDc1MzBfcHJpdiAqcHJpdiA9IGRzLT5wcml2Ow0KKwl1bnNpZ25lZCBpbnQgdmFsOw0K Kw0KKwkvKiBGb3IgYWRqdXN0aW5nIHNwZWVkIGFuZCBkdXBsZXggb2YgU0dNSUkgZm9yY2UgbW9k ZS4gKi8NCisJaWYgKGludGVyZmFjZSAhPSBQSFlfSU5URVJGQUNFX01PREVfU0dNSUkgfHwNCisJ ICAgIHBoeWxpbmtfYXV0b25lZ19pbmJhbmQobW9kZSkpDQorCQlyZXR1cm47DQorDQorCS8qIFNH TUlJIGZvcmNlIG1vZGUgc2V0dGluZyAqLw0KKwl2YWwgPSBtdDc1MzBfcmVhZChwcml2LCBNVDc1 MzFfU0dNSUlfTU9ERShwb3J0KSk7DQorCXZhbCAmPSB+TVQ3NTMxX1NHTUlJX0lGX01PREVfTUFT SzsNCisNCisJc3dpdGNoIChzcGVlZCkgew0KKwljYXNlIFNQRUVEXzEwOg0KKwkJdmFsIHw9IE1U NzUzMV9TR01JSV9GT1JDRV9TUEVFRF8xMDsNCisJCWJyZWFrOw0KKwljYXNlIFNQRUVEXzEwMDoN CisJCXZhbCB8PSBNVDc1MzFfU0dNSUlfRk9SQ0VfU1BFRURfMTAwOw0KKwkJYnJlYWs7DQorCWNh c2UgU1BFRURfMTAwMDoNCisJCXZhbCB8PSBNVDc1MzFfU0dNSUlfRk9SQ0VfU1BFRURfMTAwMDsN CisJCWJyZWFrOw0KKwl9DQorDQorCS8qIE1UNzUzMSBTR01JSSAxRyBmb3JjZSBtb2RlIGNhbiBv bmx5IHdvcmsgaW4gZnVsbCBkdXBsZXggbW9kZSwNCisJICogbm8gbWF0dGVyIE1UNzUzMV9TR01J SV9GT1JDRV9IQUxGX0RVUExFWCBpcyBzZXQgb3Igbm90Lg0KKwkgKi8NCisJaWYgKChzcGVlZCA9 PSBTUEVFRF8xMCB8fCBzcGVlZCA9PSBTUEVFRF8xMDApICYmDQorCSAgICBkdXBsZXggIT0gRFVQ TEVYX0ZVTEwpDQorCQl2YWwgfD0gTVQ3NTMxX1NHTUlJX0ZPUkNFX0hBTEZfRFVQTEVYOw0KKw0K KwltdDc1MzBfd3JpdGUocHJpdiwgTVQ3NTMxX1NHTUlJX01PREUocG9ydCksIHZhbCk7DQorfQ0K Kw0KK3N0YXRpYyBib29sIG10NzUzeF9pc19tYWNfcG9ydCh1MzIgcG9ydCkNCit7DQorCXJldHVy biAocG9ydCA9PSA1IHx8IHBvcnQgPT0gNik7DQorfQ0KKw0KK3N0YXRpYyBpbnQgbXQ3NTMxX3Nn bWlpX3NldHVwX21vZGVfZm9yY2Uoc3RydWN0IG10NzUzMF9wcml2ICpwcml2LCB1MzIgcG9ydCwN CisJCQkJCSBwaHlfaW50ZXJmYWNlX3QgaW50ZXJmYWNlKQ0KK3sNCisJdTMyIHZhbDsNCisNCisJ aWYgKCFtdDc1M3hfaXNfbWFjX3BvcnQocG9ydCkpDQorCQlyZXR1cm4gLUVJTlZBTDsNCisNCisJ bXQ3NTMwX3NldChwcml2LCBNVDc1MzFfUVBIWV9QV1JfU1RBVEVfQ1RSTChwb3J0KSwNCisJCSAg IE1UNzUzMV9TR01JSV9QSFlBX1BXRCk7DQorDQorCXZhbCA9IG10NzUzMF9yZWFkKHByaXYsIE1U NzUzMV9QSFlBX0NUUkxfU0lHTkFMMyhwb3J0KSk7DQorCXZhbCAmPSB+TVQ3NTMxX1JHX1RQSFlf U1BFRURfTUFTSzsNCisJLyogU2V0dXAgMi41IHRpbWVzIGZhc3RlciBjbG9jayBmb3IgMi41R2Jw cyBkYXRhIHNwZWVkcyB3aXRoIDEwQi84Qg0KKwkgKiBlbmNvZGluZy4NCisJICovDQorCXZhbCB8 PSAoaW50ZXJmYWNlID09IFBIWV9JTlRFUkZBQ0VfTU9ERV8yNTAwQkFTRVgpID8NCisJCU1UNzUz MV9SR19UUEhZX1NQRUVEXzNfMTI1RyA6IE1UNzUzMV9SR19UUEhZX1NQRUVEXzFfMjVHOw0KKwlt dDc1MzBfd3JpdGUocHJpdiwgTVQ3NTMxX1BIWUFfQ1RSTF9TSUdOQUwzKHBvcnQpLCB2YWwpOw0K Kw0KKwltdDc1MzBfY2xlYXIocHJpdiwgTVQ3NTMxX1BDU19DT05UUk9MXzEocG9ydCksIE1UNzUz MV9TR01JSV9BTl9FTkFCTEUpOw0KKw0KKwkvKiBNVDc1MzEgU0dNSUkgMUcgYW5kIDIuNUcgZm9y Y2UgbW9kZSBjYW4gb25seSB3b3JrIGluIGZ1bGwgZHVwbGV4DQorCSAqIG1vZGUsIG5vIG1hdHRl ciBNVDc1MzFfU0dNSUlfRk9SQ0VfSEFMRl9EVVBMRVggaXMgc2V0IG9yIG5vdC4NCisJICovDQor CW10NzUzMF9ybXcocHJpdiwgTVQ3NTMxX1NHTUlJX01PREUocG9ydCksDQorCQkgICBNVDc1MzFf U0dNSUlfSUZfTU9ERV9NQVNLIHwgTVQ3NTMxX1NHTUlJX1JFTU9URV9GQVVMVF9ESVMsDQorCQkg ICBNVDc1MzFfU0dNSUlfRk9SQ0VfU1BFRURfMTAwMCk7DQorDQorCW10NzUzMF93cml0ZShwcml2 LCBNVDc1MzFfUVBIWV9QV1JfU1RBVEVfQ1RSTChwb3J0KSwgMCk7DQorDQorCXJldHVybiAwOw0K K30NCisNCitzdGF0aWMgaW50IG10NzUzMV9zZ21paV9zZXR1cF9tb2RlX2FuKHN0cnVjdCBtdDc1 MzBfcHJpdiAqcHJpdiwgaW50IHBvcnQsDQorCQkJCSAgICAgIHBoeV9pbnRlcmZhY2VfdCBpbnRl cmZhY2UpDQorew0KKwlpZiAoIW10NzUzeF9pc19tYWNfcG9ydChwb3J0KSkNCisJCXJldHVybiAt RUlOVkFMOw0KKw0KKwltdDc1MzBfc2V0KHByaXYsIE1UNzUzMV9RUEhZX1BXUl9TVEFURV9DVFJM KHBvcnQpLA0KKwkJICAgTVQ3NTMxX1NHTUlJX1BIWUFfUFdEKTsNCisNCisJbXQ3NTMwX3Jtdyhw cml2LCBNVDc1MzFfUEhZQV9DVFJMX1NJR05BTDMocG9ydCksDQorCQkgICBNVDc1MzFfUkdfVFBI WV9TUEVFRF9NQVNLLCBNVDc1MzFfUkdfVFBIWV9TUEVFRF8xXzI1Ryk7DQorDQorCW10NzUzMF9z ZXQocHJpdiwgTVQ3NTMxX1NHTUlJX01PREUocG9ydCksDQorCQkgICBNVDc1MzFfU0dNSUlfUkVN T1RFX0ZBVUxUX0RJUyB8DQorCQkgICBNVDc1MzFfU0dNSUlfU1BFRURfRFVQTEVYX0FOKTsNCisN CisJbXQ3NTMwX3Jtdyhwcml2LCBNVDc1MzFfUENTX1NQRUVEX0FCSUxJVFkocG9ydCksDQorCQkg ICBNVDc1MzFfU0dNSUlfVFhfQ09ORklHX01BU0ssIDEpOw0KKw0KKwltdDc1MzBfc2V0KHByaXYs IE1UNzUzMV9QQ1NfQ09OVFJPTF8xKHBvcnQpLCBNVDc1MzFfU0dNSUlfQU5fRU5BQkxFKTsNCisN CisJbXQ3NTMwX3NldChwcml2LCBNVDc1MzFfUENTX0NPTlRST0xfMShwb3J0KSwgTVQ3NTMxX1NH TUlJX0FOX1JFU1RBUlQpOw0KKw0KKwltdDc1MzBfd3JpdGUocHJpdiwgTVQ3NTMxX1FQSFlfUFdS X1NUQVRFX0NUUkwocG9ydCksIDApOw0KKw0KKwlyZXR1cm4gMDsNCit9DQorDQordm9pZCBtdDc1 MzFfc2dtaWlfcmVzdGFydF9hbihzdHJ1Y3QgZHNhX3N3aXRjaCAqZHMsIGludCBwb3J0KQ0KK3sN CisJc3RydWN0IG10NzUzMF9wcml2ICpwcml2ID0gZHMtPnByaXY7DQorCXUzMiB2YWw7DQorDQor CS8qIE9ubHkgcmVzdGFydCBBTiB3aGVuIEFOIGlzIGVuYWJsZWQgKi8NCisJdmFsID0gbXQ3NTMw X3JlYWQocHJpdiwgTVQ3NTMxX1BDU19DT05UUk9MXzEocG9ydCkpOw0KKwlpZiAodmFsICYgTVQ3 NTMxX1NHTUlJX0FOX0VOQUJMRSkgew0KKwkJdmFsIHw9IE1UNzUzMV9TR01JSV9BTl9SRVNUQVJU Ow0KKwkJbXQ3NTMwX3dyaXRlKHByaXYsIE1UNzUzMV9QQ1NfQ09OVFJPTF8xKHBvcnQpLCB2YWwp Ow0KKwl9DQorfQ0KKw0KK3N0YXRpYyBpbnQNCittdDc1MzFfbWFjX2NvbmZpZyhzdHJ1Y3QgZHNh X3N3aXRjaCAqZHMsIGludCBwb3J0LCB1bnNpZ25lZCBpbnQgbW9kZSwNCisJCSAgcGh5X2ludGVy ZmFjZV90IGludGVyZmFjZSkNCit7DQorCXN0cnVjdCBtdDc1MzBfcHJpdiAqcHJpdiA9IGRzLT5w cml2Ow0KKw0KKwlpZiAoIW10NzUzeF9pc19tYWNfcG9ydChwb3J0KSkgew0KKwkJZGV2X2Vycihw cml2LT5kZXYsICJwb3J0ICVkIGlzIG5vdCBhIE1BQyBwb3J0XG4iLCBwb3J0KTsNCisJCXJldHVy biAtRUlOVkFMOw0KKwl9DQorDQorCXN3aXRjaCAoaW50ZXJmYWNlKSB7DQorCWNhc2UgUEhZX0lO VEVSRkFDRV9NT0RFX1JHTUlJOg0KKwljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9SR01JSV9JRDoN CisJY2FzZSBQSFlfSU5URVJGQUNFX01PREVfUkdNSUlfUlhJRDoNCisJY2FzZSBQSFlfSU5URVJG QUNFX01PREVfUkdNSUlfVFhJRDoNCisJCXJldHVybiBtdDc1MzFfcmdtaWlfc2V0dXAocHJpdiwg cG9ydCwgaW50ZXJmYWNlKTsNCisJY2FzZSBQSFlfSU5URVJGQUNFX01PREVfU0dNSUk6DQorCQly ZXR1cm4gbXQ3NTMxX3NnbWlpX3NldHVwX21vZGVfYW4ocHJpdiwgcG9ydCwgaW50ZXJmYWNlKTsN CisJY2FzZSBQSFlfSU5URVJGQUNFX01PREVfTkE6DQorCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RF XzEwMDBCQVNFWDoNCisJY2FzZSBQSFlfSU5URVJGQUNFX01PREVfMjUwMEJBU0VYOg0KKwkJaWYg KHBoeWxpbmtfYXV0b25lZ19pbmJhbmQobW9kZSkpDQorCQkJcmV0dXJuIC1FSU5WQUw7DQorDQor CQlyZXR1cm4gbXQ3NTMxX3NnbWlpX3NldHVwX21vZGVfZm9yY2UocHJpdiwgcG9ydCwgaW50ZXJm YWNlKTsNCisJZGVmYXVsdDoNCisJCXJldHVybiAtRUlOVkFMOw0KKwl9DQorDQorCXJldHVybiAt RUlOVkFMOw0KK30NCisNCiBzdGF0aWMgaW50DQogbXQ3NTN4X21hY19jb25maWcoc3RydWN0IGRz YV9zd2l0Y2ggKmRzLCBpbnQgcG9ydCwgdW5zaWduZWQgaW50IG1vZGUsDQogCQkgIGNvbnN0IHN0 cnVjdCBwaHlsaW5rX2xpbmtfc3RhdGUgKnN0YXRlKQ0KQEAgLTE0NTYsNiArMjE1OSw4IEBAIG10 NzUzeF9waHlsaW5rX21hY19jb25maWcoc3RydWN0IGRzYV9zd2l0Y2ggKmRzLCBpbnQgcG9ydCwg dW5zaWduZWQgaW50IG1vZGUsDQogCQlpZiAobXQ3NTN4X21hY19jb25maWcoZHMsIHBvcnQsIG1v ZGUsIHN0YXRlKSA8IDApDQogCQkJZ290byB1bnN1cHBvcnRlZDsNCiANCisJCWlmIChwcml2LT5w NV9pbnRmX3NlbCAhPSBQNV9ESVNBQkxFRCkNCisJCQlwcml2LT5wNV9pbnRlcmZhY2UgPSBzdGF0 ZS0+aW50ZXJmYWNlOw0KIAkJYnJlYWs7DQogCWNhc2UgNjogLyogMXN0IGNwdSBwb3J0ICovDQog CQlpZiAocHJpdi0+cDZfaW50ZXJmYWNlID09IHN0YXRlLT5pbnRlcmZhY2UpDQpAQCAtMTQ3NSw3 ICsyMTgwLDggQEAgbXQ3NTN4X3BoeWxpbmtfbWFjX2NvbmZpZyhzdHJ1Y3QgZHNhX3N3aXRjaCAq ZHMsIGludCBwb3J0LCB1bnNpZ25lZCBpbnQgbW9kZSwNCiAJCXJldHVybjsNCiAJfQ0KIA0KLQlp ZiAocGh5bGlua19hdXRvbmVnX2luYmFuZChtb2RlKSkgew0KKwlpZiAocGh5bGlua19hdXRvbmVn X2luYmFuZChtb2RlKSAmJg0KKwkgICAgc3RhdGUtPmludGVyZmFjZSAhPSBQSFlfSU5URVJGQUNF X01PREVfU0dNSUkpIHsNCiAJCWRldl9lcnIoZHMtPmRldiwgIiVzOiBpbi1iYW5kIG5lZ290aWF0 aW9uIHVuc3VwcG9ydGVkXG4iLA0KIAkJCV9fZnVuY19fKTsNCiAJCXJldHVybjsNCkBAIC0xNDg1 LDcgKzIxOTEsNyBAQCBtdDc1M3hfcGh5bGlua19tYWNfY29uZmlnKHN0cnVjdCBkc2Ffc3dpdGNo ICpkcywgaW50IHBvcnQsIHVuc2lnbmVkIGludCBtb2RlLA0KIAltY3JfbmV3ID0gbWNyX2N1cjsN CiAJbWNyX25ldyAmPSB+UE1DUl9MSU5LX1NFVFRJTkdTX01BU0s7DQogCW1jcl9uZXcgfD0gUE1D Ul9JRkdfWE1JVCgxKSB8IFBNQ1JfTUFDX01PREUgfCBQTUNSX0JBQ0tPRkZfRU4gfA0KLQkJICAg UE1DUl9CQUNLUFJfRU4gfCBQTUNSX0ZPUkNFX01PREU7DQorCQkgICBQTUNSX0JBQ0tQUl9FTiB8 IFBNQ1JfRk9SQ0VfTU9ERV9JRChwcml2LT5pZCk7DQogDQogCS8qIEFyZSB3ZSBjb25uZWN0ZWQg dG8gZXh0ZXJuYWwgcGh5ICovDQogCWlmIChwb3J0ID09IDUgJiYgZHNhX2lzX3VzZXJfcG9ydChk cywgNSkpDQpAQCAtMTQ5NSw3ICsyMjAxLDE4IEBAIG10NzUzeF9waHlsaW5rX21hY19jb25maWco c3RydWN0IGRzYV9zd2l0Y2ggKmRzLCBpbnQgcG9ydCwgdW5zaWduZWQgaW50IG1vZGUsDQogCQlt dDc1MzBfd3JpdGUocHJpdiwgTVQ3NTMwX1BNQ1JfUChwb3J0KSwgbWNyX25ldyk7DQogfQ0KIA0K LXN0YXRpYyB2b2lkIG10NzUzMF9waHlsaW5rX21hY19saW5rX2Rvd24oc3RydWN0IGRzYV9zd2l0 Y2ggKmRzLCBpbnQgcG9ydCwNCitzdGF0aWMgdm9pZA0KK210NzUzeF9waHlsaW5rX21hY19hbl9y ZXN0YXJ0KHN0cnVjdCBkc2Ffc3dpdGNoICpkcywgaW50IHBvcnQpDQorew0KKwlzdHJ1Y3QgbXQ3 NTMwX3ByaXYgKnByaXYgPSBkcy0+cHJpdjsNCisNCisJaWYgKCFwcml2LT5pbmZvLT5tYWNfcGNz X2FuX3Jlc3RhcnQpDQorCQlyZXR1cm47DQorDQorCXByaXYtPmluZm8tPm1hY19wY3NfYW5fcmVz dGFydChkcywgcG9ydCk7DQorfQ0KKw0KK3N0YXRpYyB2b2lkIG10NzUzeF9waHlsaW5rX21hY19s aW5rX2Rvd24oc3RydWN0IGRzYV9zd2l0Y2ggKmRzLCBpbnQgcG9ydCwNCiAJCQkJCSB1bnNpZ25l ZCBpbnQgbW9kZSwNCiAJCQkJCSBwaHlfaW50ZXJmYWNlX3QgaW50ZXJmYWNlKQ0KIHsNCkBAIC0x NTA0LDcgKzIyMjEsMTkgQEAgc3RhdGljIHZvaWQgbXQ3NTMwX3BoeWxpbmtfbWFjX2xpbmtfZG93 bihzdHJ1Y3QgZHNhX3N3aXRjaCAqZHMsIGludCBwb3J0LA0KIAltdDc1MzBfY2xlYXIocHJpdiwg TVQ3NTMwX1BNQ1JfUChwb3J0KSwgUE1DUl9MSU5LX1NFVFRJTkdTX01BU0spOw0KIH0NCiANCi1z dGF0aWMgdm9pZCBtdDc1MzBfcGh5bGlua19tYWNfbGlua191cChzdHJ1Y3QgZHNhX3N3aXRjaCAq ZHMsIGludCBwb3J0LA0KK3N0YXRpYyB2b2lkIG10NzUzeF9tYWNfcGNzX2xpbmtfdXAoc3RydWN0 IGRzYV9zd2l0Y2ggKmRzLCBpbnQgcG9ydCwNCisJCQkJICAgdW5zaWduZWQgaW50IG1vZGUsIHBo eV9pbnRlcmZhY2VfdCBpbnRlcmZhY2UsDQorCQkJCSAgIGludCBzcGVlZCwgaW50IGR1cGxleCkN Cit7DQorCXN0cnVjdCBtdDc1MzBfcHJpdiAqcHJpdiA9IGRzLT5wcml2Ow0KKw0KKwlpZiAoIXBy aXYtPmluZm8tPm1hY19wY3NfbGlua191cCkNCisJCXJldHVybjsNCisNCisJcHJpdi0+aW5mby0+ bWFjX3Bjc19saW5rX3VwKGRzLCBwb3J0LCBtb2RlLCBpbnRlcmZhY2UsIHNwZWVkLCBkdXBsZXgp Ow0KK30NCisNCitzdGF0aWMgdm9pZCBtdDc1M3hfcGh5bGlua19tYWNfbGlua191cChzdHJ1Y3Qg ZHNhX3N3aXRjaCAqZHMsIGludCBwb3J0LA0KIAkJCQkgICAgICAgdW5zaWduZWQgaW50IG1vZGUs DQogCQkJCSAgICAgICBwaHlfaW50ZXJmYWNlX3QgaW50ZXJmYWNlLA0KIAkJCQkgICAgICAgc3Ry dWN0IHBoeV9kZXZpY2UgKnBoeWRldiwNCkBAIC0xNTE0LDggKzIyNDMsMTkgQEAgc3RhdGljIHZv aWQgbXQ3NTMwX3BoeWxpbmtfbWFjX2xpbmtfdXAoc3RydWN0IGRzYV9zd2l0Y2ggKmRzLCBpbnQg cG9ydCwNCiAJc3RydWN0IG10NzUzMF9wcml2ICpwcml2ID0gZHMtPnByaXY7DQogCXUzMiBtY3I7 DQogDQorCW10NzUzeF9tYWNfcGNzX2xpbmtfdXAoZHMsIHBvcnQsIG1vZGUsIGludGVyZmFjZSwg c3BlZWQsIGR1cGxleCk7DQorDQogCW1jciA9IFBNQ1JfUlhfRU4gfCBQTUNSX1RYX0VOIHwgUE1D Ul9GT1JDRV9MTks7DQogDQorCS8qIE1UNzUzeCBNQUMgd29ya3MgaW4gMUcgZnVsbCBkdXBsZXgg bW9kZSBmb3IgYWxsIHVwLWNsb2NrZWQNCisJICogdmFyaWFudHMuDQorCSAqLw0KKwlpZiAoaW50 ZXJmYWNlID09IFBIWV9JTlRFUkZBQ0VfTU9ERV9UUkdNSUkgfHwNCisJICAgIChwaHlfaW50ZXJm YWNlX21vZGVfaXNfODAyM3ooaW50ZXJmYWNlKSkpIHsNCisJCXNwZWVkID0gU1BFRURfMTAwMDsN CisJCWR1cGxleCA9IERVUExFWF9GVUxMOw0KKwl9DQorDQogCXN3aXRjaCAoc3BlZWQpIHsNCiAJ Y2FzZSBTUEVFRF8xMDAwOg0KIAkJbWNyIHw9IFBNQ1JfRk9SQ0VfU1BFRURfMTAwMDsNCkBAIC0x NTM1LDYgKzIyNzUsNDUgQEAgc3RhdGljIHZvaWQgbXQ3NTMwX3BoeWxpbmtfbWFjX2xpbmtfdXAo c3RydWN0IGRzYV9zd2l0Y2ggKmRzLCBpbnQgcG9ydCwNCiAJbXQ3NTMwX3NldChwcml2LCBNVDc1 MzBfUE1DUl9QKHBvcnQpLCBtY3IpOw0KIH0NCiANCitzdGF0aWMgaW50DQorbXQ3NTMxX2NwdV9w b3J0X2NvbmZpZyhzdHJ1Y3QgZHNhX3N3aXRjaCAqZHMsIGludCBwb3J0KQ0KK3sNCisJc3RydWN0 IG10NzUzMF9wcml2ICpwcml2ID0gZHMtPnByaXY7DQorCXBoeV9pbnRlcmZhY2VfdCBpbnRlcmZh Y2U7DQorCWludCBzcGVlZDsNCisNCisJc3dpdGNoIChwb3J0KSB7DQorCWNhc2UgNToNCisJCWlm IChtdDc1MzFfaXNfcmdtaWlfcG9ydChwcml2LCBwb3J0KSkNCisJCQlpbnRlcmZhY2UgPSBQSFlf SU5URVJGQUNFX01PREVfUkdNSUk7DQorCQllbHNlDQorCQkJaW50ZXJmYWNlID0gUEhZX0lOVEVS RkFDRV9NT0RFXzI1MDBCQVNFWDsNCisNCisJCXByaXYtPnA1X2ludGVyZmFjZSA9IGludGVyZmFj ZTsNCisJCWJyZWFrOw0KKwljYXNlIDY6DQorCQlpbnRlcmZhY2UgPSBQSFlfSU5URVJGQUNFX01P REVfMjUwMEJBU0VYOw0KKw0KKwkJbXQ3NTMxX3BhZF9zZXR1cChkcywgaW50ZXJmYWNlKTsNCisN CisJCXByaXYtPnA2X2ludGVyZmFjZSA9IGludGVyZmFjZTsNCisJCWJyZWFrOw0KKwl9Ow0KKw0K KwlpZiAoaW50ZXJmYWNlID09IFBIWV9JTlRFUkZBQ0VfTU9ERV8yNTAwQkFTRVgpDQorCQlzcGVl ZCA9IFNQRUVEXzI1MDA7DQorCWVsc2UNCisJCXNwZWVkID0gU1BFRURfMTAwMDsNCisNCisJbXQ3 NTMxX21hY19jb25maWcoZHMsIHBvcnQsIE1MT19BTl9GSVhFRCwgaW50ZXJmYWNlKTsNCisJbXQ3 NTMwX3dyaXRlKHByaXYsIE1UNzUzMF9QTUNSX1AocG9ydCksDQorCQkgICAgIFBNQ1JfQ1BVX1BP UlRfU0VUVElORyhwcml2LT5pZCkpOw0KKwltdDc1M3hfcGh5bGlua19tYWNfbGlua191cChkcywg cG9ydCwgTUxPX0FOX0ZJWEVELCBpbnRlcmZhY2UsIE5VTEwsDQorCQkJCSAgIHNwZWVkLCBEVVBM RVhfRlVMTCwgdHJ1ZSwgdHJ1ZSk7DQorDQorCXJldHVybiAwOw0KK30NCisNCiBzdGF0aWMgdm9p ZA0KIG10NzUzMF9tYWNfcG9ydF92YWxpZGF0ZShzdHJ1Y3QgZHNhX3N3aXRjaCAqZHMsIGludCBw b3J0LA0KIAkJCSB1bnNpZ25lZCBsb25nICpzdXBwb3J0ZWQpDQpAQCAtMTU0Myw2ICsyMzIyLDE0 IEBAIG10NzUzMF9tYWNfcG9ydF92YWxpZGF0ZShzdHJ1Y3QgZHNhX3N3aXRjaCAqZHMsIGludCBw b3J0LA0KIAkJcGh5bGlua19zZXQoc3VwcG9ydGVkLCAxMDAwYmFzZVhfRnVsbCk7DQogfQ0KIA0K K3N0YXRpYyB2b2lkIG10NzUzMV9tYWNfcG9ydF92YWxpZGF0ZShzdHJ1Y3QgZHNhX3N3aXRjaCAq ZHMsIGludCBwb3J0LA0KKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgKnN1cHBvcnRlZCkNCit7DQor CXN0cnVjdCBtdDc1MzBfcHJpdiAqcHJpdiA9IGRzLT5wcml2Ow0KKw0KKwltdDc1MzFfc2dtaWlf dmFsaWRhdGUocHJpdiwgcG9ydCwgc3VwcG9ydGVkKTsNCit9DQorDQogc3RhdGljIHZvaWQNCiBt dDc1M3hfcGh5bGlua192YWxpZGF0ZShzdHJ1Y3QgZHNhX3N3aXRjaCAqZHMsIGludCBwb3J0LA0K IAkJCXVuc2lnbmVkIGxvbmcgKnN1cHBvcnRlZCwNCkBAIC0xNTU5LDcgKzIzNDYsOCBAQCBtdDc1 M3hfcGh5bGlua192YWxpZGF0ZShzdHJ1Y3QgZHNhX3N3aXRjaCAqZHMsIGludCBwb3J0LA0KIA0K IAlwaHlsaW5rX3NldF9wb3J0X21vZGVzKG1hc2spOw0KIA0KLQlpZiAoc3RhdGUtPmludGVyZmFj ZSAhPSBQSFlfSU5URVJGQUNFX01PREVfVFJHTUlJKSB7DQorCWlmIChzdGF0ZS0+aW50ZXJmYWNl ICE9IFBIWV9JTlRFUkZBQ0VfTU9ERV9UUkdNSUkgfHwNCisJICAgICFwaHlfaW50ZXJmYWNlX21v ZGVfaXNfODAyM3ooc3RhdGUtPmludGVyZmFjZSkpIHsNCiAJCXBoeWxpbmtfc2V0KG1hc2ssIDEw YmFzZVRfSGFsZik7DQogCQlwaHlsaW5rX3NldChtYXNrLCAxMGJhc2VUX0Z1bGwpOw0KIAkJcGh5 bGlua19zZXQobWFzaywgMTAwYmFzZVRfSGFsZik7DQpAQCAtMTU3OCw2ICsyMzY2LDExIEBAIG10 NzUzeF9waHlsaW5rX3ZhbGlkYXRlKHN0cnVjdCBkc2Ffc3dpdGNoICpkcywgaW50IHBvcnQsDQog DQogCWxpbmttb2RlX2FuZChzdXBwb3J0ZWQsIHN1cHBvcnRlZCwgbWFzayk7DQogCWxpbmttb2Rl X2FuZChzdGF0ZS0+YWR2ZXJ0aXNpbmcsIHN0YXRlLT5hZHZlcnRpc2luZywgbWFzayk7DQorDQor CS8qIFdlIGNhbiBvbmx5IG9wZXJhdGUgYXQgMjUwMEJhc2VYIG9yIDEwMDBCYXNlWC4gIElmIHJl cXVlc3RlZA0KKwkgKiB0byBhZHZlcnRpc2UgYm90aCwgb25seSByZXBvcnQgYWR2ZXJ0aXNpbmcg YXQgMjUwMEJhc2VYLg0KKwkgKi8NCisJcGh5bGlua19oZWxwZXJfYmFzZXhfc3BlZWQoc3RhdGUp Ow0KIH0NCiANCiBzdGF0aWMgaW50DQpAQCAtMTYyMCw2ICsyNDEzLDU3IEBAIG10NzUzMF9waHls aW5rX21hY19saW5rX3N0YXRlKHN0cnVjdCBkc2Ffc3dpdGNoICpkcywgaW50IHBvcnQsDQogCXJl dHVybiAxOw0KIH0NCiANCitzdGF0aWMgaW50DQorbXQ3NTMxX3NnbWlpX3Bjc19nZXRfc3RhdGVf YW4oc3RydWN0IG10NzUzMF9wcml2ICpwcml2LCBpbnQgcG9ydCwNCisJCQkgICAgICBzdHJ1Y3Qg cGh5bGlua19saW5rX3N0YXRlICpzdGF0ZSkNCit7DQorCXUzMiBzdGF0dXMsIHZhbDsNCisJdTE2 IGNvbmZpZ19yZWc7DQorDQorCXN0YXR1cyA9IG10NzUzMF9yZWFkKHByaXYsIE1UNzUzMV9QQ1Nf Q09OVFJPTF8xKHBvcnQpKTsNCisJc3RhdGUtPmxpbmsgPSAhIShzdGF0dXMgJiBNVDc1MzFfU0dN SUlfTElOS19TVEFUVVMpOw0KKwlpZiAoc3RhdGUtPmludGVyZmFjZSA9PSBQSFlfSU5URVJGQUNF X01PREVfU0dNSUkgJiYNCisJICAgIChzdGF0dXMgJiBNVDc1MzFfU0dNSUlfQU5fRU5BQkxFKSkg ew0KKwkJdmFsID0gbXQ3NTMwX3JlYWQocHJpdiwgTVQ3NTMxX1BDU19TUEVFRF9BQklMSVRZKHBv cnQpKTsNCisJCWNvbmZpZ19yZWcgPSB2YWwgPj4gMTY7DQorDQorCQlzd2l0Y2ggKGNvbmZpZ19y ZWcgJiBMUEFfU0dNSUlfU1BEX01BU0spIHsNCisJCWNhc2UgTFBBX1NHTUlJXzEwMDA6DQorCQkJ c3RhdGUtPnNwZWVkID0gU1BFRURfMTAwMDsNCisJCQlicmVhazsNCisJCWNhc2UgTFBBX1NHTUlJ XzEwMDoNCisJCQlzdGF0ZS0+c3BlZWQgPSBTUEVFRF8xMDA7DQorCQkJYnJlYWs7DQorCQljYXNl IExQQV9TR01JSV8xMDoNCisJCQlzdGF0ZS0+c3BlZWQgPSBTUEVFRF8xMDsNCisJCQlicmVhazsN CisJCWRlZmF1bHQ6DQorCQkJZGV2X2Vycihwcml2LT5kZXYsICJpbnZhbGlkIHNnbWlpIFBIWSBz cGVlZFxuIik7DQorCQkJc3RhdGUtPmxpbmsgPSBmYWxzZTsNCisJCQlyZXR1cm4gLUVJTlZBTDsN CisJCX0NCisNCisJCWlmIChjb25maWdfcmVnICYgTFBBX1NHTUlJX0ZVTExfRFVQTEVYKQ0KKwkJ CXN0YXRlLT5kdXBsZXggPSBEVVBMRVhfRlVMTDsNCisJCWVsc2UNCisJCQlzdGF0ZS0+ZHVwbGV4 ID0gRFVQTEVYX0hBTEY7DQorCX0NCisNCisJcmV0dXJuIDA7DQorfQ0KKw0KK3N0YXRpYyBpbnQN CittdDc1MzFfcGh5bGlua19tYWNfbGlua19zdGF0ZShzdHJ1Y3QgZHNhX3N3aXRjaCAqZHMsIGlu dCBwb3J0LA0KKwkJCSAgICAgIHN0cnVjdCBwaHlsaW5rX2xpbmtfc3RhdGUgKnN0YXRlKQ0KK3sN CisJc3RydWN0IG10NzUzMF9wcml2ICpwcml2ID0gZHMtPnByaXY7DQorDQorCWlmIChzdGF0ZS0+ aW50ZXJmYWNlID09IFBIWV9JTlRFUkZBQ0VfTU9ERV9TR01JSSkNCisJCXJldHVybiBtdDc1MzFf c2dtaWlfcGNzX2dldF9zdGF0ZV9hbihwcml2LCBwb3J0LCBzdGF0ZSk7DQorDQorCXJldHVybiAt RU9QTk9UU1VQUDsNCit9DQorDQogc3RhdGljIGludA0KIG10NzUzeF9waHlsaW5rX21hY19saW5r X3N0YXRlKHN0cnVjdCBkc2Ffc3dpdGNoICpkcywgaW50IHBvcnQsDQogCQkJICAgICAgc3RydWN0 IHBoeWxpbmtfbGlua19zdGF0ZSAqc3RhdGUpDQpAQCAtMTY3MywxMyArMjUxNywxNCBAQCBzdGF0 aWMgY29uc3Qgc3RydWN0IGRzYV9zd2l0Y2hfb3BzIG10NzUzMF9zd2l0Y2hfb3BzID0gew0KIAku cG9ydF92bGFuX3ByZXBhcmUJPSBtdDc1MzBfcG9ydF92bGFuX3ByZXBhcmUsDQogCS5wb3J0X3Zs YW5fYWRkCQk9IG10NzUzMF9wb3J0X3ZsYW5fYWRkLA0KIAkucG9ydF92bGFuX2RlbAkJPSBtdDc1 MzBfcG9ydF92bGFuX2RlbCwNCi0JLnBvcnRfbWlycm9yX2FkZAk9IG10NzUzMF9wb3J0X21pcnJv cl9hZGQsDQotCS5wb3J0X21pcnJvcl9kZWwJPSBtdDc1MzBfcG9ydF9taXJyb3JfZGVsLA0KKwku cG9ydF9taXJyb3JfYWRkCT0gbXQ3NTN4X3BvcnRfbWlycm9yX2FkZCwNCisJLnBvcnRfbWlycm9y X2RlbAk9IG10NzUzeF9wb3J0X21pcnJvcl9kZWwsDQogCS5waHlsaW5rX3ZhbGlkYXRlCT0gbXQ3 NTN4X3BoeWxpbmtfdmFsaWRhdGUsDQogCS5waHlsaW5rX21hY19saW5rX3N0YXRlCT0gbXQ3NTN4 X3BoeWxpbmtfbWFjX2xpbmtfc3RhdGUsDQogCS5waHlsaW5rX21hY19jb25maWcJPSBtdDc1M3hf cGh5bGlua19tYWNfY29uZmlnLA0KLQkucGh5bGlua19tYWNfbGlua19kb3duCT0gbXQ3NTMwX3Bo eWxpbmtfbWFjX2xpbmtfZG93biwNCi0JLnBoeWxpbmtfbWFjX2xpbmtfdXAJPSBtdDc1MzBfcGh5 bGlua19tYWNfbGlua191cCwNCisJLnBoeWxpbmtfbWFjX2FuX3Jlc3RhcnQJPSBtdDc1M3hfcGh5 bGlua19tYWNfYW5fcmVzdGFydCwNCisJLnBoeWxpbmtfbWFjX2xpbmtfZG93bgk9IG10NzUzeF9w aHlsaW5rX21hY19saW5rX2Rvd24sDQorCS5waHlsaW5rX21hY19saW5rX3VwCT0gbXQ3NTN4X3Bo eWxpbmtfbWFjX2xpbmtfdXAsDQogfTsNCiANCiBzdGF0aWMgY29uc3Qgc3RydWN0IG10NzUzeF9p bmZvIG10NzUzeF90YWJsZVtdID0gew0KQEAgLTE3MDUsMTEgKzI1NTAsMjYgQEAgc3RhdGljIGNv bnN0IHN0cnVjdCBtdDc1M3hfaW5mbyBtdDc1M3hfdGFibGVbXSA9IHsNCiAJCS5tYWNfcG9ydF9n ZXRfc3RhdGUgPSBtdDc1MzBfcGh5bGlua19tYWNfbGlua19zdGF0ZSwNCiAJCS5tYWNfcG9ydF9j b25maWcgPSBtdDc1MzBfbWFjX2NvbmZpZywNCiAJfSwNCisJW0lEX01UNzUzMV0gPSB7DQorCQku aWQgPSBJRF9NVDc1MzEsDQorCQkuc3dfc2V0dXAgPSBtdDc1MzFfc2V0dXAsDQorCQkucGh5X3Jl YWQgPSBtdDc1MzFfaW5kX3BoeV9yZWFkLA0KKwkJLnBoeV93cml0ZSA9IG10NzUzMV9pbmRfcGh5 X3dyaXRlLA0KKwkJLnBhZF9zZXR1cCA9IG10NzUzMV9wYWRfc2V0dXAsDQorCQkuY3B1X3BvcnRf Y29uZmlnID0gbXQ3NTMxX2NwdV9wb3J0X2NvbmZpZywNCisJCS5waHlfbW9kZV9zdXBwb3J0ZWQg PSBtdDc1MzFfcGh5X3N1cHBvcnRlZCwNCisJCS5tYWNfcG9ydF92YWxpZGF0ZSA9IG10NzUzMV9t YWNfcG9ydF92YWxpZGF0ZSwNCisJCS5tYWNfcG9ydF9nZXRfc3RhdGUgPSBtdDc1MzFfcGh5bGlu a19tYWNfbGlua19zdGF0ZSwNCisJCS5tYWNfcG9ydF9jb25maWcgPSBtdDc1MzFfbWFjX2NvbmZp ZywNCisJCS5tYWNfcGNzX2FuX3Jlc3RhcnQgPSBtdDc1MzFfc2dtaWlfcmVzdGFydF9hbiwNCisJ CS5tYWNfcGNzX2xpbmtfdXAgPSBtdDc1MzFfc2dtaWlfbGlua191cF9mb3JjZSwNCisJfSwNCiB9 Ow0KIA0KIHN0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIG10NzUzMF9vZl9tYXRjaFtd ID0gew0KIAl7IC5jb21wYXRpYmxlID0gIm1lZGlhdGVrLG10NzYyMSIsIC5kYXRhID0gJm10NzUz eF90YWJsZVtJRF9NVDc2MjFdLCB9LA0KIAl7IC5jb21wYXRpYmxlID0gIm1lZGlhdGVrLG10NzUz MCIsIC5kYXRhID0gJm10NzUzeF90YWJsZVtJRF9NVDc1MzBdLCB9LA0KKwl7IC5jb21wYXRpYmxl ID0gIm1lZGlhdGVrLG10NzUzMSIsIC5kYXRhID0gJm10NzUzeF90YWJsZVtJRF9NVDc1MzFdLCB9 LA0KIAl7IC8qIHNlbnRpbmVsICovIH0sDQogfTsNCiBNT0RVTEVfREVWSUNFX1RBQkxFKG9mLCBt dDc1MzBfb2ZfbWF0Y2gpOw0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2RzYS9tdDc1MzAuaCBi L2RyaXZlcnMvbmV0L2RzYS9tdDc1MzAuaA0KaW5kZXggNDRhYzU1NDMzMDg5Li45Mjc4YThlM2Qw NGUgMTAwNjQ0DQotLS0gYS9kcml2ZXJzL25ldC9kc2EvbXQ3NTMwLmgNCisrKyBiL2RyaXZlcnMv bmV0L2RzYS9tdDc1MzAuaA0KQEAgLTE0LDYgKzE0LDcgQEANCiBlbnVtIG10NzUzeF9pZCB7DQog CUlEX01UNzUzMCA9IDAsDQogCUlEX01UNzYyMSA9IDEsDQorCUlEX01UNzUzMSA9IDIsDQogfTsN CiANCiAjZGVmaW5lCU5VTV9UUkdNSUlfQ1RSTAkJCTUNCkBAIC00MSw2ICs0MiwzMyBAQCBlbnVt IG10NzUzeF9pZCB7DQogI2RlZmluZSAgTUlSUk9SX1BPUlQoeCkJCQkoKHgpICYgMHg3KQ0KICNk ZWZpbmUgIE1JUlJPUl9NQVNLCQkJMHg3DQogDQorLyogUmVnaXN0ZXJzIGZvciBDUFUgZm9yd2Fy ZCBjb250cm9sICovDQorI2RlZmluZSBNVDc1MzFfQ0ZDCQkJMHg0DQorI2RlZmluZSAgTVQ3NTMx X01JUlJPUl9FTgkJQklUKDE5KQ0KKyNkZWZpbmUgIE1UNzUzMV9NSVJST1JfTUFTSwkJKE1JUlJP Ul9NQVNLIDw8IDE2KQ0KKyNkZWZpbmUgIE1UNzUzMV9NSVJST1JfUE9SVF9HRVQoeCkJKCgoeCkg Pj4gMTYpICYgTUlSUk9SX01BU0spDQorI2RlZmluZSAgTVQ3NTMxX01JUlJPUl9QT1JUX1NFVCh4 KQkoKCh4KSAmIE1JUlJPUl9NQVNLKSA8PCAxNikNCisjZGVmaW5lICBNVDc1MzFfQ1BVX1BNQVBf TUFTSwkJR0VOTUFTSyg3LCAwKQ0KKw0KKyNkZWZpbmUgTVQ3NTNYX01JUlJPUl9SRUcoaWQpCQko KChpZCkgPT0gSURfTVQ3NTMxKSA/IFwNCisJCQkJCSBNVDc1MzFfQ0ZDIDogTVQ3NTMwX01GQykN CisjZGVmaW5lIE1UNzUzWF9NSVJST1JfRU4oaWQpCQkoKChpZCkgPT0gSURfTVQ3NTMxKSA/IFwN CisJCQkJCSBNVDc1MzFfTUlSUk9SX0VOIDogTUlSUk9SX0VOKQ0KKyNkZWZpbmUgTVQ3NTNYX01J UlJPUl9NQVNLKGlkKQkJKCgoaWQpID09IElEX01UNzUzMSkgPyBcDQorCQkJCQkgTVQ3NTMxX01J UlJPUl9NQVNLIDogTUlSUk9SX01BU0spDQorDQorLyogUmVnaXN0ZXJzIGZvciBCUERVIGFuZCBQ QUUgZnJhbWUgY29udHJvbCovDQorI2RlZmluZSBNVDc1M1hfQlBDCQkJMHgyNA0KKyNkZWZpbmUg IE1UNzUzWF9CUERVX1BPUlRfRldfTUFTSwlHRU5NQVNLKDIsIDApDQorDQorZW51bSBtdDc1M3hf YnBkdV9wb3J0X2Z3IHsNCisJTVQ3NTNYX0JQRFVfRk9MTE9XX01GQywNCisJTVQ3NTNYX0JQRFVf Q1BVX0VYQ0xVREUgPSA0LA0KKwlNVDc1M1hfQlBEVV9DUFVfSU5DTFVERSA9IDUsDQorCU1UNzUz WF9CUERVX0NQVV9PTkxZID0gNiwNCisJTVQ3NTNYX0JQRFVfRFJPUCA9IDcsDQorfTsNCisNCiAv KiBSZWdpc3RlcnMgZm9yIGFkZHJlc3MgdGFibGUgYWNjZXNzICovDQogI2RlZmluZSBNVDc1MzBf QVRBMQkJCTB4NzQNCiAjZGVmaW5lICBTVEFUSUNfRU1QCQkJMA0KQEAgLTIyMCwxMCArMjQ4LDMw IEBAIGVudW0gbXQ3NTMwX3ZsYW5fcG9ydF9hdHRyIHsNCiAjZGVmaW5lICBQTUNSX0ZPUkNFX0xO SwkJCUJJVCgwKQ0KICNkZWZpbmUgIFBNQ1JfU1BFRURfTUFTSwkJKFBNQ1JfRk9SQ0VfU1BFRURf MTAwIHwgXA0KIAkJCQkJIFBNQ1JfRk9SQ0VfU1BFRURfMTAwMCkNCisjZGVmaW5lICBNVDc1MzFf Rk9SQ0VfTE5LCQlCSVQoMzEpDQorI2RlZmluZSAgTVQ3NTMxX0ZPUkNFX1NQRAkJQklUKDMwKQ0K KyNkZWZpbmUgIE1UNzUzMV9GT1JDRV9EUFgJCUJJVCgyOSkNCisjZGVmaW5lICBNVDc1MzFfRk9S Q0VfUlhfRkMJCUJJVCgyOCkNCisjZGVmaW5lICBNVDc1MzFfRk9SQ0VfVFhfRkMJCUJJVCgyNykN CisjZGVmaW5lICBNVDc1MzFfRk9SQ0VfTU9ERQkJKE1UNzUzMV9GT1JDRV9MTksgfCBcDQorCQkJ CQkgTVQ3NTMxX0ZPUkNFX1NQRCB8IFwNCisJCQkJCSBNVDc1MzFfRk9SQ0VfRFBYIHwgXA0KKwkJ CQkJIE1UNzUzMV9GT1JDRV9SWF9GQyB8IFwNCisJCQkJCSBNVDc1MzFfRk9SQ0VfVFhfRkMpDQor I2RlZmluZSAgUE1DUl9GT1JDRV9NT0RFX0lEKGlkKQkJKCgoaWQpID09IElEX01UNzUzMSkgPyBc DQorCQkJCQkgTVQ3NTMxX0ZPUkNFX01PREUgOiBcDQorCQkJCQkgUE1DUl9GT1JDRV9NT0RFKQ0K ICNkZWZpbmUgIFBNQ1JfTElOS19TRVRUSU5HU19NQVNLCShQTUNSX1RYX0VOIHwgUE1DUl9GT1JD RV9TUEVFRF8xMDAwIHwgXA0KIAkJCQkJIFBNQ1JfUlhfRU4gfCBQTUNSX0ZPUkNFX1NQRUVEXzEw MCB8IFwNCiAJCQkJCSBQTUNSX1RYX0ZDX0VOIHwgUE1DUl9SWF9GQ19FTiB8IFwNCiAJCQkJCSBQ TUNSX0ZPUkNFX0ZEWCB8IFBNQ1JfRk9SQ0VfTE5LKQ0KKyNkZWZpbmUgIFBNQ1JfQ1BVX1BPUlRf U0VUVElORyhpZCkJKFBNQ1JfRk9SQ0VfTU9ERV9JRCgoaWQpKSB8IFwNCisJCQkJCSBQTUNSX0lG R19YTUlUKDEpIHwgUE1DUl9NQUNfTU9ERSB8IFwNCisJCQkJCSBQTUNSX0JBQ0tPRkZfRU4gfCBQ TUNSX0JBQ0tQUl9FTiB8IFwNCisJCQkJCSBQTUNSX1RYX0VOIHwgUE1DUl9SWF9FTiB8IFwNCisJ CQkJCSBQTUNSX1RYX0ZDX0VOIHwgUE1DUl9SWF9GQ19FTiB8IFwNCisJCQkJCSBQTUNSX0ZPUkNF X1NQRUVEXzEwMDAgfCBcDQorCQkJCQkgUE1DUl9GT1JDRV9GRFggfCBQTUNSX0ZPUkNFX0xOSykN CiANCiAjZGVmaW5lIE1UNzUzMF9QTVNSX1AoeCkJCSgweDMwMDggKyAoeCkgKiAweDEwMCkNCiAj ZGVmaW5lICBQTVNSX0VFRTFHCQkJQklUKDcpDQpAQCAtMjM3LDYgKzI4NSwxMCBAQCBlbnVtIG10 NzUzMF92bGFuX3BvcnRfYXR0ciB7DQogI2RlZmluZSAgUE1TUl9EUFgJCQlCSVQoMSkNCiAjZGVm aW5lICBQTVNSX0xJTksJCQlCSVQoMCkNCiANCisvKiBSZWdpc3RlciBmb3IgcG9ydCBkZWJ1ZyBj b3VudCAqLw0KKyNkZWZpbmUgTVQ3NTMxX0RCR19DTlQoeCkJCSgweDMwMTggKyAoeCkgKiAweDEw MCkNCisjZGVmaW5lICBNVDc1MzFfRElTX0NMUgkJCUJJVCgzMSkNCisNCiAvKiBSZWdpc3RlciBm b3IgTUlCICovDQogI2RlZmluZSBNVDc1MzBfUE9SVF9NSUJfQ09VTlRFUih4KQkoMHg0MDAwICsg KHgpICogMHgxMDApDQogI2RlZmluZSBNVDc1MzBfTUlCX0NDUgkJCTB4NGZlMA0KQEAgLTI1NCwx MiArMzA2LDExOCBAQCBlbnVtIG10NzUzMF92bGFuX3BvcnRfYXR0ciB7DQogCQkJCQkgQ0NSX1JY X09DVF9DTlRfQkFEIHwgXA0KIAkJCQkJIENDUl9UWF9PQ1RfQ05UX0dPT0QgfCBcDQogCQkJCQkg Q0NSX1RYX09DVF9DTlRfQkFEKQ0KKw0KKy8qIE1UNzUzMSBTR01JSSByZWdpc3RlciBncm91cCAq Lw0KKyNkZWZpbmUgTVQ3NTMxX1NHTUlJX1JFR19CQVNFCQkweDUwMDANCisjZGVmaW5lIE1UNzUz MV9TR01JSV9SRUcocCwgcikJCShNVDc1MzFfU0dNSUlfUkVHX0JBU0UgKyBcDQorCQkJCQkoKHAp IC0gNSkgKiAweDEwMDAgKyAocikpDQorDQorLyogUmVnaXN0ZXIgZm9yU0dNSUkgUENTX0NPTlRS T0xfMSAqLw0KKyNkZWZpbmUgTVQ3NTMxX1BDU19DT05UUk9MXzEocCkJCU1UNzUzMV9TR01JSV9S RUcocCwgMHgwMCkNCisjZGVmaW5lICBNVDc1MzFfU0dNSUlfTElOS19TVEFUVVMJQklUKDE4KQ0K KyNkZWZpbmUgIE1UNzUzMV9TR01JSV9BTl9FTkFCTEUJCUJJVCgxMikNCisjZGVmaW5lICBNVDc1 MzFfU0dNSUlfQU5fUkVTVEFSVAlCSVQoOSkNCisNCisvKiBSZWdpc3RlciBmb3IgU0dNSUkgUENT X1NQUEVEX0FCSUxJVFkgKi8NCisjZGVmaW5lIE1UNzUzMV9QQ1NfU1BFRURfQUJJTElUWShwKQlN VDc1MzFfU0dNSUlfUkVHKHAsIDB4MDgpDQorI2RlZmluZSAgTVQ3NTMxX1NHTUlJX1RYX0NPTkZJ R19NQVNLCUdFTk1BU0soMTUsIDApDQorI2RlZmluZSAgTVQ3NTMxX1NHTUlJX1RYX0NPTkZJRwkJ QklUKDApDQorDQorLyogUmVnaXN0ZXIgZm9yIFNHTUlJX01PREUgKi8NCisjZGVmaW5lIE1UNzUz MV9TR01JSV9NT0RFKHApCQlNVDc1MzFfU0dNSUlfUkVHKHAsIDB4MjApDQorI2RlZmluZSAgTVQ3 NTMxX1NHTUlJX1JFTU9URV9GQVVMVF9ESVMJQklUKDgpDQorI2RlZmluZSAgTVQ3NTMxX1NHTUlJ X0lGX01PREVfTUFTSwlHRU5NQVNLKDUsIDEpDQorI2RlZmluZSAgTVQ3NTMxX1NHTUlJX0ZPUkNF X0RVUExFWAlCSVQoNCkNCisjZGVmaW5lICBNVDc1MzFfU0dNSUlfRk9SQ0VfU1BFRURfTUFTSwlH RU5NQVNLKDMsIDIpDQorI2RlZmluZSAgTVQ3NTMxX1NHTUlJX0ZPUkNFX1NQRUVEXzEwMDAJQklU KDMpDQorI2RlZmluZSAgTVQ3NTMxX1NHTUlJX0ZPUkNFX1NQRUVEXzEwMAlCSVQoMikNCisjZGVm aW5lICBNVDc1MzFfU0dNSUlfRk9SQ0VfU1BFRURfMTAJMA0KKyNkZWZpbmUgIE1UNzUzMV9TR01J SV9TUEVFRF9EVVBMRVhfQU4JQklUKDEpDQorDQorZW51bSBtdDc1MzFfc2dtaWlfZm9yY2VfZHVw bGV4IHsNCisJTVQ3NTMxX1NHTUlJX0ZPUkNFX0ZVTExfRFVQTEVYID0gMCwNCisJTVQ3NTMxX1NH TUlJX0ZPUkNFX0hBTEZfRFVQTEVYID0gMHgxMCwNCit9Ow0KKw0KKy8qIEZpZWxkcyBvZiBRUEhZ X1BXUl9TVEFURV9DVFJMICovDQorI2RlZmluZSBNVDc1MzFfUVBIWV9QV1JfU1RBVEVfQ1RSTChw KQlNVDc1MzFfU0dNSUlfUkVHKHAsIDB4ZTgpDQorI2RlZmluZSAgTVQ3NTMxX1NHTUlJX1BIWUFf UFdECQlCSVQoNCkNCisNCisvKiBWYWx1ZXMgb2YgU0dNSUkgU1BFRUQgKi8NCisjZGVmaW5lIE1U NzUzMV9QSFlBX0NUUkxfU0lHTkFMMyhwKQlNVDc1MzFfU0dNSUlfUkVHKHAsIDB4MTI4KQ0KKyNk ZWZpbmUgIE1UNzUzMV9SR19UUEhZX1NQRUVEX01BU0sJKEJJVCgyKSB8IEJJVCgzKSkNCisjZGVm aW5lICBNVDc1MzFfUkdfVFBIWV9TUEVFRF8xXzI1RwkweDANCisjZGVmaW5lICBNVDc1MzFfUkdf VFBIWV9TUEVFRF8zXzEyNUcJQklUKDIpDQorDQogLyogUmVnaXN0ZXIgZm9yIHN5c3RlbSByZXNl dCAqLw0KICNkZWZpbmUgTVQ3NTMwX1NZU19DVFJMCQkJMHg3MDAwDQogI2RlZmluZSAgU1lTX0NU UkxfUEhZX1JTVAkJQklUKDIpDQogI2RlZmluZSAgU1lTX0NUUkxfU1dfUlNUCQlCSVQoMSkNCiAj ZGVmaW5lICBTWVNfQ1RSTF9SRUdfUlNUCQlCSVQoMCkNCiANCisvKiBSZWdpc3RlciBmb3IgUEhZ IEluZGlyZWN0IEFjY2VzcyBDb250cm9sICovDQorI2RlZmluZSBNVDc1MzFfUEhZX0lBQwkJCTB4 NzAxQw0KKyNkZWZpbmUgIE1UNzUzMV9QSFlfQUNTX1NUCQlCSVQoMzEpDQorI2RlZmluZSAgTVQ3 NTMxX01ESU9fUkVHX0FERFJfTUFTSwkoMHgxZiA8PCAyNSkNCisjZGVmaW5lICBNVDc1MzFfTURJ T19QSFlfQUREUl9NQVNLCSgweDFmIDw8IDIwKQ0KKyNkZWZpbmUgIE1UNzUzMV9NRElPX0NNRF9N QVNLCQkoMHgzIDw8IDE4KQ0KKyNkZWZpbmUgIE1UNzUzMV9NRElPX1NUX01BU0sJCSgweDMgPDwg MTYpDQorI2RlZmluZSAgTVQ3NTMxX01ESU9fUldfREFUQV9NQVNLCSgweGZmZmYpDQorI2RlZmlu ZSAgTVQ3NTMxX01ESU9fUkVHX0FERFIoeCkJKCgoeCkgJiAweDFmKSA8PCAyNSkNCisjZGVmaW5l ICBNVDc1MzFfTURJT19ERVZfQUREUih4KQkoKCh4KSAmIDB4MWYpIDw8IDI1KQ0KKyNkZWZpbmUg IE1UNzUzMV9NRElPX1BIWV9BRERSKHgpCSgoKHgpICYgMHgxZikgPDwgMjApDQorI2RlZmluZSAg TVQ3NTMxX01ESU9fQ01EKHgpCQkoKCh4KSAmIDB4MykgPDwgMTgpDQorI2RlZmluZSAgTVQ3NTMx X01ESU9fU1QoeCkJCSgoKHgpICYgMHgzKSA8PCAxNikNCisNCitlbnVtIG10NzUzMV9waHlfaWFj X2NtZCB7DQorCU1UNzUzMV9NRElPX0FERFIgPSAwLA0KKwlNVDc1MzFfTURJT19XUklURSA9IDEs DQorCU1UNzUzMV9NRElPX1JFQUQgPSAyLA0KKwlNVDc1MzFfTURJT19SRUFEX0NMNDUgPSAzLA0K K307DQorDQorLyogTURJT19TVDogTURJTyBzdGFydCBmaWVsZCAqLw0KK2VudW0gbXQ3NTMxX21k aW9fc3Qgew0KKwlNVDc1MzFfTURJT19TVF9DTDQ1ID0gMCwNCisJTVQ3NTMxX01ESU9fU1RfQ0wy MiA9IDEsDQorfTsNCisNCisjZGVmaW5lICBNVDc1MzFfTURJT19DTDIyX1JFQUQJCShNVDc1MzFf TURJT19TVChNVDc1MzFfTURJT19TVF9DTDIyKSB8IFwNCisJCQkJCSBNVDc1MzFfTURJT19DTUQo TVQ3NTMxX01ESU9fUkVBRCkpDQorI2RlZmluZSAgTVQ3NTMxX01ESU9fQ0wyMl9XUklURQkJKE1U NzUzMV9NRElPX1NUKE1UNzUzMV9NRElPX1NUX0NMMjIpIHwgXA0KKwkJCQkJIE1UNzUzMV9NRElP X0NNRChNVDc1MzFfTURJT19XUklURSkpDQorI2RlZmluZSAgTVQ3NTMxX01ESU9fQ0w0NV9BRERS CQkoTVQ3NTMxX01ESU9fU1QoTVQ3NTMxX01ESU9fU1RfQ0w0NSkgfCBcDQorCQkJCQkgTVQ3NTMx X01ESU9fQ01EKE1UNzUzMV9NRElPX0FERFIpKQ0KKyNkZWZpbmUgIE1UNzUzMV9NRElPX0NMNDVf UkVBRAkJKE1UNzUzMV9NRElPX1NUKE1UNzUzMV9NRElPX1NUX0NMNDUpIHwgXA0KKwkJCQkJIE1U NzUzMV9NRElPX0NNRChNVDc1MzFfTURJT19SRUFEKSkNCisjZGVmaW5lICBNVDc1MzFfTURJT19D TDQ1X1dSSVRFCQkoTVQ3NTMxX01ESU9fU1QoTVQ3NTMxX01ESU9fU1RfQ0w0NSkgfCBcDQorCQkJ CQkgTVQ3NTMxX01ESU9fQ01EKE1UNzUzMV9NRElPX1dSSVRFKSkNCisNCisvKiBSZWdpc3RlciBm b3IgUkdNSUkgY2xvY2sgcGhhc2UgKi8NCisjZGVmaW5lIE1UNzUzMV9DTEtHRU5fQ1RSTAkJMHg3 NTAwDQorI2RlZmluZSAgQ0xLX1NLRVdfT1VUKHgpCQkoKCh4KSAmIDB4MykgPDwgOCkNCisjZGVm aW5lICBDTEtfU0tFV19PVVRfTUFTSwkJR0VOTUFTSyg5LCA4KQ0KKyNkZWZpbmUgIENMS19TS0VX X0lOKHgpCQkJKCgoeCkgJiAweDMpIDw8IDYpDQorI2RlZmluZSAgQ0xLX1NLRVdfSU5fTUFTSwkJ R0VOTUFTSyg3LCA2KQ0KKyNkZWZpbmUgIFJYQ0xLX05PX0RFTEFZCQkJQklUKDUpDQorI2RlZmlu ZSAgVFhDTEtfTk9fUkVWRVJTRQkJQklUKDQpDQorI2RlZmluZSAgR1BfTU9ERSh4KQkJCSgoKHgp ICYgMHgzKSA8PCAxKQ0KKyNkZWZpbmUgIEdQX01PREVfTUFTSwkJCUdFTk1BU0soMiwgMSkNCisj ZGVmaW5lICBHUF9DTEtfRU4JCQlCSVQoMCkNCisNCitlbnVtIG10NzUzMV9ncF9tb2RlIHsNCisJ TVQ3NTMxX0dQX01PREVfUkdNSUkgPSAwLA0KKwlNVDc1MzFfR1BfTU9ERV9NSUkgPSAxLA0KKwlN VDc1MzFfR1BfTU9ERV9SRVZfTUlJID0gMg0KK307DQorDQorZW51bSBtdDc1MzFfY2xrX3NrZXcg ew0KKwlNVDc1MzFfQ0xLX1NLRVdfTk9fQ0hHID0gMCwNCisJTVQ3NTMxX0NMS19TS0VXX0RMWV8x MDBQUFMgPSAxLA0KKwlNVDc1MzFfQ0xLX1NLRVdfRExZXzIwMFBQUyA9IDIsDQorCU1UNzUzMV9D TEtfU0tFV19SRVZFUlNFID0gMywNCit9Ow0KKw0KIC8qIFJlZ2lzdGVyIGZvciBodyB0cmFwIHN0 YXR1cyAqLw0KICNkZWZpbmUgTVQ3NTMwX0hXVFJBUAkJCTB4NzgwMA0KICNkZWZpbmUgIEhXVFJB UF9YVEFMX01BU0sJCShCSVQoMTApIHwgQklUKDkpKQ0KQEAgLTI2Nyw2ICs0MjUsMTYgQEAgZW51 bSBtdDc1MzBfdmxhbl9wb3J0X2F0dHIgew0KICNkZWZpbmUgIEhXVFJBUF9YVEFMXzQwTUhaCQko QklUKDEwKSkNCiAjZGVmaW5lICBIV1RSQVBfWFRBTF8yME1IWgkJKEJJVCg5KSkNCiANCisjZGVm aW5lIE1UNzUzMV9IV1RSQVAJCQkweDc4MDANCisjZGVmaW5lICBIV1RSQVBfWFRBTF9GU0VMX01B U0sJCUJJVCg3KQ0KKyNkZWZpbmUgIEhXVFJBUF9YVEFMX0ZTRUxfMjVNSFoJCUJJVCg3KQ0KKyNk ZWZpbmUgIEhXVFJBUF9YVEFMX0ZTRUxfNDBNSFoJCTANCisvKiBVbmlxdWUgZmllbGRzIG9mIChN KUhXU1RSQVAgZm9yIE1UNzUzMSAqLw0KKyNkZWZpbmUgIFhUQUxfRlNFTF9TCQkJNw0KKyNkZWZp bmUgIFhUQUxfRlNFTF9NCQkJQklUKDcpDQorI2RlZmluZSAgUEhZX0VOCQkJCUJJVCg2KQ0KKyNk ZWZpbmUgIENIR19TVFJBUAkJCUJJVCg4KQ0KKw0KIC8qIFJlZ2lzdGVyIGZvciBodyB0cmFwIG1v ZGlmaWNhdGlvbiAqLw0KICNkZWZpbmUgTVQ3NTMwX01IV1RSQVAJCQkweDc4MDQNCiAjZGVmaW5l ICBNSFdUUkFQX1BIWTBfU0VMCQlCSVQoMjApDQpAQCAtMjgxLDE0ICs0NDksMzcgQEAgZW51bSBt dDc1MzBfdmxhbl9wb3J0X2F0dHIgew0KICNkZWZpbmUgTVQ3NTMwX1RPUF9TSUdfQ1RSTAkJMHg3 ODA4DQogI2RlZmluZSAgVE9QX1NJR19DVFJMX05PUk1BTAkJKEJJVCgxNykgfCBCSVQoMTYpKQ0K IA0KKyNkZWZpbmUgTVQ3NTMxX1RPUF9TSUdfU1IJCTB4NzgwYw0KKyNkZWZpbmUgIFBBRF9EVUFM X1NHTUlJX0VOCQlCSVQoMSkNCisjZGVmaW5lICBQQURfTUNNX1NNSV9FTgkJCUJJVCgwKQ0KKw0K ICNkZWZpbmUgTVQ3NTMwX0lPX0RSVl9DUgkJMHg3ODEwDQogI2RlZmluZSAgUDVfSU9fQ0xLX0RS Vih4KQkJKCh4KSAmIDB4MykNCiAjZGVmaW5lICBQNV9JT19EQVRBX0RSVih4KQkJKCgoeCkgJiAw eDMpIDw8IDQpDQogDQorI2RlZmluZSBNVDc1MzFfQ0hJUF9SRVYJCQkweDc4MUMNCisNCisjZGVm aW5lIE1UNzUzMV9QTExHUF9FTgkJCTB4NzgyMA0KKyNkZWZpbmUgIEVOX0NPUkVQTEwJCQlCSVQo MikNCisjZGVmaW5lICBTV19DTEtTVwkJCUJJVCgxKQ0KKyNkZWZpbmUgIFNXX1BMTEdQCQkJQklU KDApDQorDQogI2RlZmluZSBNVDc1MzBfUDZFQ1IJCQkweDc4MzANCiAjZGVmaW5lICBQNl9JTlRG X01PREVfTUFTSwkJMHgzDQogI2RlZmluZSAgUDZfSU5URl9NT0RFKHgpCQkoKHgpICYgMHgzKQ0K IA0KKyNkZWZpbmUgTVQ3NTMxX1BMTEdQX0NSMAkJMHg3OGE4DQorI2RlZmluZSAgUkdfQ09SRVBM TF9FTgkJCUJJVCgyMikNCisjZGVmaW5lICBSR19DT1JFUExMX1BPU0RJVl9TCQkyMw0KKyNkZWZp bmUgIFJHX0NPUkVQTExfUE9TRElWX00JCTB4MzgwMDAwMA0KKyNkZWZpbmUgIFJHX0NPUkVQTExf U0RNX1BDV19TCQkxDQorI2RlZmluZSAgUkdfQ09SRVBMTF9TRE1fUENXX00JCTB4M2ZmZmZlDQor I2RlZmluZSAgUkdfQ09SRVBMTF9TRE1fUENXX0NIRwkJQklUKDApDQorDQorLyogUmVnaXN0ZXJz IGZvciBSR01JSSBhbmQgU0dNSUkgUExMIGNsb2NrICovDQorI2RlZmluZSBNVDc1MzFfQU5BX1BM TEdQX0NSMgkJMHg3OGIwDQorI2RlZmluZSBNVDc1MzFfQU5BX1BMTEdQX0NSNQkJMHg3OGJjDQor DQogLyogUmVnaXN0ZXJzIGZvciBUUkdNSUkgb24gdGhlIGJvdGggc2lkZSAqLw0KICNkZWZpbmUg TVQ3NTMwX1RSR01JSV9SQ0tfQ1RSTAkJMHg3YTAwDQogI2RlZmluZSAgUlhfUlNUCQkJCUJJVCgz MSkNCkBAIC0zMjcsMTAgKzUxOCwyNSBAQCBlbnVtIG10NzUzMF92bGFuX3BvcnRfYXR0ciB7DQog I2RlZmluZSBNVDc1MzBfUDVSR01JSVRYQ1IJCTB4N2IwNA0KICNkZWZpbmUgIENTUl9SR01JSV9U WENfQ0ZHKHgpCQkoKHgpICYgMHgxZikNCiANCisvKiBSZWdpc3RlcnMgZm9yIEdQSU8gbW9kZSAq Lw0KKyNkZWZpbmUgTVQ3NTMxX0dQSU9fTU9ERTAJCTB4N2MwYw0KKyNkZWZpbmUgIE1UNzUzMV9H UElPMF9NQVNLCQlHRU5NQVNLKDMsIDApDQorI2RlZmluZSAgTVQ3NTMxX0dQSU8wX0lOVEVSUlVQ VAkJMQ0KKw0KKyNkZWZpbmUgTVQ3NTMxX0dQSU9fTU9ERTEJCTB4N2MxMA0KKyNkZWZpbmUgIE1U NzUzMV9HUElPMTFfUkdfUlhEMl9NQVNLCUdFTk1BU0soMTUsIDEyKQ0KKyNkZWZpbmUgIE1UNzUz MV9FWFRfUF9NRENfMTEJCSgyIDw8IDEyKQ0KKyNkZWZpbmUgIE1UNzUzMV9HUElPMTJfUkdfUlhE M19NQVNLCUdFTk1BU0soMTksIDE2KQ0KKyNkZWZpbmUgIE1UNzUzMV9FWFRfUF9NRElPXzEyCQko MiA8PCAxNikNCisNCiAjZGVmaW5lIE1UNzUzMF9DUkVWCQkJMHg3ZmZjDQogI2RlZmluZSAgQ0hJ UF9OQU1FX1NISUZUCQkxNg0KICNkZWZpbmUgIE1UNzUzMF9JRAkJCTB4NzUzMA0KIA0KKyNkZWZp bmUgTVQ3NTMxX0NSRVYJCQkweDc4MUMNCisjZGVmaW5lICBDSElQX1JFVl9NCQkJMHgwZg0KKyNk ZWZpbmUgIE1UNzUzMV9JRAkJCTB4NzUzMQ0KKw0KIC8qIFJlZ2lzdGVycyBmb3IgY29yZSBQTEwg YWNjZXNzIHRocm91Z2ggbW1kIGluZGlyZWN0ICovDQogI2RlZmluZSBDT1JFX1BMTF9HUk9VUDIJ CQkweDQwMQ0KICNkZWZpbmUgIFJHX1NZU1BMTF9FTl9OT1JNQUwJCUJJVCgxNSkNCkBAIC0zNDcs NiArNTUzLDEwIEBAIGVudW0gbXQ3NTMwX3ZsYW5fcG9ydF9hdHRyIHsNCiAjZGVmaW5lICBSR19T WVNQTExfRERTRkJLX0VOCQlCSVQoMTIpDQogI2RlZmluZSAgUkdfU1lTUExMX0JJQVNfRU4JCUJJ VCgxMSkNCiAjZGVmaW5lICBSR19TWVNQTExfQklBU19MUEZfRU4JCUJJVCgxMCkNCisjZGVmaW5l ICBNVDc1MzFfUEhZX1BMTF9PRkYJCUJJVCg1KQ0KKyNkZWZpbmUgIE1UNzUzMV9QSFlfUExMX0JZ UEFTU19NT0RFCUJJVCg0KQ0KKw0KKyNkZWZpbmUgTVQ3NTNYX0NUUkxfUEhZX0FERFIJCTANCiAN CiAjZGVmaW5lIENPUkVfUExMX0dST1VQNQkJCTB4NDA0DQogI2RlZmluZSAgUkdfTENERFNfUENX X05DUE8xKHgpCQkoKHgpICYgMHhmZmZmKQ0KQEAgLTQyNSw2ICs2MzUsNyBAQCBlbnVtIHA1X2lu dGVyZmFjZV9zZWxlY3Qgew0KIAlQNV9JTlRGX1NFTF9QSFlfUDAsDQogCVA1X0lOVEZfU0VMX1BI WV9QNCwNCiAJUDVfSU5URl9TRUxfR01BQzUsDQorCVA1X0lOVEZfU0VMX0dNQUM1X1NHTUlJLA0K IH07DQogDQogc3RhdGljIGNvbnN0IGNoYXIgKnA1X2ludGZfbW9kZXModW5zaWduZWQgaW50IHA1 X2ludGVyZmFjZSkNCkBAIC00MzgsNiArNjQ5LDggQEAgc3RhdGljIGNvbnN0IGNoYXIgKnA1X2lu dGZfbW9kZXModW5zaWduZWQgaW50IHA1X2ludGVyZmFjZSkNCiAJCXJldHVybiAiUEhZIFA0IjsN CiAJY2FzZSBQNV9JTlRGX1NFTF9HTUFDNToNCiAJCXJldHVybiAiR01BQzUiOw0KKwljYXNlIFA1 X0lOVEZfU0VMX0dNQUM1X1NHTUlJOg0KKwkJcmV0dXJuICJHTUFDNV9TR01JSSI7DQogCWRlZmF1 bHQ6DQogCQlyZXR1cm4gInVua25vd24iOw0KIAl9DQpAQCAtNDU4LDYgKzY3MSwxMCBAQCBzdGF0 aWMgY29uc3QgY2hhciAqcDVfaW50Zl9tb2Rlcyh1bnNpZ25lZCBpbnQgcDVfaW50ZXJmYWNlKQ0K ICAqCQkJTUFDIHBvcnQNCiAgKiBAbWFjX3BvcnRfY29uZmlnOglIb2xkaW5nIHRoZSB3YXkgc2V0 dGluZyB1cCB0aGUgUEhZIGF0dHJpYnV0ZSB0byBhDQogICoJCQljZXJ0YWluIE1BQyBwb3J0DQor ICogQG1hY19wY3NfYW5fcmVzdGFydAlIb2xkaW5nIHRoZSB3YXkgcmVzdGFydGluZyBQQ1MgYXV0 b25lZ290aWF0aW9uIGZvciBhDQorICoJCQljZXJ0YWluIE1BQyBwb3J0DQorICogQG1hY19wY3Nf bGlua191cDoJSG9sZGluZyB0aGUgd2F5IHNldHRpbmcgdXAgdGhlIFBIWSBhdHRyaWJ1dGUgdG8g dGhlIHBjcw0KKyAqCQkJb2YgdGhlIGNlcnRhaW4gTUFDIHBvcnQNCiAgKi8NCiBzdHJ1Y3QgbXQ3 NTN4X2luZm8gew0KIAllbnVtIG10NzUzeF9pZCBpZDsNCkBAIC00NjYsNiArNjgzLDcgQEAgc3Ry dWN0IG10NzUzeF9pbmZvIHsNCiAJaW50ICgqcGh5X3JlYWQpKHN0cnVjdCBkc2Ffc3dpdGNoICpk cywgaW50IHBvcnQsIGludCByZWdudW0pOw0KIAlpbnQgKCpwaHlfd3JpdGUpKHN0cnVjdCBkc2Ff c3dpdGNoICpkcywgaW50IHBvcnQsIGludCByZWdudW0sIHUxNiB2YWwpOw0KIAlpbnQgKCpwYWRf c2V0dXApKHN0cnVjdCBkc2Ffc3dpdGNoICpkcywgcGh5X2ludGVyZmFjZV90IGludGVyZmFjZSk7 DQorCWludCAoKmNwdV9wb3J0X2NvbmZpZykoc3RydWN0IGRzYV9zd2l0Y2ggKmRzLCBpbnQgcG9y dCk7DQogCWJvb2wgKCpwaHlfbW9kZV9zdXBwb3J0ZWQpKHN0cnVjdCBkc2Ffc3dpdGNoICpkcywg aW50IHBvcnQsDQogCQkJCSAgIGNvbnN0IHN0cnVjdCBwaHlsaW5rX2xpbmtfc3RhdGUgKnN0YXRl KTsNCiAJdm9pZCAoKm1hY19wb3J0X3ZhbGlkYXRlKShzdHJ1Y3QgZHNhX3N3aXRjaCAqZHMsIGlu dCBwb3J0LA0KQEAgLTQ3NSw2ICs2OTMsMTAgQEAgc3RydWN0IG10NzUzeF9pbmZvIHsNCiAJaW50 ICgqbWFjX3BvcnRfY29uZmlnKShzdHJ1Y3QgZHNhX3N3aXRjaCAqZHMsIGludCBwb3J0LA0KIAkJ CSAgICAgICB1bnNpZ25lZCBpbnQgbW9kZSwNCiAJCQkgICAgICAgcGh5X2ludGVyZmFjZV90IGlu dGVyZmFjZSk7DQorCXZvaWQgKCptYWNfcGNzX2FuX3Jlc3RhcnQpKHN0cnVjdCBkc2Ffc3dpdGNo ICpkcywgaW50IHBvcnQpOw0KKwl2b2lkICgqbWFjX3Bjc19saW5rX3VwKShzdHJ1Y3QgZHNhX3N3 aXRjaCAqZHMsIGludCBwb3J0LA0KKwkJCQl1bnNpZ25lZCBpbnQgbW9kZSwgcGh5X2ludGVyZmFj ZV90IGludGVyZmFjZSwNCisJCQkJaW50IHNwZWVkLCBpbnQgZHVwbGV4KTsNCiB9Ow0KIA0KIC8q IHN0cnVjdCBtdDc1MzBfcHJpdiAtCVRoaXMgaXMgdGhlIG1haW4gZGF0YSBzdHJ1Y3R1cmUgZm9y IGhvbGRpbmcgdGhlIHN0YXRlDQotLSANCjIuMTcuMQ0K From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-12.8 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id B0E11C433E4 for ; Tue, 18 Aug 2020 07:25:10 +0000 (UTC) Received: from merlin.infradead.org (merlin.infradead.org [205.233.59.134]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 63F2520786 for ; Tue, 18 Aug 2020 07:25:10 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="tiFNIwU6"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="BXQ1jqGf" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 63F2520786 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=mediatek.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-mediatek-bounces+linux-mediatek=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=merlin.20170209; h=Sender:Content-Transfer-Encoding: Content-Type:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To:Message-ID:Date: Subject:To:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=eDAy/6M1z9naMKHUlRRt7sPwrUdkEgipyhIV1DXsxBs=; b=tiFNIwU6e5kE7/rLfMX8WY1Yn gMAgDAq8sqkmrPdvT2mixD5A8kYudVJ7YguPPrMI9BcHG/pDGvzLG4OYsJYed5GU6zS2nyUV67Mk7 Z4A/ILXY3f7wY/gHUBc4jzgIDRTw5E4548NjVuvqVGyrgEB/g0I61RV9EaR94yBSUYZBVbNjM+RVr DL5aClnS0bWO2lIfNu78Om2n/OSPjdLSVx7Yde+b2zGvnhpEvXi5pzE4/KJYYT9pkGf5IU9LOOowN H4u3KPZBPu5wxNZ7VzuatFA9itqkm+fZ6skftbaL4ddtpfdClEuCBhPNJx5LLoQ88f2V5RDMFNirs bUiLoucBg==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1k7vzM-0005OV-MB; Tue, 18 Aug 2020 07:24:56 +0000 Received: from mailgw01.mediatek.com ([216.200.240.184]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1k7vzF-0005Ir-Ud for linux-mediatek@lists.infradead.org; Tue, 18 Aug 2020 07:24:53 +0000 X-UUID: 683bcf55cf834c8896f2d0120a0247e7-20200817 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=agOiGUWOjxDew40igvpbtiYlL977voFJJ+jPDiFQ9G0=; b=BXQ1jqGfqH9ansVgxDUDSr8s0ofSpQUJxu6NjURVEbGKqIrZmm/pav7RG5/GELtFf69X7PNbawvRYJq8TU0D6cSq8vN5axRf7hvb8tCgRDCeAi0tO7EwwP5CwboRUzK6fvUDzwVnnk3Q90rhishjwKJ06A0enI8kO8o7uSIA3V8=; X-UUID: 683bcf55cf834c8896f2d0120a0247e7-20200817 Received: from mtkcas66.mediatek.inc [(172.29.193.44)] by mailgw01.mediatek.com (envelope-from ) (musrelay.mediatek.com ESMTP with TLS) with ESMTP id 853532659; Mon, 17 Aug 2020 23:21:38 -0800 Received: from mtkmbs07n1.mediatek.inc (172.21.101.16) by MTKMBS62N1.mediatek.inc (172.29.193.41) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Tue, 18 Aug 2020 00:14:40 -0700 Received: from mtkcas07.mediatek.inc (172.21.101.84) by mtkmbs07n1.mediatek.inc (172.21.101.16) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Tue, 18 Aug 2020 15:14:38 +0800 Received: from mtksdccf07.mediatek.inc (172.21.84.99) by mtkcas07.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Tue, 18 Aug 2020 15:14:39 +0800 From: Landen Chao To: , , , , , Subject: [PATCH net-next v2 5/7] net: dsa: mt7530: Add the support of MT7531 switch Date: Tue, 18 Aug 2020 15:14:10 +0800 Message-ID: X-Mailer: git-send-email 2.18.0 In-Reply-To: References: MIME-Version: 1.0 X-MTK: N X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200818_032450_282477_595572E1 X-CRM114-Status: GOOD ( 19.80 ) X-BeenThere: linux-mediatek@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: devicetree@vger.kernel.org, dqfext@gmail.com, frank-w@public-files.de, netdev@vger.kernel.org, sean.wang@mediatek.com, linux-kernel@vger.kernel.org, opensource@vdorst.com, linux-mediatek@lists.infradead.org, Landen Chao , davem@davemloft.net Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "Linux-mediatek" Errors-To: linux-mediatek-bounces+linux-mediatek=archiver.kernel.org@lists.infradead.org Add new support for MT7531: MT7531 is the next generation of MT7530. It is also a 7-ports switch with 5 giga embedded phys, 2 cpu ports, and the same MAC logic of MT7530. Cpu port 6 only supports SGMII interface. Cpu port 5 supports either RGMII or SGMII in different HW sku. Due to SGMII interface support, pll, and pad setting are different from MT7530. This patch adds different initial setting, and SGMII phylink handlers of MT7531. MT7531 SGMII interface can be configured in following mode: - 'SGMII AN mode' with in-band negotiation capability which is compatible with PHY_INTERFACE_MODE_SGMII. - 'SGMII force mode' without in-bnad negotiation which is compatible with 10B/8B encoding of PHY_INTERFACE_MODE_1000BASEX with fixed full-duplex and fixed pause. - 2.5 times faster clocked 'SGMII force mode' without in-bnad negotiation which is compatible with 10B/8B encoding of PHY_INTERFACE_MODE_2500BASEX with fixed full-duplex and fixed pause. Signed-off-by: Landen Chao Signed-off-by: Sean Wang --- drivers/net/dsa/Kconfig | 6 +- drivers/net/dsa/mt7530.c | 908 +++++++++++++++++++++++++++++++++++++-- drivers/net/dsa/mt7530.h | 222 ++++++++++ 3 files changed, 1109 insertions(+), 27 deletions(-) diff --git a/drivers/net/dsa/Kconfig b/drivers/net/dsa/Kconfig index 66784412b683..e77781d791a9 100644 --- a/drivers/net/dsa/Kconfig +++ b/drivers/net/dsa/Kconfig @@ -33,12 +33,12 @@ config NET_DSA_LANTIQ_GSWIP the xrx200 / VR9 SoC. config NET_DSA_MT7530 - tristate "MediaTek MT7530 and MT7621 Ethernet switch support" + tristate "MediaTek MT753x and MT7621 Ethernet switch support" depends on NET_DSA select NET_DSA_TAG_MTK help - This enables support for the MediaTek MT7530 and MT7621 Ethernet - switch chip. + This enables support for the MediaTek MT7530, MT7531, and MT7621 + Ethernet switch chips. config NET_DSA_MV88E6060 tristate "Marvell 88E6060 ethernet switch chip support" diff --git a/drivers/net/dsa/mt7530.c b/drivers/net/dsa/mt7530.c index d30b41725b4d..a63a319089f7 100644 --- a/drivers/net/dsa/mt7530.c +++ b/drivers/net/dsa/mt7530.c @@ -233,6 +233,12 @@ mt7530_write(struct mt7530_priv *priv, u32 reg, u32 val) mutex_unlock(&bus->mdio_lock); } +static u32 +_mt7530_unlocked_read(struct mt7530_dummy_poll *p) +{ + return mt7530_mii_read(p->priv, p->reg); +} + static u32 _mt7530_read(struct mt7530_dummy_poll *p) { @@ -483,6 +489,108 @@ mt7530_pad_clk_setup(struct dsa_switch *ds, phy_interface_t interface) return 0; } +static bool mt7531_dual_sgmii_supported(struct mt7530_priv *priv) +{ + u32 val; + + val = mt7530_read(priv, MT7531_TOP_SIG_SR); + + return (val & PAD_DUAL_SGMII_EN) != 0; +} + +static int +mt7531_pad_setup(struct dsa_switch *ds, phy_interface_t interface) +{ + struct mt7530_priv *priv = ds->priv; + u32 val; + u32 top_sig; + u32 hwstrap; + u32 xtal; + + if (mt7531_dual_sgmii_supported(priv)) + return 0; + + val = mt7530_read(priv, MT7531_CREV); + top_sig = mt7530_read(priv, MT7531_TOP_SIG_SR); + hwstrap = mt7530_read(priv, MT7531_HWTRAP); + if ((val & CHIP_REV_M) > 0) + xtal = (top_sig & PAD_MCM_SMI_EN) ? HWTRAP_XTAL_FSEL_40MHZ : + HWTRAP_XTAL_FSEL_25MHZ; + else + xtal = hwstrap & HWTRAP_XTAL_FSEL_MASK; + + /* Step 1 : Disable MT7531 COREPLL */ + val = mt7530_read(priv, MT7531_PLLGP_EN); + val &= ~EN_COREPLL; + mt7530_write(priv, MT7531_PLLGP_EN, val); + + /* Step 2: switch to XTAL output */ + val = mt7530_read(priv, MT7531_PLLGP_EN); + val |= SW_CLKSW; + mt7530_write(priv, MT7531_PLLGP_EN, val); + + val = mt7530_read(priv, MT7531_PLLGP_CR0); + val &= ~RG_COREPLL_EN; + mt7530_write(priv, MT7531_PLLGP_CR0, val); + + /* Step 3: disable PLLGP and enable program PLLGP */ + val = mt7530_read(priv, MT7531_PLLGP_EN); + val |= SW_PLLGP; + mt7530_write(priv, MT7531_PLLGP_EN, val); + + /* Step 4: program COREPLL output frequency to 500MHz */ + val = mt7530_read(priv, MT7531_PLLGP_CR0); + val &= ~RG_COREPLL_POSDIV_M; + val |= 2 << RG_COREPLL_POSDIV_S; + mt7530_write(priv, MT7531_PLLGP_CR0, val); + usleep_range(25, 35); + + switch (xtal) { + case HWTRAP_XTAL_FSEL_25MHZ: + val = mt7530_read(priv, MT7531_PLLGP_CR0); + val &= ~RG_COREPLL_SDM_PCW_M; + val |= 0x140000 << RG_COREPLL_SDM_PCW_S; + mt7530_write(priv, MT7531_PLLGP_CR0, val); + break; + case HWTRAP_XTAL_FSEL_40MHZ: + val = mt7530_read(priv, MT7531_PLLGP_CR0); + val &= ~RG_COREPLL_SDM_PCW_M; + val |= 0x190000 << RG_COREPLL_SDM_PCW_S; + mt7530_write(priv, MT7531_PLLGP_CR0, val); + break; + }; + + /* Set feedback divide ratio update signal to high */ + val = mt7530_read(priv, MT7531_PLLGP_CR0); + val |= RG_COREPLL_SDM_PCW_CHG; + mt7530_write(priv, MT7531_PLLGP_CR0, val); + /* Wait for at least 16 XTAL clocks */ + usleep_range(10, 20); + + /* Step 5: set feedback divide ratio update signal to low */ + val = mt7530_read(priv, MT7531_PLLGP_CR0); + val &= ~RG_COREPLL_SDM_PCW_CHG; + mt7530_write(priv, MT7531_PLLGP_CR0, val); + + /* Enable 325M clock for SGMII */ + mt7530_write(priv, MT7531_ANA_PLLGP_CR5, 0xad0000); + + /* Enable 250SSC clock for RGMII */ + mt7530_write(priv, MT7531_ANA_PLLGP_CR2, 0x4f40000); + + /* Step 6: Enable MT7531 PLL */ + val = mt7530_read(priv, MT7531_PLLGP_CR0); + val |= RG_COREPLL_EN; + mt7530_write(priv, MT7531_PLLGP_CR0, val); + + val = mt7530_read(priv, MT7531_PLLGP_EN); + val |= EN_COREPLL; + mt7530_write(priv, MT7531_PLLGP_EN, val); + usleep_range(25, 35); + + return 0; +} + static void mt7530_mib_reset(struct dsa_switch *ds) { @@ -507,6 +615,217 @@ static int mt7530_phy_write(struct dsa_switch *ds, int port, int regnum, return mdiobus_write_nested(priv->bus, port, regnum, val); } +static int +mt7531_ind_c45_phy_read(struct mt7530_priv *priv, int port, int devad, + int regnum) +{ + struct mii_bus *bus = priv->bus; + struct mt7530_dummy_poll p; + u32 reg, val; + int ret; + + INIT_MT7530_DUMMY_POLL(&p, priv, MT7531_PHY_IAC); + + mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED); + + ret = readx_poll_timeout(_mt7530_unlocked_read, &p, val, + !(val & MT7531_PHY_ACS_ST), 20, 100000); + if (ret < 0) { + dev_err(priv->dev, "poll timeout\n"); + goto out; + } + + reg = MT7531_MDIO_CL45_ADDR | MT7531_MDIO_PHY_ADDR(port) | + MT7531_MDIO_DEV_ADDR(devad) | regnum; + mt7530_mii_write(priv, MT7531_PHY_IAC, reg | MT7531_PHY_ACS_ST); + + ret = readx_poll_timeout(_mt7530_unlocked_read, &p, val, + !(val & MT7531_PHY_ACS_ST), 20, 100000); + if (ret < 0) { + dev_err(priv->dev, "poll timeout\n"); + goto out; + } + + reg = MT7531_MDIO_CL45_READ | MT7531_MDIO_PHY_ADDR(port) | + MT7531_MDIO_DEV_ADDR(devad); + mt7530_mii_write(priv, MT7531_PHY_IAC, reg | MT7531_PHY_ACS_ST); + + ret = readx_poll_timeout(_mt7530_unlocked_read, &p, val, + !(val & MT7531_PHY_ACS_ST), 20, 100000); + if (ret < 0) { + dev_err(priv->dev, "poll timeout\n"); + goto out; + } + + ret = val & MT7531_MDIO_RW_DATA_MASK; +out: + mutex_unlock(&bus->mdio_lock); + + return ret; +} + +static int +mt7531_ind_c45_phy_write(struct mt7530_priv *priv, int port, int devad, + int regnum, u32 data) +{ + struct mii_bus *bus = priv->bus; + struct mt7530_dummy_poll p; + u32 val, reg; + int ret; + + INIT_MT7530_DUMMY_POLL(&p, priv, MT7531_PHY_IAC); + + mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED); + + ret = readx_poll_timeout(_mt7530_unlocked_read, &p, val, + !(val & MT7531_PHY_ACS_ST), 20, 100000); + if (ret < 0) { + dev_err(priv->dev, "poll timeout\n"); + goto out; + } + + reg = MT7531_MDIO_CL45_ADDR | MT7531_MDIO_PHY_ADDR(port) | + MT7531_MDIO_DEV_ADDR(devad) | regnum; + mt7530_mii_write(priv, MT7531_PHY_IAC, reg | MT7531_PHY_ACS_ST); + + ret = readx_poll_timeout(_mt7530_unlocked_read, &p, val, + !(val & MT7531_PHY_ACS_ST), 20, 100000); + if (ret < 0) { + dev_err(priv->dev, "poll timeout\n"); + goto out; + } + + reg = MT7531_MDIO_CL45_WRITE | MT7531_MDIO_PHY_ADDR(port) | + MT7531_MDIO_DEV_ADDR(devad) | data; + mt7530_mii_write(priv, MT7531_PHY_IAC, reg | MT7531_PHY_ACS_ST); + + ret = readx_poll_timeout(_mt7530_unlocked_read, &p, val, + !(val & MT7531_PHY_ACS_ST), 20, 100000); + if (ret < 0) { + dev_err(priv->dev, "poll timeout\n"); + goto out; + } + +out: + mutex_unlock(&bus->mdio_lock); + + return ret; +} + +static int +mt7531_ind_c22_phy_read(struct mt7530_priv *priv, int port, int regnum) +{ + struct mii_bus *bus = priv->bus; + struct mt7530_dummy_poll p; + int ret; + u32 val; + + INIT_MT7530_DUMMY_POLL(&p, priv, MT7531_PHY_IAC); + + mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED); + + ret = readx_poll_timeout(_mt7530_unlocked_read, &p, val, + !(val & MT7531_PHY_ACS_ST), 20, 100000); + if (ret < 0) { + dev_err(priv->dev, "poll timeout\n"); + goto out; + } + + val = MT7531_MDIO_CL22_READ | MT7531_MDIO_PHY_ADDR(port) | + MT7531_MDIO_REG_ADDR(regnum); + + mt7530_mii_write(priv, MT7531_PHY_IAC, val | MT7531_PHY_ACS_ST); + + ret = readx_poll_timeout(_mt7530_unlocked_read, &p, val, + !(val & MT7531_PHY_ACS_ST), 20, 100000); + if (ret < 0) { + dev_err(priv->dev, "poll timeout\n"); + goto out; + } + + ret = val & MT7531_MDIO_RW_DATA_MASK; +out: + mutex_unlock(&bus->mdio_lock); + + return ret; +} + +static int +mt7531_ind_c22_phy_write(struct mt7530_priv *priv, int port, int regnum, + u16 data) +{ + struct mii_bus *bus = priv->bus; + struct mt7530_dummy_poll p; + int ret; + u32 reg; + + INIT_MT7530_DUMMY_POLL(&p, priv, MT7531_PHY_IAC); + + mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED); + + ret = readx_poll_timeout(_mt7530_unlocked_read, &p, reg, + !(reg & MT7531_PHY_ACS_ST), 20, 100000); + if (ret < 0) { + dev_err(priv->dev, "poll timeout\n"); + goto out; + } + + reg = MT7531_MDIO_CL22_WRITE | MT7531_MDIO_PHY_ADDR(port) | + MT7531_MDIO_REG_ADDR(regnum) | data; + + mt7530_mii_write(priv, MT7531_PHY_IAC, reg | MT7531_PHY_ACS_ST); + + ret = readx_poll_timeout(_mt7530_unlocked_read, &p, reg, + !(reg & MT7531_PHY_ACS_ST), 20, 100000); + if (ret < 0) { + dev_err(priv->dev, "poll timeout\n"); + goto out; + } + +out: + mutex_unlock(&bus->mdio_lock); + + return ret; +} + +static int +mt7531_ind_phy_read(struct dsa_switch *ds, int port, int regnum) +{ + struct mt7530_priv *priv = ds->priv; + int devad; + int ret; + + if (regnum & MII_ADDR_C45) { + devad = (regnum >> MII_DEVADDR_C45_SHIFT) & 0x1f; + ret = mt7531_ind_c45_phy_read(priv, port, devad, + regnum & MII_REGADDR_C45_MASK); + } else { + ret = mt7531_ind_c22_phy_read(priv, port, regnum); + } + + return ret; +} + +static int +mt7531_ind_phy_write(struct dsa_switch *ds, int port, int regnum, + u16 data) +{ + struct mt7530_priv *priv = ds->priv; + int devad; + int ret; + + if (regnum & MII_ADDR_C45) { + devad = (regnum >> MII_DEVADDR_C45_SHIFT) & 0x1f; + ret = mt7531_ind_c45_phy_write(priv, port, devad, + regnum & MII_REGADDR_C45_MASK, + data); + } else { + ret = mt7531_ind_c22_phy_write(priv, port, regnum, data); + } + + return ret; +} + static void mt7530_get_strings(struct dsa_switch *ds, int port, u32 stringset, uint8_t *data) @@ -623,9 +942,14 @@ static void mt7530_setup_port5(struct dsa_switch *ds, phy_interface_t interface) } static int -mt7530_cpu_port_enable(struct mt7530_priv *priv, - int port) +mt753x_cpu_port_enable(struct dsa_switch *ds, int port) { + struct mt7530_priv *priv = ds->priv; + + /* Setup max capability of CPU port at first */ + if (priv->info->cpu_port_config) + priv->info->cpu_port_config(ds, port); + /* Enable Mediatek header mode on the cpu port */ mt7530_write(priv, MT7530_PVC_P(port), PORT_SPEC_TAG); @@ -638,7 +962,7 @@ mt7530_cpu_port_enable(struct mt7530_priv *priv, mt7530_rmw(priv, MT7530_MFC, CPU_MASK, CPU_EN | CPU_PORT(port)); /* CPU port gets connected to all user ports of - * the switch + * the switch. */ mt7530_write(priv, MT7530_PCR_P(port), PCR_MATRIX(dsa_user_ports(priv->ds))); @@ -1132,27 +1456,42 @@ mt7530_port_vlan_del(struct dsa_switch *ds, int port, return 0; } -static int mt7530_port_mirror_add(struct dsa_switch *ds, int port, +static int mt753x_mirror_port_get(unsigned int id, u32 val) +{ + return (id == ID_MT7531) ? MT7531_MIRROR_PORT_GET(val) : + MIRROR_PORT(val); +} + +static int mt753x_mirror_port_set(unsigned int id, u32 val) +{ + return (id == ID_MT7531) ? MT7531_MIRROR_PORT_SET(val) : + MIRROR_PORT(val); +} + +static int mt753x_port_mirror_add(struct dsa_switch *ds, int port, struct dsa_mall_mirror_tc_entry *mirror, bool ingress) { struct mt7530_priv *priv = ds->priv; + int monitor_port; u32 val; /* Check for existent entry */ if ((ingress ? priv->mirror_rx : priv->mirror_tx) & BIT(port)) return -EEXIST; - val = mt7530_read(priv, MT7530_MFC); + val = mt7530_read(priv, MT753X_MIRROR_REG(priv->id)); /* MT7530 only supports one monitor port */ - if (val & MIRROR_EN && MIRROR_PORT(val) != mirror->to_local_port) + monitor_port = mt753x_mirror_port_get(priv->id, val); + if (val & MT753X_MIRROR_EN(priv->id) && + monitor_port != mirror->to_local_port) return -EEXIST; - val |= MIRROR_EN; - val &= ~MIRROR_MASK; - val |= mirror->to_local_port; - mt7530_write(priv, MT7530_MFC, val); + val |= MT753X_MIRROR_EN(priv->id); + val &= ~MT753X_MIRROR_MASK(priv->id); + val |= mt753x_mirror_port_set(priv->id, mirror->to_local_port); + mt7530_write(priv, MT753X_MIRROR_REG(priv->id), val); val = mt7530_read(priv, MT7530_PCR_P(port)); if (ingress) { @@ -1167,7 +1506,7 @@ static int mt7530_port_mirror_add(struct dsa_switch *ds, int port, return 0; } -static void mt7530_port_mirror_del(struct dsa_switch *ds, int port, +static void mt753x_port_mirror_del(struct dsa_switch *ds, int port, struct dsa_mall_mirror_tc_entry *mirror) { struct mt7530_priv *priv = ds->priv; @@ -1184,9 +1523,9 @@ static void mt7530_port_mirror_del(struct dsa_switch *ds, int port, mt7530_write(priv, MT7530_PCR_P(port), val); if (!priv->mirror_rx && !priv->mirror_tx) { - val = mt7530_read(priv, MT7530_MFC); - val &= ~MIRROR_EN; - mt7530_write(priv, MT7530_MFC, val); + val = mt7530_read(priv, MT753X_MIRROR_REG(priv->id)); + val &= ~MT753X_MIRROR_EN(priv->id); + mt7530_write(priv, MT753X_MIRROR_REG(priv->id), val); } } @@ -1293,7 +1632,7 @@ mt7530_setup(struct dsa_switch *ds) PCR_MATRIX_CLR); if (dsa_is_cpu_port(ds, i)) - mt7530_cpu_port_enable(priv, i); + mt753x_cpu_port_enable(ds, i); else mt7530_port_disable(ds, i); @@ -1351,6 +1690,118 @@ mt7530_setup(struct dsa_switch *ds) return 0; } +static int +mt7531_setup(struct dsa_switch *ds) +{ + struct mt7530_priv *priv = ds->priv; + struct mt7530_dummy_poll p; + u32 val, id; + int ret, i; + + /* Reset whole chip through gpio pin or memory-mapped registers for + * different type of hardware + */ + if (priv->mcm) { + reset_control_assert(priv->rstc); + usleep_range(1000, 1100); + reset_control_deassert(priv->rstc); + } else { + gpiod_set_value_cansleep(priv->reset, 0); + usleep_range(1000, 1100); + gpiod_set_value_cansleep(priv->reset, 1); + } + + /* Waiting for MT7530 got to stable */ + INIT_MT7530_DUMMY_POLL(&p, priv, MT7530_HWTRAP); + ret = readx_poll_timeout(_mt7530_read, &p, val, val != 0, + 20, 1000000); + if (ret < 0) { + dev_err(priv->dev, "reset timeout\n"); + return ret; + } + + id = mt7530_read(priv, MT7531_CREV); + id >>= CHIP_NAME_SHIFT; + + if (id != MT7531_ID) { + dev_err(priv->dev, "chip %x can't be supported\n", id); + return -ENODEV; + } + + /* Reset the switch through internal reset */ + mt7530_write(priv, MT7530_SYS_CTRL, + SYS_CTRL_PHY_RST | SYS_CTRL_SW_RST | + SYS_CTRL_REG_RST); + + if (mt7531_dual_sgmii_supported(priv)) { + priv->p5_intf_sel = P5_INTF_SEL_GMAC5_SGMII; + + /* Let ds->slave_mii_bus be able to access external phy. */ + mt7530_rmw(priv, MT7531_GPIO_MODE1, MT7531_GPIO11_RG_RXD2_MASK, + MT7531_EXT_P_MDC_11); + mt7530_rmw(priv, MT7531_GPIO_MODE1, MT7531_GPIO12_RG_RXD3_MASK, + MT7531_EXT_P_MDIO_12); + } else { + priv->p5_intf_sel = P5_INTF_SEL_GMAC5; + } + dev_dbg(ds->dev, "P5 support %s interface\n", + p5_intf_modes(priv->p5_intf_sel)); + + mt7530_rmw(priv, MT7531_GPIO_MODE0, MT7531_GPIO0_MASK, + MT7531_GPIO0_INTERRUPT); + + /* Let phylink decide the interface later. */ + priv->p5_interface = PHY_INTERFACE_MODE_NA; + priv->p6_interface = PHY_INTERFACE_MODE_NA; + + /* Enable PHY core PLL, since phy_device has not yet been created + * provided for phy_[read,write]_mmd_indirect is called, we provide + * our own mt7531_ind_mmd_phy_[read,write] to complete this + * function. + */ + val = mt7531_ind_c45_phy_read(priv, MT753X_CTRL_PHY_ADDR, + MDIO_MMD_VEND2, CORE_PLL_GROUP4); + val |= MT7531_PHY_PLL_BYPASS_MODE; + val &= ~MT7531_PHY_PLL_OFF; + mt7531_ind_c45_phy_write(priv, MT753X_CTRL_PHY_ADDR, MDIO_MMD_VEND2, + CORE_PLL_GROUP4, val); + + /* BPDU to CPU port */ + mt7530_rmw(priv, MT7531_CFC, MT7531_CPU_PMAP_MASK, + BIT(MT7530_CPU_PORT)); + mt7530_rmw(priv, MT753X_BPC, MT753X_BPDU_PORT_FW_MASK, + MT753X_BPDU_CPU_ONLY); + + /* Enable and reset MIB counters */ + mt7530_mib_reset(ds); + + for (i = 0; i < MT7530_NUM_PORTS; i++) { + /* Disable forwarding by default on all ports */ + mt7530_rmw(priv, MT7530_PCR_P(i), PCR_MATRIX_MASK, + PCR_MATRIX_CLR); + + mt7530_set(priv, MT7531_DBG_CNT(i), MT7531_DIS_CLR); + + if (dsa_is_cpu_port(ds, i)) + mt753x_cpu_port_enable(ds, i); + else + mt7530_port_disable(ds, i); + + /* Enable consistent egress tag */ + mt7530_rmw(priv, MT7530_PVC_P(i), PVC_EG_TAG_MASK, + PVC_EG_TAG(MT7530_VLAN_EG_CONSISTENT)); + } + + ds->configure_vlan_while_not_filtering = true; + + /* Flush the FDB table */ + ret = mt7530_fdb_cmd(priv, MT7530_FDB_FLUSH, NULL); + if (ret < 0) + return ret; + + return 0; +} + static bool mt7530_phy_mode_supported(struct dsa_switch *ds, int port, const struct phylink_link_state *state) @@ -1389,6 +1840,47 @@ mt7530_phy_mode_supported(struct dsa_switch *ds, int port, return false; } +static bool mt7531_is_rgmii_port(struct mt7530_priv *priv, u32 port) +{ + return (port == 5) && (priv->p5_intf_sel != P5_INTF_SEL_GMAC5_SGMII); +} + +static bool +mt7531_phy_supported(struct dsa_switch *ds, int port, + const struct phylink_link_state *state) +{ + struct mt7530_priv *priv = ds->priv; + + switch (port) { + case 0: /* Internal phy */ + case 1: + case 2: + case 3: + case 4: + if (state->interface != PHY_INTERFACE_MODE_GMII) + goto unsupported; + break; + case 5: /* 2nd cpu port supports either rgmii or sgmii/8023z */ + if (mt7531_is_rgmii_port(priv, port)) + return phy_interface_mode_is_rgmii(state->interface); + fallthrough; + case 6: /* 1st cpu port supports sgmii/8023z only */ + if (state->interface != PHY_INTERFACE_MODE_SGMII && + !phy_interface_mode_is_8023z(state->interface)) + goto unsupported; + break; + default: + dev_err(priv->dev, "%s: unsupported port: %i\n", __func__, + port); + goto unsupported; + } + + return true; + +unsupported: + return false; +} + static bool mt753x_phy_mode_supported(struct dsa_switch *ds, int port, const struct phylink_link_state *state) @@ -1421,6 +1913,217 @@ mt7530_mac_config(struct dsa_switch *ds, int port, unsigned int mode, return 0; } +static int mt7531_rgmii_setup(struct mt7530_priv *priv, u32 port, + phy_interface_t interface) +{ + u32 val; + + if (!mt7531_is_rgmii_port(priv, port)) { + dev_err(priv->dev, "RGMII mode is not available for port %d\n", + port); + return -EINVAL; + } + + val = mt7530_read(priv, MT7531_CLKGEN_CTRL); + val |= GP_CLK_EN; + val &= ~GP_MODE_MASK; + val |= GP_MODE(MT7531_GP_MODE_RGMII); + val &= ~(TXCLK_NO_REVERSE | RXCLK_NO_DELAY); + switch (interface) { + case PHY_INTERFACE_MODE_RGMII: + val |= TXCLK_NO_REVERSE; + val |= RXCLK_NO_DELAY; + break; + case PHY_INTERFACE_MODE_RGMII_RXID: + val |= TXCLK_NO_REVERSE; + break; + case PHY_INTERFACE_MODE_RGMII_TXID: + val |= RXCLK_NO_DELAY; + break; + case PHY_INTERFACE_MODE_RGMII_ID: + break; + default: + return -EINVAL; + } + val &= ~CLK_SKEW_IN_MASK; + val |= CLK_SKEW_IN(MT7531_CLK_SKEW_NO_CHG); + val &= ~CLK_SKEW_OUT_MASK; + val |= CLK_SKEW_OUT(MT7531_CLK_SKEW_NO_CHG); + mt7530_write(priv, MT7531_CLKGEN_CTRL, val); + + return 0; +} + +static void mt7531_sgmii_validate(struct mt7530_priv *priv, int port, + unsigned long *supported) +{ + /* Port5 supports ethier RGMII or SGMII. + * Port6 supports SGMII only. + */ + switch (port) { + case 5: + if (mt7531_is_rgmii_port(priv, port)) + break; + fallthrough; + case 6: + phylink_set(supported, 1000baseX_Full); + phylink_set(supported, 2500baseX_Full); + phylink_set(supported, 2500baseT_Full); + } +} + +void +mt7531_sgmii_link_up_force(struct dsa_switch *ds, int port, + unsigned int mode, phy_interface_t interface, + int speed, int duplex) +{ + struct mt7530_priv *priv = ds->priv; + unsigned int val; + + /* For adjusting speed and duplex of SGMII force mode. */ + if (interface != PHY_INTERFACE_MODE_SGMII || + phylink_autoneg_inband(mode)) + return; + + /* SGMII force mode setting */ + val = mt7530_read(priv, MT7531_SGMII_MODE(port)); + val &= ~MT7531_SGMII_IF_MODE_MASK; + + switch (speed) { + case SPEED_10: + val |= MT7531_SGMII_FORCE_SPEED_10; + break; + case SPEED_100: + val |= MT7531_SGMII_FORCE_SPEED_100; + break; + case SPEED_1000: + val |= MT7531_SGMII_FORCE_SPEED_1000; + break; + } + + /* MT7531 SGMII 1G force mode can only work in full duplex mode, + * no matter MT7531_SGMII_FORCE_HALF_DUPLEX is set or not. + */ + if ((speed == SPEED_10 || speed == SPEED_100) && + duplex != DUPLEX_FULL) + val |= MT7531_SGMII_FORCE_HALF_DUPLEX; + + mt7530_write(priv, MT7531_SGMII_MODE(port), val); +} + +static bool mt753x_is_mac_port(u32 port) +{ + return (port == 5 || port == 6); +} + +static int mt7531_sgmii_setup_mode_force(struct mt7530_priv *priv, u32 port, + phy_interface_t interface) +{ + u32 val; + + if (!mt753x_is_mac_port(port)) + return -EINVAL; + + mt7530_set(priv, MT7531_QPHY_PWR_STATE_CTRL(port), + MT7531_SGMII_PHYA_PWD); + + val = mt7530_read(priv, MT7531_PHYA_CTRL_SIGNAL3(port)); + val &= ~MT7531_RG_TPHY_SPEED_MASK; + /* Setup 2.5 times faster clock for 2.5Gbps data speeds with 10B/8B + * encoding. + */ + val |= (interface == PHY_INTERFACE_MODE_2500BASEX) ? + MT7531_RG_TPHY_SPEED_3_125G : MT7531_RG_TPHY_SPEED_1_25G; + mt7530_write(priv, MT7531_PHYA_CTRL_SIGNAL3(port), val); + + mt7530_clear(priv, MT7531_PCS_CONTROL_1(port), MT7531_SGMII_AN_ENABLE); + + /* MT7531 SGMII 1G and 2.5G force mode can only work in full duplex + * mode, no matter MT7531_SGMII_FORCE_HALF_DUPLEX is set or not. + */ + mt7530_rmw(priv, MT7531_SGMII_MODE(port), + MT7531_SGMII_IF_MODE_MASK | MT7531_SGMII_REMOTE_FAULT_DIS, + MT7531_SGMII_FORCE_SPEED_1000); + + mt7530_write(priv, MT7531_QPHY_PWR_STATE_CTRL(port), 0); + + return 0; +} + +static int mt7531_sgmii_setup_mode_an(struct mt7530_priv *priv, int port, + phy_interface_t interface) +{ + if (!mt753x_is_mac_port(port)) + return -EINVAL; + + mt7530_set(priv, MT7531_QPHY_PWR_STATE_CTRL(port), + MT7531_SGMII_PHYA_PWD); + + mt7530_rmw(priv, MT7531_PHYA_CTRL_SIGNAL3(port), + MT7531_RG_TPHY_SPEED_MASK, MT7531_RG_TPHY_SPEED_1_25G); + + mt7530_set(priv, MT7531_SGMII_MODE(port), + MT7531_SGMII_REMOTE_FAULT_DIS | + MT7531_SGMII_SPEED_DUPLEX_AN); + + mt7530_rmw(priv, MT7531_PCS_SPEED_ABILITY(port), + MT7531_SGMII_TX_CONFIG_MASK, 1); + + mt7530_set(priv, MT7531_PCS_CONTROL_1(port), MT7531_SGMII_AN_ENABLE); + + mt7530_set(priv, MT7531_PCS_CONTROL_1(port), MT7531_SGMII_AN_RESTART); + + mt7530_write(priv, MT7531_QPHY_PWR_STATE_CTRL(port), 0); + + return 0; +} + +void mt7531_sgmii_restart_an(struct dsa_switch *ds, int port) +{ + struct mt7530_priv *priv = ds->priv; + u32 val; + + /* Only restart AN when AN is enabled */ + val = mt7530_read(priv, MT7531_PCS_CONTROL_1(port)); + if (val & MT7531_SGMII_AN_ENABLE) { + val |= MT7531_SGMII_AN_RESTART; + mt7530_write(priv, MT7531_PCS_CONTROL_1(port), val); + } +} + +static int +mt7531_mac_config(struct dsa_switch *ds, int port, unsigned int mode, + phy_interface_t interface) +{ + struct mt7530_priv *priv = ds->priv; + + if (!mt753x_is_mac_port(port)) { + dev_err(priv->dev, "port %d is not a MAC port\n", port); + return -EINVAL; + } + + switch (interface) { + case PHY_INTERFACE_MODE_RGMII: + case PHY_INTERFACE_MODE_RGMII_ID: + case PHY_INTERFACE_MODE_RGMII_RXID: + case PHY_INTERFACE_MODE_RGMII_TXID: + return mt7531_rgmii_setup(priv, port, interface); + case PHY_INTERFACE_MODE_SGMII: + return mt7531_sgmii_setup_mode_an(priv, port, interface); + case PHY_INTERFACE_MODE_NA: + case PHY_INTERFACE_MODE_1000BASEX: + case PHY_INTERFACE_MODE_2500BASEX: + if (phylink_autoneg_inband(mode)) + return -EINVAL; + + return mt7531_sgmii_setup_mode_force(priv, port, interface); + default: + return -EINVAL; + } + + return -EINVAL; +} + static int mt753x_mac_config(struct dsa_switch *ds, int port, unsigned int mode, const struct phylink_link_state *state) @@ -1456,6 +2159,8 @@ mt753x_phylink_mac_config(struct dsa_switch *ds, int port, unsigned int mode, if (mt753x_mac_config(ds, port, mode, state) < 0) goto unsupported; + if (priv->p5_intf_sel != P5_DISABLED) + priv->p5_interface = state->interface; break; case 6: /* 1st cpu port */ if (priv->p6_interface == state->interface) @@ -1475,7 +2180,8 @@ mt753x_phylink_mac_config(struct dsa_switch *ds, int port, unsigned int mode, return; } - if (phylink_autoneg_inband(mode)) { + if (phylink_autoneg_inband(mode) && + state->interface != PHY_INTERFACE_MODE_SGMII) { dev_err(ds->dev, "%s: in-band negotiation unsupported\n", __func__); return; @@ -1485,7 +2191,7 @@ mt753x_phylink_mac_config(struct dsa_switch *ds, int port, unsigned int mode, mcr_new = mcr_cur; mcr_new &= ~PMCR_LINK_SETTINGS_MASK; mcr_new |= PMCR_IFG_XMIT(1) | PMCR_MAC_MODE | PMCR_BACKOFF_EN | - PMCR_BACKPR_EN | PMCR_FORCE_MODE; + PMCR_BACKPR_EN | PMCR_FORCE_MODE_ID(priv->id); /* Are we connected to external phy */ if (port == 5 && dsa_is_user_port(ds, 5)) @@ -1495,7 +2201,18 @@ mt753x_phylink_mac_config(struct dsa_switch *ds, int port, unsigned int mode, mt7530_write(priv, MT7530_PMCR_P(port), mcr_new); } -static void mt7530_phylink_mac_link_down(struct dsa_switch *ds, int port, +static void +mt753x_phylink_mac_an_restart(struct dsa_switch *ds, int port) +{ + struct mt7530_priv *priv = ds->priv; + + if (!priv->info->mac_pcs_an_restart) + return; + + priv->info->mac_pcs_an_restart(ds, port); +} + +static void mt753x_phylink_mac_link_down(struct dsa_switch *ds, int port, unsigned int mode, phy_interface_t interface) { @@ -1504,7 +2221,19 @@ static void mt7530_phylink_mac_link_down(struct dsa_switch *ds, int port, mt7530_clear(priv, MT7530_PMCR_P(port), PMCR_LINK_SETTINGS_MASK); } -static void mt7530_phylink_mac_link_up(struct dsa_switch *ds, int port, +static void mt753x_mac_pcs_link_up(struct dsa_switch *ds, int port, + unsigned int mode, phy_interface_t interface, + int speed, int duplex) +{ + struct mt7530_priv *priv = ds->priv; + + if (!priv->info->mac_pcs_link_up) + return; + + priv->info->mac_pcs_link_up(ds, port, mode, interface, speed, duplex); +} + +static void mt753x_phylink_mac_link_up(struct dsa_switch *ds, int port, unsigned int mode, phy_interface_t interface, struct phy_device *phydev, @@ -1514,8 +2243,19 @@ static void mt7530_phylink_mac_link_up(struct dsa_switch *ds, int port, struct mt7530_priv *priv = ds->priv; u32 mcr; + mt753x_mac_pcs_link_up(ds, port, mode, interface, speed, duplex); + mcr = PMCR_RX_EN | PMCR_TX_EN | PMCR_FORCE_LNK; + /* MT753x MAC works in 1G full duplex mode for all up-clocked + * variants. + */ + if (interface == PHY_INTERFACE_MODE_TRGMII || + (phy_interface_mode_is_8023z(interface))) { + speed = SPEED_1000; + duplex = DUPLEX_FULL; + } + switch (speed) { case SPEED_1000: mcr |= PMCR_FORCE_SPEED_1000; @@ -1535,6 +2275,45 @@ static void mt7530_phylink_mac_link_up(struct dsa_switch *ds, int port, mt7530_set(priv, MT7530_PMCR_P(port), mcr); } +static int +mt7531_cpu_port_config(struct dsa_switch *ds, int port) +{ + struct mt7530_priv *priv = ds->priv; + phy_interface_t interface; + int speed; + + switch (port) { + case 5: + if (mt7531_is_rgmii_port(priv, port)) + interface = PHY_INTERFACE_MODE_RGMII; + else + interface = PHY_INTERFACE_MODE_2500BASEX; + + priv->p5_interface = interface; + break; + case 6: + interface = PHY_INTERFACE_MODE_2500BASEX; + + mt7531_pad_setup(ds, interface); + + priv->p6_interface = interface; + break; + }; + + if (interface == PHY_INTERFACE_MODE_2500BASEX) + speed = SPEED_2500; + else + speed = SPEED_1000; + + mt7531_mac_config(ds, port, MLO_AN_FIXED, interface); + mt7530_write(priv, MT7530_PMCR_P(port), + PMCR_CPU_PORT_SETTING(priv->id)); + mt753x_phylink_mac_link_up(ds, port, MLO_AN_FIXED, interface, NULL, + speed, DUPLEX_FULL, true, true); + + return 0; +} + static void mt7530_mac_port_validate(struct dsa_switch *ds, int port, unsigned long *supported) @@ -1543,6 +2322,14 @@ mt7530_mac_port_validate(struct dsa_switch *ds, int port, phylink_set(supported, 1000baseX_Full); } +static void mt7531_mac_port_validate(struct dsa_switch *ds, int port, + unsigned long *supported) +{ + struct mt7530_priv *priv = ds->priv; + + mt7531_sgmii_validate(priv, port, supported); +} + static void mt753x_phylink_validate(struct dsa_switch *ds, int port, unsigned long *supported, @@ -1559,7 +2346,8 @@ mt753x_phylink_validate(struct dsa_switch *ds, int port, phylink_set_port_modes(mask); - if (state->interface != PHY_INTERFACE_MODE_TRGMII) { + if (state->interface != PHY_INTERFACE_MODE_TRGMII || + !phy_interface_mode_is_8023z(state->interface)) { phylink_set(mask, 10baseT_Half); phylink_set(mask, 10baseT_Full); phylink_set(mask, 100baseT_Half); @@ -1578,6 +2366,11 @@ mt753x_phylink_validate(struct dsa_switch *ds, int port, linkmode_and(supported, supported, mask); linkmode_and(state->advertising, state->advertising, mask); + + /* We can only operate at 2500BaseX or 1000BaseX. If requested + * to advertise both, only report advertising at 2500BaseX. + */ + phylink_helper_basex_speed(state); } static int @@ -1620,6 +2413,57 @@ mt7530_phylink_mac_link_state(struct dsa_switch *ds, int port, return 1; } +static int +mt7531_sgmii_pcs_get_state_an(struct mt7530_priv *priv, int port, + struct phylink_link_state *state) +{ + u32 status, val; + u16 config_reg; + + status = mt7530_read(priv, MT7531_PCS_CONTROL_1(port)); + state->link = !!(status & MT7531_SGMII_LINK_STATUS); + if (state->interface == PHY_INTERFACE_MODE_SGMII && + (status & MT7531_SGMII_AN_ENABLE)) { + val = mt7530_read(priv, MT7531_PCS_SPEED_ABILITY(port)); + config_reg = val >> 16; + + switch (config_reg & LPA_SGMII_SPD_MASK) { + case LPA_SGMII_1000: + state->speed = SPEED_1000; + break; + case LPA_SGMII_100: + state->speed = SPEED_100; + break; + case LPA_SGMII_10: + state->speed = SPEED_10; + break; + default: + dev_err(priv->dev, "invalid sgmii PHY speed\n"); + state->link = false; + return -EINVAL; + } + + if (config_reg & LPA_SGMII_FULL_DUPLEX) + state->duplex = DUPLEX_FULL; + else + state->duplex = DUPLEX_HALF; + } + + return 0; +} + +static int +mt7531_phylink_mac_link_state(struct dsa_switch *ds, int port, + struct phylink_link_state *state) +{ + struct mt7530_priv *priv = ds->priv; + + if (state->interface == PHY_INTERFACE_MODE_SGMII) + return mt7531_sgmii_pcs_get_state_an(priv, port, state); + + return -EOPNOTSUPP; +} + static int mt753x_phylink_mac_link_state(struct dsa_switch *ds, int port, struct phylink_link_state *state) @@ -1673,13 +2517,14 @@ static const struct dsa_switch_ops mt7530_switch_ops = { .port_vlan_prepare = mt7530_port_vlan_prepare, .port_vlan_add = mt7530_port_vlan_add, .port_vlan_del = mt7530_port_vlan_del, - .port_mirror_add = mt7530_port_mirror_add, - .port_mirror_del = mt7530_port_mirror_del, + .port_mirror_add = mt753x_port_mirror_add, + .port_mirror_del = mt753x_port_mirror_del, .phylink_validate = mt753x_phylink_validate, .phylink_mac_link_state = mt753x_phylink_mac_link_state, .phylink_mac_config = mt753x_phylink_mac_config, - .phylink_mac_link_down = mt7530_phylink_mac_link_down, - .phylink_mac_link_up = mt7530_phylink_mac_link_up, + .phylink_mac_an_restart = mt753x_phylink_mac_an_restart, + .phylink_mac_link_down = mt753x_phylink_mac_link_down, + .phylink_mac_link_up = mt753x_phylink_mac_link_up, }; static const struct mt753x_info mt753x_table[] = { @@ -1705,11 +2550,26 @@ static const struct mt753x_info mt753x_table[] = { .mac_port_get_state = mt7530_phylink_mac_link_state, .mac_port_config = mt7530_mac_config, }, + [ID_MT7531] = { + .id = ID_MT7531, + .sw_setup = mt7531_setup, + .phy_read = mt7531_ind_phy_read, + .phy_write = mt7531_ind_phy_write, + .pad_setup = mt7531_pad_setup, + .cpu_port_config = mt7531_cpu_port_config, + .phy_mode_supported = mt7531_phy_supported, + .mac_port_validate = mt7531_mac_port_validate, + .mac_port_get_state = mt7531_phylink_mac_link_state, + .mac_port_config = mt7531_mac_config, + .mac_pcs_an_restart = mt7531_sgmii_restart_an, + .mac_pcs_link_up = mt7531_sgmii_link_up_force, + }, }; static const struct of_device_id mt7530_of_match[] = { { .compatible = "mediatek,mt7621", .data = &mt753x_table[ID_MT7621], }, { .compatible = "mediatek,mt7530", .data = &mt753x_table[ID_MT7530], }, + { .compatible = "mediatek,mt7531", .data = &mt753x_table[ID_MT7531], }, { /* sentinel */ }, }; MODULE_DEVICE_TABLE(of, mt7530_of_match); diff --git a/drivers/net/dsa/mt7530.h b/drivers/net/dsa/mt7530.h index 44ac55433089..9278a8e3d04e 100644 --- a/drivers/net/dsa/mt7530.h +++ b/drivers/net/dsa/mt7530.h @@ -14,6 +14,7 @@ enum mt753x_id { ID_MT7530 = 0, ID_MT7621 = 1, + ID_MT7531 = 2, }; #define NUM_TRGMII_CTRL 5 @@ -41,6 +42,33 @@ enum mt753x_id { #define MIRROR_PORT(x) ((x) & 0x7) #define MIRROR_MASK 0x7 +/* Registers for CPU forward control */ +#define MT7531_CFC 0x4 +#define MT7531_MIRROR_EN BIT(19) +#define MT7531_MIRROR_MASK (MIRROR_MASK << 16) +#define MT7531_MIRROR_PORT_GET(x) (((x) >> 16) & MIRROR_MASK) +#define MT7531_MIRROR_PORT_SET(x) (((x) & MIRROR_MASK) << 16) +#define MT7531_CPU_PMAP_MASK GENMASK(7, 0) + +#define MT753X_MIRROR_REG(id) (((id) == ID_MT7531) ? \ + MT7531_CFC : MT7530_MFC) +#define MT753X_MIRROR_EN(id) (((id) == ID_MT7531) ? \ + MT7531_MIRROR_EN : MIRROR_EN) +#define MT753X_MIRROR_MASK(id) (((id) == ID_MT7531) ? \ + MT7531_MIRROR_MASK : MIRROR_MASK) + +/* Registers for BPDU and PAE frame control*/ +#define MT753X_BPC 0x24 +#define MT753X_BPDU_PORT_FW_MASK GENMASK(2, 0) + +enum mt753x_bpdu_port_fw { + MT753X_BPDU_FOLLOW_MFC, + MT753X_BPDU_CPU_EXCLUDE = 4, + MT753X_BPDU_CPU_INCLUDE = 5, + MT753X_BPDU_CPU_ONLY = 6, + MT753X_BPDU_DROP = 7, +}; + /* Registers for address table access */ #define MT7530_ATA1 0x74 #define STATIC_EMP 0 @@ -220,10 +248,30 @@ enum mt7530_vlan_port_attr { #define PMCR_FORCE_LNK BIT(0) #define PMCR_SPEED_MASK (PMCR_FORCE_SPEED_100 | \ PMCR_FORCE_SPEED_1000) +#define MT7531_FORCE_LNK BIT(31) +#define MT7531_FORCE_SPD BIT(30) +#define MT7531_FORCE_DPX BIT(29) +#define MT7531_FORCE_RX_FC BIT(28) +#define MT7531_FORCE_TX_FC BIT(27) +#define MT7531_FORCE_MODE (MT7531_FORCE_LNK | \ + MT7531_FORCE_SPD | \ + MT7531_FORCE_DPX | \ + MT7531_FORCE_RX_FC | \ + MT7531_FORCE_TX_FC) +#define PMCR_FORCE_MODE_ID(id) (((id) == ID_MT7531) ? \ + MT7531_FORCE_MODE : \ + PMCR_FORCE_MODE) #define PMCR_LINK_SETTINGS_MASK (PMCR_TX_EN | PMCR_FORCE_SPEED_1000 | \ PMCR_RX_EN | PMCR_FORCE_SPEED_100 | \ PMCR_TX_FC_EN | PMCR_RX_FC_EN | \ PMCR_FORCE_FDX | PMCR_FORCE_LNK) +#define PMCR_CPU_PORT_SETTING(id) (PMCR_FORCE_MODE_ID((id)) | \ + PMCR_IFG_XMIT(1) | PMCR_MAC_MODE | \ + PMCR_BACKOFF_EN | PMCR_BACKPR_EN | \ + PMCR_TX_EN | PMCR_RX_EN | \ + PMCR_TX_FC_EN | PMCR_RX_FC_EN | \ + PMCR_FORCE_SPEED_1000 | \ + PMCR_FORCE_FDX | PMCR_FORCE_LNK) #define MT7530_PMSR_P(x) (0x3008 + (x) * 0x100) #define PMSR_EEE1G BIT(7) @@ -237,6 +285,10 @@ enum mt7530_vlan_port_attr { #define PMSR_DPX BIT(1) #define PMSR_LINK BIT(0) +/* Register for port debug count */ +#define MT7531_DBG_CNT(x) (0x3018 + (x) * 0x100) +#define MT7531_DIS_CLR BIT(31) + /* Register for MIB */ #define MT7530_PORT_MIB_COUNTER(x) (0x4000 + (x) * 0x100) #define MT7530_MIB_CCR 0x4fe0 @@ -254,12 +306,118 @@ enum mt7530_vlan_port_attr { CCR_RX_OCT_CNT_BAD | \ CCR_TX_OCT_CNT_GOOD | \ CCR_TX_OCT_CNT_BAD) + +/* MT7531 SGMII register group */ +#define MT7531_SGMII_REG_BASE 0x5000 +#define MT7531_SGMII_REG(p, r) (MT7531_SGMII_REG_BASE + \ + ((p) - 5) * 0x1000 + (r)) + +/* Register forSGMII PCS_CONTROL_1 */ +#define MT7531_PCS_CONTROL_1(p) MT7531_SGMII_REG(p, 0x00) +#define MT7531_SGMII_LINK_STATUS BIT(18) +#define MT7531_SGMII_AN_ENABLE BIT(12) +#define MT7531_SGMII_AN_RESTART BIT(9) + +/* Register for SGMII PCS_SPPED_ABILITY */ +#define MT7531_PCS_SPEED_ABILITY(p) MT7531_SGMII_REG(p, 0x08) +#define MT7531_SGMII_TX_CONFIG_MASK GENMASK(15, 0) +#define MT7531_SGMII_TX_CONFIG BIT(0) + +/* Register for SGMII_MODE */ +#define MT7531_SGMII_MODE(p) MT7531_SGMII_REG(p, 0x20) +#define MT7531_SGMII_REMOTE_FAULT_DIS BIT(8) +#define MT7531_SGMII_IF_MODE_MASK GENMASK(5, 1) +#define MT7531_SGMII_FORCE_DUPLEX BIT(4) +#define MT7531_SGMII_FORCE_SPEED_MASK GENMASK(3, 2) +#define MT7531_SGMII_FORCE_SPEED_1000 BIT(3) +#define MT7531_SGMII_FORCE_SPEED_100 BIT(2) +#define MT7531_SGMII_FORCE_SPEED_10 0 +#define MT7531_SGMII_SPEED_DUPLEX_AN BIT(1) + +enum mt7531_sgmii_force_duplex { + MT7531_SGMII_FORCE_FULL_DUPLEX = 0, + MT7531_SGMII_FORCE_HALF_DUPLEX = 0x10, +}; + +/* Fields of QPHY_PWR_STATE_CTRL */ +#define MT7531_QPHY_PWR_STATE_CTRL(p) MT7531_SGMII_REG(p, 0xe8) +#define MT7531_SGMII_PHYA_PWD BIT(4) + +/* Values of SGMII SPEED */ +#define MT7531_PHYA_CTRL_SIGNAL3(p) MT7531_SGMII_REG(p, 0x128) +#define MT7531_RG_TPHY_SPEED_MASK (BIT(2) | BIT(3)) +#define MT7531_RG_TPHY_SPEED_1_25G 0x0 +#define MT7531_RG_TPHY_SPEED_3_125G BIT(2) + /* Register for system reset */ #define MT7530_SYS_CTRL 0x7000 #define SYS_CTRL_PHY_RST BIT(2) #define SYS_CTRL_SW_RST BIT(1) #define SYS_CTRL_REG_RST BIT(0) +/* Register for PHY Indirect Access Control */ +#define MT7531_PHY_IAC 0x701C +#define MT7531_PHY_ACS_ST BIT(31) +#define MT7531_MDIO_REG_ADDR_MASK (0x1f << 25) +#define MT7531_MDIO_PHY_ADDR_MASK (0x1f << 20) +#define MT7531_MDIO_CMD_MASK (0x3 << 18) +#define MT7531_MDIO_ST_MASK (0x3 << 16) +#define MT7531_MDIO_RW_DATA_MASK (0xffff) +#define MT7531_MDIO_REG_ADDR(x) (((x) & 0x1f) << 25) +#define MT7531_MDIO_DEV_ADDR(x) (((x) & 0x1f) << 25) +#define MT7531_MDIO_PHY_ADDR(x) (((x) & 0x1f) << 20) +#define MT7531_MDIO_CMD(x) (((x) & 0x3) << 18) +#define MT7531_MDIO_ST(x) (((x) & 0x3) << 16) + +enum mt7531_phy_iac_cmd { + MT7531_MDIO_ADDR = 0, + MT7531_MDIO_WRITE = 1, + MT7531_MDIO_READ = 2, + MT7531_MDIO_READ_CL45 = 3, +}; + +/* MDIO_ST: MDIO start field */ +enum mt7531_mdio_st { + MT7531_MDIO_ST_CL45 = 0, + MT7531_MDIO_ST_CL22 = 1, +}; + +#define MT7531_MDIO_CL22_READ (MT7531_MDIO_ST(MT7531_MDIO_ST_CL22) | \ + MT7531_MDIO_CMD(MT7531_MDIO_READ)) +#define MT7531_MDIO_CL22_WRITE (MT7531_MDIO_ST(MT7531_MDIO_ST_CL22) | \ + MT7531_MDIO_CMD(MT7531_MDIO_WRITE)) +#define MT7531_MDIO_CL45_ADDR (MT7531_MDIO_ST(MT7531_MDIO_ST_CL45) | \ + MT7531_MDIO_CMD(MT7531_MDIO_ADDR)) +#define MT7531_MDIO_CL45_READ (MT7531_MDIO_ST(MT7531_MDIO_ST_CL45) | \ + MT7531_MDIO_CMD(MT7531_MDIO_READ)) +#define MT7531_MDIO_CL45_WRITE (MT7531_MDIO_ST(MT7531_MDIO_ST_CL45) | \ + MT7531_MDIO_CMD(MT7531_MDIO_WRITE)) + +/* Register for RGMII clock phase */ +#define MT7531_CLKGEN_CTRL 0x7500 +#define CLK_SKEW_OUT(x) (((x) & 0x3) << 8) +#define CLK_SKEW_OUT_MASK GENMASK(9, 8) +#define CLK_SKEW_IN(x) (((x) & 0x3) << 6) +#define CLK_SKEW_IN_MASK GENMASK(7, 6) +#define RXCLK_NO_DELAY BIT(5) +#define TXCLK_NO_REVERSE BIT(4) +#define GP_MODE(x) (((x) & 0x3) << 1) +#define GP_MODE_MASK GENMASK(2, 1) +#define GP_CLK_EN BIT(0) + +enum mt7531_gp_mode { + MT7531_GP_MODE_RGMII = 0, + MT7531_GP_MODE_MII = 1, + MT7531_GP_MODE_REV_MII = 2 +}; + +enum mt7531_clk_skew { + MT7531_CLK_SKEW_NO_CHG = 0, + MT7531_CLK_SKEW_DLY_100PPS = 1, + MT7531_CLK_SKEW_DLY_200PPS = 2, + MT7531_CLK_SKEW_REVERSE = 3, +}; + /* Register for hw trap status */ #define MT7530_HWTRAP 0x7800 #define HWTRAP_XTAL_MASK (BIT(10) | BIT(9)) @@ -267,6 +425,16 @@ enum mt7530_vlan_port_attr { #define HWTRAP_XTAL_40MHZ (BIT(10)) #define HWTRAP_XTAL_20MHZ (BIT(9)) +#define MT7531_HWTRAP 0x7800 +#define HWTRAP_XTAL_FSEL_MASK BIT(7) +#define HWTRAP_XTAL_FSEL_25MHZ BIT(7) +#define HWTRAP_XTAL_FSEL_40MHZ 0 +/* Unique fields of (M)HWSTRAP for MT7531 */ +#define XTAL_FSEL_S 7 +#define XTAL_FSEL_M BIT(7) +#define PHY_EN BIT(6) +#define CHG_STRAP BIT(8) + /* Register for hw trap modification */ #define MT7530_MHWTRAP 0x7804 #define MHWTRAP_PHY0_SEL BIT(20) @@ -281,14 +449,37 @@ enum mt7530_vlan_port_attr { #define MT7530_TOP_SIG_CTRL 0x7808 #define TOP_SIG_CTRL_NORMAL (BIT(17) | BIT(16)) +#define MT7531_TOP_SIG_SR 0x780c +#define PAD_DUAL_SGMII_EN BIT(1) +#define PAD_MCM_SMI_EN BIT(0) + #define MT7530_IO_DRV_CR 0x7810 #define P5_IO_CLK_DRV(x) ((x) & 0x3) #define P5_IO_DATA_DRV(x) (((x) & 0x3) << 4) +#define MT7531_CHIP_REV 0x781C + +#define MT7531_PLLGP_EN 0x7820 +#define EN_COREPLL BIT(2) +#define SW_CLKSW BIT(1) +#define SW_PLLGP BIT(0) + #define MT7530_P6ECR 0x7830 #define P6_INTF_MODE_MASK 0x3 #define P6_INTF_MODE(x) ((x) & 0x3) +#define MT7531_PLLGP_CR0 0x78a8 +#define RG_COREPLL_EN BIT(22) +#define RG_COREPLL_POSDIV_S 23 +#define RG_COREPLL_POSDIV_M 0x3800000 +#define RG_COREPLL_SDM_PCW_S 1 +#define RG_COREPLL_SDM_PCW_M 0x3ffffe +#define RG_COREPLL_SDM_PCW_CHG BIT(0) + +/* Registers for RGMII and SGMII PLL clock */ +#define MT7531_ANA_PLLGP_CR2 0x78b0 +#define MT7531_ANA_PLLGP_CR5 0x78bc + /* Registers for TRGMII on the both side */ #define MT7530_TRGMII_RCK_CTRL 0x7a00 #define RX_RST BIT(31) @@ -327,10 +518,25 @@ enum mt7530_vlan_port_attr { #define MT7530_P5RGMIITXCR 0x7b04 #define CSR_RGMII_TXC_CFG(x) ((x) & 0x1f) +/* Registers for GPIO mode */ +#define MT7531_GPIO_MODE0 0x7c0c +#define MT7531_GPIO0_MASK GENMASK(3, 0) +#define MT7531_GPIO0_INTERRUPT 1 + +#define MT7531_GPIO_MODE1 0x7c10 +#define MT7531_GPIO11_RG_RXD2_MASK GENMASK(15, 12) +#define MT7531_EXT_P_MDC_11 (2 << 12) +#define MT7531_GPIO12_RG_RXD3_MASK GENMASK(19, 16) +#define MT7531_EXT_P_MDIO_12 (2 << 16) + #define MT7530_CREV 0x7ffc #define CHIP_NAME_SHIFT 16 #define MT7530_ID 0x7530 +#define MT7531_CREV 0x781C +#define CHIP_REV_M 0x0f +#define MT7531_ID 0x7531 + /* Registers for core PLL access through mmd indirect */ #define CORE_PLL_GROUP2 0x401 #define RG_SYSPLL_EN_NORMAL BIT(15) @@ -347,6 +553,10 @@ enum mt7530_vlan_port_attr { #define RG_SYSPLL_DDSFBK_EN BIT(12) #define RG_SYSPLL_BIAS_EN BIT(11) #define RG_SYSPLL_BIAS_LPF_EN BIT(10) +#define MT7531_PHY_PLL_OFF BIT(5) +#define MT7531_PHY_PLL_BYPASS_MODE BIT(4) + +#define MT753X_CTRL_PHY_ADDR 0 #define CORE_PLL_GROUP5 0x404 #define RG_LCDDS_PCW_NCPO1(x) ((x) & 0xffff) @@ -425,6 +635,7 @@ enum p5_interface_select { P5_INTF_SEL_PHY_P0, P5_INTF_SEL_PHY_P4, P5_INTF_SEL_GMAC5, + P5_INTF_SEL_GMAC5_SGMII, }; static const char *p5_intf_modes(unsigned int p5_interface) @@ -438,6 +649,8 @@ static const char *p5_intf_modes(unsigned int p5_interface) return "PHY P4"; case P5_INTF_SEL_GMAC5: return "GMAC5"; + case P5_INTF_SEL_GMAC5_SGMII: + return "GMAC5_SGMII"; default: return "unknown"; } @@ -458,6 +671,10 @@ static const char *p5_intf_modes(unsigned int p5_interface) * MAC port * @mac_port_config: Holding the way setting up the PHY attribute to a * certain MAC port + * @mac_pcs_an_restart Holding the way restarting PCS autonegotiation for a + * certain MAC port + * @mac_pcs_link_up: Holding the way setting up the PHY attribute to the pcs + * of the certain MAC port */ struct mt753x_info { enum mt753x_id id; @@ -466,6 +683,7 @@ struct mt753x_info { int (*phy_read)(struct dsa_switch *ds, int port, int regnum); int (*phy_write)(struct dsa_switch *ds, int port, int regnum, u16 val); int (*pad_setup)(struct dsa_switch *ds, phy_interface_t interface); + int (*cpu_port_config)(struct dsa_switch *ds, int port); bool (*phy_mode_supported)(struct dsa_switch *ds, int port, const struct phylink_link_state *state); void (*mac_port_validate)(struct dsa_switch *ds, int port, @@ -475,6 +693,10 @@ struct mt753x_info { int (*mac_port_config)(struct dsa_switch *ds, int port, unsigned int mode, phy_interface_t interface); + void (*mac_pcs_an_restart)(struct dsa_switch *ds, int port); + void (*mac_pcs_link_up)(struct dsa_switch *ds, int port, + unsigned int mode, phy_interface_t interface, + int speed, int duplex); }; /* struct mt7530_priv - This is the main data structure for holding the state -- 2.17.1 _______________________________________________ Linux-mediatek mailing list Linux-mediatek@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-mediatek