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=-2.9 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,SPF_PASS, 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 C2250C468C7 for ; Thu, 12 Jul 2018 05:51:45 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 5890920875 for ; Thu, 12 Jul 2018 05:51:45 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=cadence.com header.i=@cadence.com header.b="lOgwPt9c" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 5890920875 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=cadence.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1732671AbeGLF7i (ORCPT ); Thu, 12 Jul 2018 01:59:38 -0400 Received: from mail-eopbgr720086.outbound.protection.outlook.com ([40.107.72.86]:52128 "EHLO NAM05-CO1-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1725911AbeGLFzy (ORCPT ); Thu, 12 Jul 2018 01:55:54 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=cadence.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=6w6v6jxUVsfnlEVaDue7RMpiwDugk92RGsz7TMkAax0=; b=lOgwPt9cNkJ7oZuqbP0N0qh6qsOTzx3lK2p3FPFxqLulr/KAjE5qxQYVFs10AA7G/rWTfzhVytg0xrPH96u58pB6KecdoJ38wV3XWCW/1yrN2IdUhySWBb8bVg/KdC5KtpZrAo1Um4wu6HRTpSERZy228O2IMsdZ9zlQsIRvZK0= Received: from DM5PR07CA0084.namprd07.prod.outlook.com (2603:10b6:4:ad::49) by BYAPR07MB4712.namprd07.prod.outlook.com (2603:10b6:a02:f0::11) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.952.17; Thu, 12 Jul 2018 05:47:51 +0000 Received: from BY2NAM05FT036.eop-nam05.prod.protection.outlook.com (2a01:111:f400:7e52::203) by DM5PR07CA0084.outlook.office365.com (2603:10b6:4:ad::49) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384) id 15.20.952.18 via Frontend Transport; Thu, 12 Jul 2018 05:47:51 +0000 Authentication-Results: spf=softfail (sender IP is 158.140.1.28) smtp.mailfrom=cadence.com; vger.kernel.org; dkim=none (message not signed) header.d=none;vger.kernel.org; dmarc=fail action=none header.from=cadence.com; Received-SPF: SoftFail (protection.outlook.com: domain of transitioning cadence.com discourages use of 158.140.1.28 as permitted sender) Received: from sjmaillnx1.cadence.com (158.140.1.28) by BY2NAM05FT036.mail.protection.outlook.com (10.152.100.173) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P384) id 15.20.973.9 via Frontend Transport; Thu, 12 Jul 2018 05:47:50 +0000 Received: from maileu3.global.cadence.com (maileu3.cadence.com [10.160.88.99]) by sjmaillnx1.cadence.com (8.14.4/8.14.4) with ESMTP id w6C5lkvu032054 (version=TLSv1/SSLv3 cipher=AES256-SHA bits=256 verify=FAIL); Wed, 11 Jul 2018 22:47:49 -0700 X-CrossPremisesHeadersFilteredBySendConnector: maileu3.global.cadence.com Received: from maileu3.global.cadence.com (10.160.88.99) by maileu3.global.cadence.com (10.160.88.99) with Microsoft SMTP Server (TLS) id 15.0.1367.3; Thu, 12 Jul 2018 07:48:02 +0200 Received: from lvlogina.cadence.com (10.165.176.102) by maileu3.global.cadence.com (10.160.88.99) with Microsoft SMTP Server id 15.0.1367.3 via Frontend Transport; Thu, 12 Jul 2018 07:48:02 +0200 Received: from lvlogina.cadence.com (localhost.localdomain [127.0.0.1]) by lvlogina.cadence.com (8.14.4/8.14.4) with ESMTP id w6C5ljOh029483; Thu, 12 Jul 2018 06:47:46 +0100 Received: (from pawell@localhost) by lvlogina.cadence.com (8.14.4/8.14.4/Submit) id w6C5ljMi029476; Thu, 12 Jul 2018 06:47:45 +0100 From: Pawel Laszczak CC: Greg Kroah-Hartman , , Felipe Balbi , , , , Subject: [PATCH 02/31] usb: usbssp: Added some decoding functions. Date: Thu, 12 Jul 2018 06:46:59 +0100 Message-ID: <1531374448-26532-3-git-send-email-pawell@cadence.com> X-Mailer: git-send-email 1.7.11.2 In-Reply-To: <1531374448-26532-1-git-send-email-pawell@cadence.com> References: <1531374448-26532-1-git-send-email-pawell@cadence.com> MIME-Version: 1.0 Content-Type: text/plain X-OrganizationHeadersPreserved: maileu3.global.cadence.com X-EOPAttributedMessage: 0 X-Forefront-Antispam-Report: CIP:158.140.1.28;IPV:CAL;SCL:-1;CTRY:US;EFV:NLI;SFV:NSPM;SFS:(10009020)(136003)(346002)(39860400002)(396003)(376002)(2980300002)(189003)(199004)(36092001)(43544003)(76176011)(7636002)(42186006)(86362001)(316002)(305945005)(16586007)(54906003)(426003)(186003)(246002)(8936002)(8676002)(336012)(50226002)(47776003)(109986005)(356003)(26005)(2906002)(486006)(476003)(126002)(107886003)(446003)(2616005)(11346002)(478600001)(5660300001)(4326008)(14444005)(4720700003)(1671002)(26826003)(87636003)(6666003)(106466001)(551934003)(105596002)(48376002)(50466002)(36756003)(51416003)(266003);DIR:OUT;SFP:1101;SCL:1;SRVR:BYAPR07MB4712;H:sjmaillnx1.cadence.com;FPR:;SPF:SoftFail;LANG:en;PTR:corp.cadence.com;MX:1;A:1; X-Microsoft-Exchange-Diagnostics: 1;BY2NAM05FT036;1:RqatsX6vL52B2/bEr2HLkQ4GQPSc6ii/Stn3KSsD7gw2joYhQafcj14+xsWcdfGmE4nLR2tAcGjXAnme9Cy0FtsqU9t09D597x7WMfBYnQFU4RWBJidEjsy+387NbZsp X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 2bda3ec8-93d5-4539-3b39-08d5e7bb0112 X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:(7020095)(4652040)(8989117)(5600053)(711020)(4534165)(4627221)(201703031133081)(201702281549075)(8990107)(2017052603328)(7153060);SRVR:BYAPR07MB4712; X-Microsoft-Exchange-Diagnostics: 1;BYAPR07MB4712;3:LNsT8GeydekJe635Jht4dFOjVT4oE4A+irHrfKc0+LU44kro0127gRQiSR+4vQRHvX3F4vt4Rjc2q72qGyfOnZ716o4NyTwevUnvQ2+fl5EgE9UsDcnjx/DjlcKwJpwtrPMn52DzAoLFdwuVnuchrqvzd9aaiq/jqlfANplX7pWDGOgybk37o7zigsJUodrvcfCQQ7bw/cWXueK294Iienw5g0olk53VN4xONKWd47virShKXUhHt1WK+pJ+vDBXQyHzckWOOUWbyrExCYcxWQFo/ocbNHsgyMtBeP77x2RpLzvqvSKF/zOW2QLx1tTx7cbENsO2fJSzdDnDXSTI1dsvkC59H1cdRxXiYQ8sH5M=;25:8x395qp3lOXoK/IyRolt/q1+0DuMFyKVb6YWJ076d93AxHTPsvnmnWTLcerWKsIF5bHXrFvPj4ZzbSebxY1ONcaipUBostxInIA7WNjbG/EJJoMHLCixZPP0s3r49U68bNymuwnMwV20tkS+QNMWMKPvYTUJcSdtvTEIYaYM8LERIvvEpd3y2XWa9jxlv9XSMJR0Dy/ECDGiX7Pwg48nzPBf0AXJZ10o9/vBglMsQjUJFkVpSRZzPog5sOVcTJOcPGUr8LmT5GkZBABpdCPix2mVkFZw6zCv8F+turxyZWA/mFmB813dCL+bLJvT+snqt09qkVQGYFaGWeV56TyUTw== X-MS-TrafficTypeDiagnostic: BYAPR07MB4712: X-Microsoft-Exchange-Diagnostics: 1;BYAPR07MB4712;31:sABkoLoj98zuzmfi2ZFiMj3hC5hbAR2cujO2BetgjGldsWNk6ocaTwk9yYaJaK04PH0PNgKUldHDnTjvmYAFRaG5wD/jiAK7Ou0OBwR/E2LQEfje80Y4jz/EcM9s+C2UgGHQZ9gowvrOt9Lc3Q4fhHsRpxqwEkeOXyqm+qnLLEyFziXIzHOGzK97KlTB0C6vAL4Zs38JgucaColO6ZrOG5KoRxuAfq//in+8CRNeeL4=;20:fZFeCXzNRDn6XdE6DkpUjq4sjbGruJJO88NRuXCz+Zdp/aMthAEjzJfSBqlJcRAt0Azm7X3njctVF6YjTNkIgkMv7nqUD1fg+VowQR1VjEoKgRMa3zqwIClGl2lHb1ZvFiN71eV35Wvo7sUWKQR7o0eg/Y2ONt+YNfxlrwbdi+f+VjUaw43B+bL4cORszRbnIhHli+mDtSFphqSQgtxYTUrDPoxJdHEuDitnR1JVmy6p8T5nlcmV8S8775I8o8TVS9wxi4+pGw2GGqMow7t4HTHykYWIJv1+MV1xrSOkpdCZ9aCEmXDovjdg5hYf4lTtgiLjyUjhUtHDelRV6K2AM0eiufiGMO7hlochHpSPp6RuyTcVTX+EbQL0KueKlqZRvpqGiii1Em+8u1EZmET77MgM2cvNObQxk0ZSKLE2CACg/Fxx50KNGn15c/QydJHFtOVArIICRtfm2kCkJNaWIAzivodhvT30AJw6ZkvnwUNdX/ycxqNShv6dlEkl+kxE X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(72806322054110); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0;PCL:0;RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(10201501046)(93006095)(93003095)(3002001)(3231311)(944501410)(52105095)(149027)(150027)(6041310)(20161123564045)(20161123558120)(20161123562045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123560045)(6072148)(201708071742011)(7699016);SRVR:BYAPR07MB4712;BCL:0;PCL:0;RULEID:;SRVR:BYAPR07MB4712; X-Microsoft-Exchange-Diagnostics: 1;BYAPR07MB4712;4:UPIM9yZ3ai5TahVx18Wxq8jFy0VF8KNJMNiMg4xIFnLXTkUcQU9wTGmaB2ixdHFijhfc5kIuUA76H0ogjjNLda36BWPSjPQH7CacttAzjAJR1N5GCJQhMbxewVR8UUF7dwv8/SKGce50ZWPU0QUkAfaaZLhf4+QGVO7lgiGd2IlfNx9yrAHZJL/b3SsUl4B0dG65SfMu70tqyfbzPT8P7SvcwBO0/oGECiSNrPwypeNlWzKRRqz9FYBiLnkeuQ4SuIIMPRHWP+nsFq5CUndjfhqS8qSqBF4nKwV/7KhnuX6ZiqMKaZ83Unv3jFWAFRjO X-Forefront-PRVS: 0731AA2DE6 X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1;BYAPR07MB4712;23:Jhezjo/HgwlRaPnNo4n/3P2uJrYyEWITA4OxemY1D?= =?us-ascii?Q?HscgLrTxpe7Y5/hUGxwOSEWvgM8D5/eOM9vfCKPIkirJOjvIG879muy5mD6R?= =?us-ascii?Q?sQVdqDsjjUsQNjlQIu+EClVIUOIn+yJ0wWhRQARP2/hThFQmrmwkTZVx8ldn?= =?us-ascii?Q?ciIeUv/D22gnz8P84+1TgdHJqkmIh28PSDHiKEggHsfgG7VzDqW/GJBDYlEX?= =?us-ascii?Q?KhFmCKEcW9Zx/3zrA61tZFrQcBR/vn7hD/81rs3cA0WeqVtaTNuaXXDYtVlX?= =?us-ascii?Q?r9auJvTc5r+OGksyapgUU5hXtLqGKBHweA75Mo0WbHSN11lgfyTHIsPr3icq?= =?us-ascii?Q?0ljMj+OZj6jbg/uW1f0bXBB4GrXKbPYF8ZPkl8G1r+PB2WacJQ3nbI8myugz?= =?us-ascii?Q?cbnrVbYMnUzjXS9bmNFd7voHuUWtswioS3yeg9N/vfaFaX5ZSejCq3+RC4fF?= =?us-ascii?Q?t0E/r0lClMgdb26HHcUtDcC0CnKDuHcksCTE+TS3YsMWbDI4kPSZfc8Fn5mI?= =?us-ascii?Q?AlaSE2eTCP9I+1cOXHL7Esib8XTDOEkjbyWBZibDK+oS87rnaKtzxcZROt5S?= =?us-ascii?Q?6MkrFHv3SbmVU7IUJqlE6pXU1VEqs2LBtBkQVtUrdyJVCQEgOfrtFQKVcliv?= =?us-ascii?Q?mOGbwtlOvKLv+7EmCd288ro9l7iTDrzX+s+vLSu+dT4Fds/Kn/riFmi1xWNd?= =?us-ascii?Q?akbb18+sRTjabDaPP9qCyyyBKr1l2bNixCTbQGRaAIu5dzReFvop5+8pJ6R7?= =?us-ascii?Q?G05bdzhlsKJZiYo7ytNfkd2Kq5NEg/R6d8OCaWhiHAtind9Du7vDn/WaA1FI?= =?us-ascii?Q?d7ywDA7dGJU5prOUe/LvHnFl8qQF9M+cz4gjSTnjEo+6HRFEHXvWutC9NYkf?= =?us-ascii?Q?5lRln4gRyS96CyF6Vd3OX0oOJ3/cpU6NfL6BOmQGToUrmcwuy3iQMw7lk0ey?= =?us-ascii?Q?iwLmLO16+71lu2Kge5s5+ozfDycui3I6hzXQ+IM0Mr688Dhw+EwfNURqoRIA?= =?us-ascii?Q?T1gcG97XP8mxK3sQ54Kl/O7JnMNzk9fXhIJtXV0v91QAvb4Xx+cn3UxAnvf+?= =?us-ascii?Q?k8FcmqtHe59mgSyQXTO89ZhPQQXeaWYULzbR9HPP6mAfHscI9CCxYHVRDQ0S?= =?us-ascii?Q?wjPiClCt8EDJoGdFqSHbefRamyN3hRnBThdGRheyIOTP8cz9MmXE6KpJWf++?= =?us-ascii?Q?numtw4ox63mGEFvnLOXPKMmY+W8gxMv/YBA?= X-Microsoft-Antispam-Message-Info: vnuubc9QNf7e5+VOrd3vYkjHn2nfJ+DeHb6dZgsVvCbHIXDcXULLAFQBHR9tGzAr6+bWmXXT0BpcWFRxC09rXPbol6IxhTHHDinHrM29xv81YLfcefE5u4MiDPFmIXVbl4D1zhV+xI4GLyF4pXFADwuRsqtb2wbxkb4YnBhvMp+0Z1KMMPy9bN9XQI7Rq2rsEmxWUsetT0zB62pseLJ8wdMfO9KhynVgxn6FMLNm56OOxU8mawf/x62MF0vfmf+f6i2r41FllX/XCuxOJuZ3fuATtfTCj/okOTzrUsKQN8khn4hhUjhQdjvp/+dyw71DuQeAsE0NLD5SrFxl1kVENMcEgP5hBvq4zOjBypspGLIe9859COYGYH92ha1fnoeK/cAdOTj7qLj1cVIuymw7QA== X-Microsoft-Exchange-Diagnostics: 1;BYAPR07MB4712;6:raYUlKxFmeQYJw95F+AvPkn2+35ut1gUQTVW84LF7cN9miME5K2sSZ2v7ygk03x1WWoTpML+/9ebr8PxgzwMG5wFJjMrWlTYk0C1t2gwQp61iNo4o09FvqiXSP7iFNH59wOM4hKz7HJOmTCYY/QAuXGau9yh+83YwPw8yNQChKVi4SAup3NSXMnHwcwD1TmId9AWD2xkBS4PTLdd4Hm21/JLgxYMD6n7kYpChXITwSPlufCN67uTohAJo2fxhBlZ84FbCphFGTwGJzajhlD07aT74qBuCH6WP9PP7JYRdsqbxao3mFWV15cvANg6XbhkpHrgTOQ19dI9fIAY1D4dR2iw74051fSplFInxWmlZbVfR98CWy3MIKExurvtgxykwOoXdxo9wImxb2PJ6JWcHB519uETdX9qdOXqxuFQxS66vIBWemG/FJoSFZt832spgLQ2BIjuo69n8NLqSnCEaA==;5:DRuOjwWGWElUF5T6BMfopDpwNM06cTyiOzqY5o7f4hhOcyRmcfQBRGYJCFyLvTU3mkYrRAJ7YhySCOj0d+iqdpTCyfPdaS2jH1SWtgNEGlOj0pSKrchDDeT3DbU2UsRws3UMpVG4TqBgVj9rl/isbEMhuvn1es36+Dt6n5F+PHQ=;24:q8JjU4jO/xdUuPKTrm54l0CRsB1hf+lSoifFCGR8qmldrdH9qXY+OjH2cj2qs6f0p5trV2cYhn6gN1h9eRcHBdTdl6dD2RJZEw0l28hpc7U= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1;BYAPR07MB4712;7:K7Cq1rT63nVLi1Uf5mtXCNyM0VdTEZobBK1No4ZBmKpHWdOZUKbCXWcl4wyy3KcSbdzZigfmzL9kBbQHyBH5dAzQTGKRjH2ZzqrNoJXxjlQ64V9/MvYBEwfxV/O5ZXlvCQmiIr0qgS2lrBGK4iezbhAS2orTaKz4l5fVTXugGVfHFvi1cLoCCMLgpbEO1HvD1tuZqIPBzpuZyzkOBua9sh77erirMRDsRfyFGLGDTW9TSo8RHywGFDei60aiX5w0;20:mawlj/IkaFvp119ahDgq39v481P9VziZX8ZBW+LQkiNYVS45IRX1SONa5clxOLrlMf4nitCwTth9QiwRNwmBADhD4i8p0QY8ZT6EZAwZW7/nidwhoEoaaUfbRRW/dSqD+CVScJaSkLODSLds2WkC9lIccXHttega+QFROQmPUWBzOxjYQRg9svjbfSrQP2P8Z74l1GdO97rMVRxA69/NExOEnBpE+wNPP13xFkU8PR8Ihj5015zc5IVPZw2HSmnu X-OriginatorOrg: cadence.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 12 Jul 2018 05:47:50.5040 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 2bda3ec8-93d5-4539-3b39-08d5e7bb0112 X-MS-Exchange-CrossTenant-Id: d36035c5-6ce6-4662-a3dc-e762e61ae4c9 X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=d36035c5-6ce6-4662-a3dc-e762e61ae4c9;Ip=[158.140.1.28];Helo=[sjmaillnx1.cadence.com] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: BYAPR07MB4712 To: unlisted-recipients:; (no To-header on input) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This patch add additional functions that converts some fields to string. For example function usbssp_trb_comp_code_string take completion c ode value and return string describing completion code. Signed-off-by: Pawel Laszczak --- drivers/usb/usbssp/gadget.h | 572 ++++++++++++++++++++++++++++++++++++ 1 file changed, 572 insertions(+) diff --git a/drivers/usb/usbssp/gadget.h b/drivers/usb/usbssp/gadget.h index 486e868068b7..6b634dc63d9e 100644 --- a/drivers/usb/usbssp/gadget.h +++ b/drivers/usb/usbssp/gadget.h @@ -922,6 +922,73 @@ struct usbssp_transfer_event { #define COMP_UNDEFINED_ERROR 33 #define COMP_INVALID_STREAM_ID_ERROR 34 +static inline const char *usbssp_trb_comp_code_string(u8 status) +{ + switch (status) { + case COMP_INVALID: + return "Invalid"; + case COMP_SUCCESS: + return "Success"; + case COMP_DATA_BUFFER_ERROR: + return "Data Buffer Error"; + case COMP_BABBLE_DETECTED_ERROR: + return "Babble Detected"; + case COMP_USB_TRANSACTION_ERROR: + return "USB Transaction Error"; + case COMP_TRB_ERROR: + return "TRB Error"; + case COMP_RESOURCE_ERROR: + return "Resource Error"; + case COMP_NO_SLOTS_AVAILABLE_ERROR: + return "No Slots Available Error"; + case COMP_INVALID_STREAM_TYPE_ERROR: + return "Invalid Stream Type Error"; + case COMP_SLOT_NOT_ENABLED_ERROR: + return "Slot Not Enabled Error"; + case COMP_ENDPOINT_NOT_ENABLED_ERROR: + return "Endpoint Not Enabled Error"; + case COMP_SHORT_PACKET: + return "Short Packet"; + case COMP_RING_UNDERRUN: + return "Ring Underrun"; + case COMP_RING_OVERRUN: + return "Ring Overrun"; + case COMP_VF_EVENT_RING_FULL_ERROR: + return "VF Event Ring Full Error"; + case COMP_PARAMETER_ERROR: + return "Parameter Error"; + case COMP_CONTEXT_STATE_ERROR: + return "Context State Error"; + case COMP_EVENT_RING_FULL_ERROR: + return "Event Ring Full Error"; + case COMP_INCOMPATIBLE_DEVICE_ERROR: + return "Incompatible Device Error"; + case COMP_MISSED_SERVICE_ERROR: + return "Missed Service Error"; + case COMP_COMMAND_RING_STOPPED: + return "Command Ring Stopped"; + case COMP_COMMAND_ABORTED: + return "Command Aborted"; + case COMP_STOPPED: + return "Stopped"; + case COMP_STOPPED_LENGTH_INVALID: + return "Stopped - Length Invalid"; + case COMP_STOPPED_SHORT_PACKET: + return "Stopped - Short Packet"; + case COMP_MAX_EXIT_LATENCY_TOO_LARGE_ERROR: + return "Max Exit Latency Too Large Error"; + case COMP_ISOCH_BUFFER_OVERRUN: + return "Isoch Buffer Overrun"; + case COMP_EVENT_LOST_ERROR: + return "Event Lost Error"; + case COMP_UNDEFINED_ERROR: + return "Undefined Error"; + case COMP_INVALID_STREAM_ID_ERROR: + return "Invalid Stream ID Error"; + default: + return "Unknown!!"; + } +} struct usbssp_link_trb { /* 64-bit segment pointer*/ __le64 segment_ptr; @@ -1274,6 +1341,27 @@ enum usbssp_ring_type { TYPE_EVENT, }; +static inline const char *usbssp_ring_type_string(enum usbssp_ring_type type) +{ + switch (type) { + case TYPE_CTRL: + return "CTRL"; + case TYPE_ISOC: + return "ISOC"; + case TYPE_BULK: + return "BULK"; + case TYPE_INTR: + return "INTR"; + case TYPE_STREAM: + return "STREAM"; + case TYPE_COMMAND: + return "CMD"; + case TYPE_EVENT: + return "EVENT"; + } + + return "UNKNOWN"; +} struct usbssp_ring { struct usbssp_segment *first_seg; struct usbssp_segment *last_seg; @@ -1564,4 +1652,488 @@ struct usbssp_udc { #define usbssp_info(usbssp_data, fmt, args...) \ dev_info(usbssp_data->dev, fmt, ## args) +/* + * Registers should always be accessed with double word or quad word accesses. + * + * Registers with 64-bit address pointers should be written to with + * dword accesses by writing the low dword first (ptr[0]), then the high dword + * (ptr[1]) second. DC implementations that do not support 64-bit address + * pointers will ignore the high dword, and write order is irrelevant. + */ +static inline u64 usbssp_read_64(const struct usbssp_udc *usbssp_data, + __le64 __iomem *regs) +{ + return lo_hi_readq(regs); +} + +static inline void usbssp_write_64(struct usbssp_udc *usbssp_data, + const u64 val, __le64 __iomem *regs) +{ + lo_hi_writeq(val, regs); +} +static inline char *usbssp_slot_state_string(u32 state) +{ + switch (state) { + case SLOT_STATE_ENABLED: + return "enabled/disabled"; + case SLOT_STATE_DEFAULT: + return "default"; + case SLOT_STATE_ADDRESSED: + return "addressed"; + case SLOT_STATE_CONFIGURED: + return "configured"; + default: + return "reserved"; + } +} + +static inline const char *usbssp_decode_trb(u32 field0, u32 field1, u32 field2, + u32 field3) +{ + static char str[256]; + int type = TRB_FIELD_TO_TYPE(field3); + + switch (type) { + case TRB_LINK: + sprintf(str, + "LINK %08x%08x intr %d type '%s' flags %c:%c:%c:%c", + field1, field0, GET_INTR_TARGET(field2), + usbssp_trb_type_string(type), + field3 & TRB_IOC ? 'I' : 'i', + field3 & TRB_CHAIN ? 'C' : 'c', + field3 & TRB_TC ? 'T' : 't', + field3 & TRB_CYCLE ? 'C' : 'c'); + break; + case TRB_TRANSFER: + case TRB_COMPLETION: + case TRB_PORT_STATUS: + case TRB_DOORBELL: + case TRB_HC_EVENT: + case TRB_DEV_NOTE: + case TRB_MFINDEX_WRAP: + sprintf(str, + "TRB %08x%08x status '%s' len %d slot %d ep %d:=:" + "type '%s' flags %c:%c", + field1, field0, + usbssp_trb_comp_code_string(GET_COMP_CODE(field2)), + EVENT_TRB_LEN(field2), TRB_TO_SLOT_ID(field3), + /* Macro decrements 1, maybe it shouldn't?!? */ + TRB_TO_EP_INDEX(field3) + 1, + usbssp_trb_type_string(type), + field3 & EVENT_DATA ? 'E' : 'e', + field3 & TRB_CYCLE ? 'C' : 'c'); + + break; + case TRB_SETUP: + sprintf(str, "bRequestType %02x bRequest %02x wValue %02x%02x " + "wIndex %02x%02x wLength %d length %d " + "TD size %d intr %d type '%s' flags %c:%c:%c", + field0 & 0xff, + (field0 & 0xff00) >> 8, + (field0 & 0xff000000) >> 24, + (field0 & 0xff0000) >> 16, + (field1 & 0xff00) >> 8, + field1 & 0xff, + (field1 & 0xff000000) >> 16 | + (field1 & 0xff0000) >> 16, + TRB_LEN(field2), GET_TD_SIZE(field2), + GET_INTR_TARGET(field2), + usbssp_trb_type_string(type), + field3 & TRB_IDT ? 'I' : 'i', + field3 & TRB_IOC ? 'I' : 'i', + field3 & TRB_CYCLE ? 'C' : 'c'); + break; + case TRB_DATA: + sprintf(str, "Buffer %08x%08x length %d TD size %d intr %d " + "type '%s' flags %c:%c:%c:%c:%c:%c:%c", + field1, field0, TRB_LEN(field2), + GET_TD_SIZE(field2), + GET_INTR_TARGET(field2), + usbssp_trb_type_string(type), + field3 & TRB_IDT ? 'I' : 'i', + field3 & TRB_IOC ? 'I' : 'i', + field3 & TRB_CHAIN ? 'C' : 'c', + field3 & TRB_NO_SNOOP ? 'S' : 's', + field3 & TRB_ISP ? 'I' : 'i', + field3 & TRB_ENT ? 'E' : 'e', + field3 & TRB_CYCLE ? 'C' : 'c'); + break; + case TRB_STATUS: + sprintf(str, "Buffer %08x%08x length %d TD size %d intr" + "%d type '%s' flags %c:%c:%c:%c", + field1, field0, TRB_LEN(field2), + GET_TD_SIZE(field2), + GET_INTR_TARGET(field2), + usbssp_trb_type_string(type), + field3 & TRB_IOC ? 'I' : 'i', + field3 & TRB_CHAIN ? 'C' : 'c', + field3 & TRB_ENT ? 'E' : 'e', + field3 & TRB_CYCLE ? 'C' : 'c'); + break; + case TRB_NORMAL: + case TRB_ISOC: + case TRB_EVENT_DATA: + case TRB_TR_NOOP: + sprintf(str, + "Buffer %08x%08x length %d TD size %d intr %d " + "type '%s' flags %c:%c:%c:%c:%c:%c:%c:%c", + field1, field0, TRB_LEN(field2), GET_TD_SIZE(field2), + GET_INTR_TARGET(field2), + usbssp_trb_type_string(type), + field3 & TRB_BEI ? 'B' : 'b', + field3 & TRB_IDT ? 'I' : 'i', + field3 & TRB_IOC ? 'I' : 'i', + field3 & TRB_CHAIN ? 'C' : 'c', + field3 & TRB_NO_SNOOP ? 'S' : 's', + field3 & TRB_ISP ? 'I' : 'i', + field3 & TRB_ENT ? 'E' : 'e', + field3 & TRB_CYCLE ? 'C' : 'c'); + break; + + case TRB_CMD_NOOP: + case TRB_ENABLE_SLOT: + sprintf(str, + "%s: flags %c", + usbssp_trb_type_string(type), + field3 & TRB_CYCLE ? 'C' : 'c'); + break; + case TRB_DISABLE_SLOT: + sprintf(str, + "%s: slot %d flags %c", + usbssp_trb_type_string(type), + TRB_TO_SLOT_ID(field3), + field3 & TRB_CYCLE ? 'C' : 'c'); + break; + case TRB_ADDR_DEV: + sprintf(str, + "%s: ctx %08x%08x slot %d flags %c:%c", + usbssp_trb_type_string(type), + field1, field0, + TRB_TO_SLOT_ID(field3), + field3 & TRB_BSR ? 'B' : 'b', + field3 & TRB_CYCLE ? 'C' : 'c'); + break; + case TRB_CONFIG_EP: + sprintf(str, + "%s: ctx %08x%08x slot %d flags %c:%c", + usbssp_trb_type_string(type), + field1, field0, + TRB_TO_SLOT_ID(field3), + field3 & TRB_DC ? 'D' : 'd', + field3 & TRB_CYCLE ? 'C' : 'c'); + break; + case TRB_EVAL_CONTEXT: + sprintf(str, + "%s: ctx %08x%08x slot %d flags %c", + usbssp_trb_type_string(type), + field1, field0, + TRB_TO_SLOT_ID(field3), + field3 & TRB_CYCLE ? 'C' : 'c'); + break; + case TRB_RESET_EP: + sprintf(str, + "%s: ctx %08x%08x slot %d ep %d flags %c", + usbssp_trb_type_string(type), + field1, field0, + TRB_TO_SLOT_ID(field3), + /* Macro decrements 1, maybe it shouldn't?!? */ + TRB_TO_EP_INDEX(field3) + 1, + field3 & TRB_CYCLE ? 'C' : 'c'); + break; + case TRB_STOP_RING: + sprintf(str, + "%s: slot %d sp %d ep %d flags %c", + usbssp_trb_type_string(type), + TRB_TO_SLOT_ID(field3), + TRB_TO_SUSPEND_PORT(field3), + /* Macro decrements 1, maybe it shouldn't?!? */ + TRB_TO_EP_INDEX(field3) + 1, + field3 & TRB_CYCLE ? 'C' : 'c'); + break; + case TRB_SET_DEQ: + sprintf(str, + "%s: deq %08x%08x stream %d slot %d ep %d flags %c", + usbssp_trb_type_string(type), + field1, field0, + TRB_TO_STREAM_ID(field2), + TRB_TO_SLOT_ID(field3), + /* Macro decrements 1, maybe it shouldn't?!? */ + TRB_TO_EP_INDEX(field3) + 1, + field3 & TRB_CYCLE ? 'C' : 'c'); + break; + case TRB_RESET_DEV: + sprintf(str, + "%s: slot %d flags %c", + usbssp_trb_type_string(type), + TRB_TO_SLOT_ID(field3), + field3 & TRB_CYCLE ? 'C' : 'c'); + break; + case TRB_FORCE_EVENT: + sprintf(str, + "%s: event %08x%08x vf intr %d vf id %d flags %c", + usbssp_trb_type_string(type), + field1, field0, + TRB_TO_VF_INTR_TARGET(field2), + TRB_TO_VF_ID(field3), + field3 & TRB_CYCLE ? 'C' : 'c'); + break; + case TRB_SET_LT: + sprintf(str, + "%s: belt %d flags %c", + usbssp_trb_type_string(type), + TRB_TO_BELT(field3), + field3 & TRB_CYCLE ? 'C' : 'c'); + break; + case TRB_FORCE_HEADER: + sprintf(str, + "%s: info %08x%08x%08x pkt type %d roothub port %d flags %c", + usbssp_trb_type_string(type), + field2, field1, field0 & 0xffffffe0, + TRB_TO_PACKET_TYPE(field0), + TRB_TO_DEV_PORT(field3), + field3 & TRB_CYCLE ? 'C' : 'c'); + break; + default: + sprintf(str, + "type '%s' -> raw %08x %08x %08x %08x", + usbssp_trb_type_string(type), + field0, field1, field2, field3); + } + + return str; +} + +static inline const char *usbssp_decode_slot_context(u32 info, u32 info2, + u32 int_target, u32 state) +{ + static char str[1024]; + u32 speed; + int ret = 0; + + speed = info & DEV_SPEED; + + ret = sprintf(str, "%s Ctx Entries %d MEL %d us", + ({ char *s; + switch (speed) { + case SLOT_SPEED_FS: + s = "full-speed"; + break; + case SLOT_SPEED_LS: + s = "low-speed"; + break; + case SLOT_SPEED_HS: + s = "high-speed"; + break; + case SLOT_SPEED_SS: + s = "super-speed"; + break; + case SLOT_SPEED_SSP: + s = "super-speed plus"; + break; + default: + s = "UNKNOWN speed"; + } s; }), + (info & LAST_CTX_MASK) >> 27, + info2 & MAX_EXIT); + + ret += sprintf(str + ret, " [Intr %d] Addr %d State %s", + GET_INTR_TARGET(int_target), + state & DEV_ADDR_MASK, + usbssp_slot_state_string(GET_SLOT_STATE(state))); + + return str; +} + + +static inline const char *usbssp_portsc_link_state_string(u32 portsc) +{ + switch (portsc & PORT_PLS_MASK) { + case XDEV_U0: + return "U0"; + case XDEV_U1: + return "U1"; + case XDEV_U2: + return "U2"; + case XDEV_U3: + return "U3"; + case XDEV_DISABLED: + return "Disabled"; + case XDEV_RXDETECT: + return "RxDetect"; + case XDEV_INACTIVE: + return "Inactive"; + case XDEV_POLLING: + return "Polling"; + case XDEV_RECOVERY: + return "Recovery"; + case XDEV_HOT_RESET: + return "Hot Reset"; + case XDEV_COMP_MODE: + return "Compliance mode"; + case XDEV_TEST_MODE: + return "Test mode"; + case XDEV_RESUME: + return "Resume"; + default: + break; + } + return "Unknown"; +} + +static inline const char *usbssp_decode_portsc(u32 portsc) +{ + static char str[256]; + int ret; + + ret = sprintf(str, "%s %s %s Link:%s PortSpeed:%d ", + portsc & PORT_POWER ? "Powered" : "Powered-off", + portsc & PORT_CONNECT ? "Connected" : "Not-connected", + portsc & PORT_PE ? "Enabled" : "Disabled", + usbssp_portsc_link_state_string(portsc), + DEV_PORT_SPEED(portsc)); + + if (portsc & PORT_OC) + ret += sprintf(str + ret, "OverCurrent "); + if (portsc & PORT_RESET) + ret += sprintf(str + ret, "In-Reset "); + + ret += sprintf(str + ret, "Change: "); + if (portsc & PORT_CSC) + ret += sprintf(str + ret, "CSC "); + if (portsc & PORT_PEC) + ret += sprintf(str + ret, "PEC "); + if (portsc & PORT_WRC) + ret += sprintf(str + ret, "WRC "); + if (portsc & PORT_OCC) + ret += sprintf(str + ret, "OCC "); + if (portsc & PORT_RC) + ret += sprintf(str + ret, "PRC "); + if (portsc & PORT_PLC) + ret += sprintf(str + ret, "PLC "); + if (portsc & PORT_CEC) + ret += sprintf(str + ret, "CEC "); + ret += sprintf(str + ret, "Wake: "); + if (portsc & PORT_WKCONN_E) + ret += sprintf(str + ret, "WCE "); + if (portsc & PORT_WKDISC_E) + ret += sprintf(str + ret, "WDE "); + if (portsc & PORT_WKOC_E) + ret += sprintf(str + ret, "WOE "); + + return str; +} + +static inline const char *usbssp_ep_state_string(u8 state) +{ + switch (state) { + case EP_STATE_DISABLED: + return "disabled"; + case EP_STATE_RUNNING: + return "running"; + case EP_STATE_HALTED: + return "halted"; + case EP_STATE_STOPPED: + return "stopped"; + case EP_STATE_ERROR: + return "error"; + default: + return "INVALID"; + } +} + +static inline const char *usbssp_ep_type_string(u8 type) +{ + switch (type) { + case ISOC_OUT_EP: + return "Isoc OUT"; + case BULK_OUT_EP: + return "Bulk OUT"; + case INT_OUT_EP: + return "Int OUT"; + case CTRL_EP: + return "Ctrl"; + case ISOC_IN_EP: + return "Isoc IN"; + case BULK_IN_EP: + return "Bulk IN"; + case INT_IN_EP: + return "Int IN"; + default: + return "INVALID"; + } +} + +static inline const char *usbssp_decode_ep_context(u32 info, u32 info2, u64 deq, + u32 tx_info) +{ + static char str[1024]; + int ret; + + u32 esit; + u16 maxp; + u16 avg; + + u8 max_pstr; + u8 ep_state; + u8 interval; + u8 ep_type; + u8 burst; + u8 cerr; + u8 mult; + + bool lsa; + bool hid; + + esit = CTX_TO_MAX_ESIT_PAYLOAD_HI(info) << 16 | + CTX_TO_MAX_ESIT_PAYLOAD(tx_info); + + ep_state = info & EP_STATE_MASK; + max_pstr = CTX_TO_EP_MAXPSTREAMS(info); + interval = CTX_TO_EP_INTERVAL(info); + mult = CTX_TO_EP_MULT(info) + 1; + lsa = !!(info & EP_HAS_LSA); + + cerr = (info2 & (3 << 1)) >> 1; + ep_type = CTX_TO_EP_TYPE(info2); + hid = !!(info2 & (1 << 7)); + burst = CTX_TO_MAX_BURST(info2); + maxp = MAX_PACKET_DECODED(info2); + + avg = EP_AVG_TRB_LENGTH(tx_info); + + ret = sprintf(str, "State %s mult %d max P. Streams %d %s", + usbssp_ep_state_string(ep_state), mult, + max_pstr, lsa ? "LSA " : ""); + + ret += sprintf(str + ret, "interval %d us max ESIT payload %d CErr %d ", + (1 << interval) * 125, esit, cerr); + + ret += sprintf(str + ret, "Type %s %sburst %d maxp %d deq %016llx ", + usbssp_ep_type_string(ep_type), hid ? "HID" : "", + burst, maxp, deq); + + ret += sprintf(str + ret, "avg trb len %d", avg); + + return str; +} + +/** + * next_request - gets the next request on the given list + * @list: the request list to operate on + * + * Caller should take care of locking. This function return %NULL or the first + * request available on @list. + */ +static inline struct usbssp_request *next_request(struct list_head *list) +{ + return list_first_entry_or_null(list, struct usbssp_request, list); +} + +struct usbssp_udc; +#define to_usbssp_ep(ep) (container_of(ep, struct usbssp_ep, endpoint)) +#define gadget_to_usbssp(g) (container_of(g, struct usbssp_udc, gadget)) +#define request_to_usbssp_request(r) (container_of(r, struct usbssp_request, request)) + +#define to_usbssp_request(r) (container_of(r, struct usbssp_request, request)) + #endif /* __LINUX_USBSSP_GADGET_H */ -- 2.17.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [02/31] usb: usbssp: Added some decoding functions. From: Pawel Laszczak Message-Id: <1531374448-26532-3-git-send-email-pawell@cadence.com> Date: Thu, 12 Jul 2018 06:46:59 +0100 Cc: Greg Kroah-Hartman , linux-usb@vger.kernel.org, Felipe Balbi , linux-kernel@vger.kernel.org, ltyrala@cadence.com, adouglas@cadence.com, pawell@cadence.com List-ID: VGhpcyBwYXRjaCBhZGQgYWRkaXRpb25hbCBmdW5jdGlvbnMgdGhhdCBjb252ZXJ0cyBzb21lIGZp ZWxkcyB0byBzdHJpbmcuCgpGb3IgZXhhbXBsZSBmdW5jdGlvbiB1c2Jzc3BfdHJiX2NvbXBfY29k ZV9zdHJpbmcgdGFrZSBjb21wbGV0aW9uIGMKb2RlIHZhbHVlIGFuZCByZXR1cm4gc3RyaW5nIGRl c2NyaWJpbmcgY29tcGxldGlvbiBjb2RlLgoKU2lnbmVkLW9mZi1ieTogUGF3ZWwgTGFzemN6YWsg PHBhd2VsbEBjYWRlbmNlLmNvbT4KLS0tCiBkcml2ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0LmggfCA1 NzIgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAxIGZpbGUgY2hhbmdlZCwg NTcyIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0 LmggYi9kcml2ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0LmgKaW5kZXggNDg2ZTg2ODA2OGI3Li42YjYz NGRjNjNkOWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3VzYnNzcC9nYWRnZXQuaAorKysgYi9k cml2ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0LmgKQEAgLTkyMiw2ICs5MjIsNzMgQEAgc3RydWN0IHVz YnNzcF90cmFuc2Zlcl9ldmVudCB7CiAjZGVmaW5lIENPTVBfVU5ERUZJTkVEX0VSUk9SCQkzMwog I2RlZmluZSBDT01QX0lOVkFMSURfU1RSRUFNX0lEX0VSUk9SCTM0CiAKK3N0YXRpYyBpbmxpbmUg Y29uc3QgY2hhciAqdXNic3NwX3RyYl9jb21wX2NvZGVfc3RyaW5nKHU4IHN0YXR1cykKK3sKKwlz d2l0Y2ggKHN0YXR1cykgeworCWNhc2UgQ09NUF9JTlZBTElEOgorCQlyZXR1cm4gIkludmFsaWQi OworCWNhc2UgQ09NUF9TVUNDRVNTOgorCQlyZXR1cm4gIlN1Y2Nlc3MiOworCWNhc2UgQ09NUF9E QVRBX0JVRkZFUl9FUlJPUjoKKwkJcmV0dXJuICJEYXRhIEJ1ZmZlciBFcnJvciI7CisJY2FzZSBD T01QX0JBQkJMRV9ERVRFQ1RFRF9FUlJPUjoKKwkJcmV0dXJuICJCYWJibGUgRGV0ZWN0ZWQiOwor CWNhc2UgQ09NUF9VU0JfVFJBTlNBQ1RJT05fRVJST1I6CisJCXJldHVybiAiVVNCIFRyYW5zYWN0 aW9uIEVycm9yIjsKKwljYXNlIENPTVBfVFJCX0VSUk9SOgorCQlyZXR1cm4gIlRSQiBFcnJvciI7 CisJY2FzZSBDT01QX1JFU09VUkNFX0VSUk9SOgorCQlyZXR1cm4gIlJlc291cmNlIEVycm9yIjsK KwljYXNlIENPTVBfTk9fU0xPVFNfQVZBSUxBQkxFX0VSUk9SOgorCQlyZXR1cm4gIk5vIFNsb3Rz IEF2YWlsYWJsZSBFcnJvciI7CisJY2FzZSBDT01QX0lOVkFMSURfU1RSRUFNX1RZUEVfRVJST1I6 CisJCXJldHVybiAiSW52YWxpZCBTdHJlYW0gVHlwZSBFcnJvciI7CisJY2FzZSBDT01QX1NMT1Rf Tk9UX0VOQUJMRURfRVJST1I6CisJCXJldHVybiAiU2xvdCBOb3QgRW5hYmxlZCBFcnJvciI7CisJ Y2FzZSBDT01QX0VORFBPSU5UX05PVF9FTkFCTEVEX0VSUk9SOgorCQlyZXR1cm4gIkVuZHBvaW50 IE5vdCBFbmFibGVkIEVycm9yIjsKKwljYXNlIENPTVBfU0hPUlRfUEFDS0VUOgorCQlyZXR1cm4g IlNob3J0IFBhY2tldCI7CisJY2FzZSBDT01QX1JJTkdfVU5ERVJSVU46CisJCXJldHVybiAiUmlu ZyBVbmRlcnJ1biI7CisJY2FzZSBDT01QX1JJTkdfT1ZFUlJVTjoKKwkJcmV0dXJuICJSaW5nIE92 ZXJydW4iOworCWNhc2UgQ09NUF9WRl9FVkVOVF9SSU5HX0ZVTExfRVJST1I6CisJCXJldHVybiAi VkYgRXZlbnQgUmluZyBGdWxsIEVycm9yIjsKKwljYXNlIENPTVBfUEFSQU1FVEVSX0VSUk9SOgor CQlyZXR1cm4gIlBhcmFtZXRlciBFcnJvciI7CisJY2FzZSBDT01QX0NPTlRFWFRfU1RBVEVfRVJS T1I6CisJCXJldHVybiAiQ29udGV4dCBTdGF0ZSBFcnJvciI7CisJY2FzZSBDT01QX0VWRU5UX1JJ TkdfRlVMTF9FUlJPUjoKKwkJcmV0dXJuICJFdmVudCBSaW5nIEZ1bGwgRXJyb3IiOworCWNhc2Ug Q09NUF9JTkNPTVBBVElCTEVfREVWSUNFX0VSUk9SOgorCQlyZXR1cm4gIkluY29tcGF0aWJsZSBE ZXZpY2UgRXJyb3IiOworCWNhc2UgQ09NUF9NSVNTRURfU0VSVklDRV9FUlJPUjoKKwkJcmV0dXJu ICJNaXNzZWQgU2VydmljZSBFcnJvciI7CisJY2FzZSBDT01QX0NPTU1BTkRfUklOR19TVE9QUEVE OgorCQlyZXR1cm4gIkNvbW1hbmQgUmluZyBTdG9wcGVkIjsKKwljYXNlIENPTVBfQ09NTUFORF9B Qk9SVEVEOgorCQlyZXR1cm4gIkNvbW1hbmQgQWJvcnRlZCI7CisJY2FzZSBDT01QX1NUT1BQRUQ6 CisJCXJldHVybiAiU3RvcHBlZCI7CisJY2FzZSBDT01QX1NUT1BQRURfTEVOR1RIX0lOVkFMSUQ6 CisJCXJldHVybiAiU3RvcHBlZCAtIExlbmd0aCBJbnZhbGlkIjsKKwljYXNlIENPTVBfU1RPUFBF RF9TSE9SVF9QQUNLRVQ6CisJCXJldHVybiAiU3RvcHBlZCAtIFNob3J0IFBhY2tldCI7CisJY2Fz ZSBDT01QX01BWF9FWElUX0xBVEVOQ1lfVE9PX0xBUkdFX0VSUk9SOgorCQlyZXR1cm4gIk1heCBF eGl0IExhdGVuY3kgVG9vIExhcmdlIEVycm9yIjsKKwljYXNlIENPTVBfSVNPQ0hfQlVGRkVSX09W RVJSVU46CisJCXJldHVybiAiSXNvY2ggQnVmZmVyIE92ZXJydW4iOworCWNhc2UgQ09NUF9FVkVO VF9MT1NUX0VSUk9SOgorCQlyZXR1cm4gIkV2ZW50IExvc3QgRXJyb3IiOworCWNhc2UgQ09NUF9V TkRFRklORURfRVJST1I6CisJCXJldHVybiAiVW5kZWZpbmVkIEVycm9yIjsKKwljYXNlIENPTVBf SU5WQUxJRF9TVFJFQU1fSURfRVJST1I6CisJCXJldHVybiAiSW52YWxpZCBTdHJlYW0gSUQgRXJy b3IiOworCWRlZmF1bHQ6CisJCXJldHVybiAiVW5rbm93biEhIjsKKwl9Cit9CiBzdHJ1Y3QgdXNi c3NwX2xpbmtfdHJiIHsKIAkvKiA2NC1iaXQgc2VnbWVudCBwb2ludGVyKi8KIAlfX2xlNjQgc2Vn bWVudF9wdHI7CkBAIC0xMjc0LDYgKzEzNDEsMjcgQEAgZW51bSB1c2Jzc3BfcmluZ190eXBlIHsK IAlUWVBFX0VWRU5ULAogfTsKIAorc3RhdGljIGlubGluZSBjb25zdCBjaGFyICp1c2Jzc3Bfcmlu Z190eXBlX3N0cmluZyhlbnVtIHVzYnNzcF9yaW5nX3R5cGUgdHlwZSkKK3sKKwlzd2l0Y2ggKHR5 cGUpIHsKKwljYXNlIFRZUEVfQ1RSTDoKKwkJcmV0dXJuICJDVFJMIjsKKwljYXNlIFRZUEVfSVNP QzoKKwkJcmV0dXJuICJJU09DIjsKKwljYXNlIFRZUEVfQlVMSzoKKwkJcmV0dXJuICJCVUxLIjsK KwljYXNlIFRZUEVfSU5UUjoKKwkJcmV0dXJuICJJTlRSIjsKKwljYXNlIFRZUEVfU1RSRUFNOgor CQlyZXR1cm4gIlNUUkVBTSI7CisJY2FzZSBUWVBFX0NPTU1BTkQ6CisJCXJldHVybiAiQ01EIjsK KwljYXNlIFRZUEVfRVZFTlQ6CisJCXJldHVybiAiRVZFTlQiOworCX0KKworCXJldHVybiAiVU5L Tk9XTiI7Cit9CiBzdHJ1Y3QgdXNic3NwX3JpbmcgewogCXN0cnVjdCB1c2Jzc3Bfc2VnbWVudAkq Zmlyc3Rfc2VnOwogCXN0cnVjdCB1c2Jzc3Bfc2VnbWVudAkqbGFzdF9zZWc7CkBAIC0xNTY0LDQg KzE2NTIsNDg4IEBAIHN0cnVjdCB1c2Jzc3BfdWRjIHsKICNkZWZpbmUgdXNic3NwX2luZm8odXNi c3NwX2RhdGEsIGZtdCwgYXJncy4uLikgXAogCWRldl9pbmZvKHVzYnNzcF9kYXRhLT5kZXYsIGZt dCwgIyMgYXJncykKIAorLyoKKyAqIFJlZ2lzdGVycyBzaG91bGQgYWx3YXlzIGJlIGFjY2Vzc2Vk IHdpdGggZG91YmxlIHdvcmQgb3IgcXVhZCB3b3JkIGFjY2Vzc2VzLgorICoKKyAqIFJlZ2lzdGVy cyB3aXRoIDY0LWJpdCBhZGRyZXNzIHBvaW50ZXJzIHNob3VsZCBiZSB3cml0dGVuIHRvIHdpdGgK KyAqIGR3b3JkIGFjY2Vzc2VzIGJ5IHdyaXRpbmcgdGhlIGxvdyBkd29yZCBmaXJzdCAocHRyWzBd KSwgdGhlbiB0aGUgaGlnaCBkd29yZAorICogKHB0clsxXSkgc2Vjb25kLiBEQyBpbXBsZW1lbnRh dGlvbnMgdGhhdCBkbyBub3Qgc3VwcG9ydCA2NC1iaXQgYWRkcmVzcworICogcG9pbnRlcnMgd2ls bCBpZ25vcmUgdGhlIGhpZ2ggZHdvcmQsIGFuZCB3cml0ZSBvcmRlciBpcyBpcnJlbGV2YW50Lgor ICovCitzdGF0aWMgaW5saW5lIHU2NCB1c2Jzc3BfcmVhZF82NChjb25zdCBzdHJ1Y3QgdXNic3Nw X3VkYyAqdXNic3NwX2RhdGEsCisJCV9fbGU2NCBfX2lvbWVtICpyZWdzKQoreworCXJldHVybiBs b19oaV9yZWFkcShyZWdzKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIHVzYnNzcF93cml0ZV82 NChzdHJ1Y3QgdXNic3NwX3VkYyAqdXNic3NwX2RhdGEsCisJCQkJIGNvbnN0IHU2NCB2YWwsIF9f bGU2NCBfX2lvbWVtICpyZWdzKQoreworCWxvX2hpX3dyaXRlcSh2YWwsIHJlZ3MpOworfQorc3Rh dGljIGlubGluZSBjaGFyICp1c2Jzc3Bfc2xvdF9zdGF0ZV9zdHJpbmcodTMyIHN0YXRlKQorewor CXN3aXRjaCAoc3RhdGUpIHsKKwljYXNlIFNMT1RfU1RBVEVfRU5BQkxFRDoKKwkJcmV0dXJuICJl bmFibGVkL2Rpc2FibGVkIjsKKwljYXNlIFNMT1RfU1RBVEVfREVGQVVMVDoKKwkJcmV0dXJuICJk ZWZhdWx0IjsKKwljYXNlIFNMT1RfU1RBVEVfQUREUkVTU0VEOgorCQlyZXR1cm4gImFkZHJlc3Nl ZCI7CisJY2FzZSBTTE9UX1NUQVRFX0NPTkZJR1VSRUQ6CisJCXJldHVybiAiY29uZmlndXJlZCI7 CisJZGVmYXVsdDoKKwkJcmV0dXJuICJyZXNlcnZlZCI7CisJfQorfQorCitzdGF0aWMgaW5saW5l IGNvbnN0IGNoYXIgKnVzYnNzcF9kZWNvZGVfdHJiKHUzMiBmaWVsZDAsIHUzMiBmaWVsZDEsIHUz MiBmaWVsZDIsCisJCXUzMiBmaWVsZDMpCit7CisJc3RhdGljIGNoYXIgc3RyWzI1Nl07CisJaW50 IHR5cGUgPSBUUkJfRklFTERfVE9fVFlQRShmaWVsZDMpOworCisJc3dpdGNoICh0eXBlKSB7CisJ Y2FzZSBUUkJfTElOSzoKKwkJc3ByaW50ZihzdHIsCisJCQkiTElOSyAlMDh4JTA4eCBpbnRyICVk IHR5cGUgJyVzJyBmbGFncyAlYzolYzolYzolYyIsCisJCQlmaWVsZDEsIGZpZWxkMCwgR0VUX0lO VFJfVEFSR0VUKGZpZWxkMiksCisJCQl1c2Jzc3BfdHJiX3R5cGVfc3RyaW5nKHR5cGUpLAorCQkJ ZmllbGQzICYgVFJCX0lPQyA/ICdJJyA6ICdpJywKKwkJCWZpZWxkMyAmIFRSQl9DSEFJTiA/ICdD JyA6ICdjJywKKwkJCWZpZWxkMyAmIFRSQl9UQyA/ICdUJyA6ICd0JywKKwkJCWZpZWxkMyAmIFRS Ql9DWUNMRSA/ICdDJyA6ICdjJyk7CisJCWJyZWFrOworCWNhc2UgVFJCX1RSQU5TRkVSOgorCWNh c2UgVFJCX0NPTVBMRVRJT046CisJY2FzZSBUUkJfUE9SVF9TVEFUVVM6CisJY2FzZSBUUkJfRE9P UkJFTEw6CisJY2FzZSBUUkJfSENfRVZFTlQ6CisJY2FzZSBUUkJfREVWX05PVEU6CisJY2FzZSBU UkJfTUZJTkRFWF9XUkFQOgorCQlzcHJpbnRmKHN0ciwKKwkJCSJUUkIgJTA4eCUwOHggc3RhdHVz ICclcycgbGVuICVkIHNsb3QgJWQgZXAgJWQ6PToiCisJCQkidHlwZSAnJXMnIGZsYWdzICVjOiVj IiwKKwkJCWZpZWxkMSwgZmllbGQwLAorCQkJdXNic3NwX3RyYl9jb21wX2NvZGVfc3RyaW5nKEdF VF9DT01QX0NPREUoZmllbGQyKSksCisJCQlFVkVOVF9UUkJfTEVOKGZpZWxkMiksIFRSQl9UT19T TE9UX0lEKGZpZWxkMyksCisJCQkvKiBNYWNybyBkZWNyZW1lbnRzIDEsIG1heWJlIGl0IHNob3Vs ZG4ndD8hPyAqLworCQkJVFJCX1RPX0VQX0lOREVYKGZpZWxkMykgKyAxLAorCQkJdXNic3NwX3Ry Yl90eXBlX3N0cmluZyh0eXBlKSwKKwkJCWZpZWxkMyAmIEVWRU5UX0RBVEEgPyAnRScgOiAnZScs CisJCQlmaWVsZDMgJiBUUkJfQ1lDTEUgPyAnQycgOiAnYycpOworCisJCWJyZWFrOworCWNhc2Ug VFJCX1NFVFVQOgorCQlzcHJpbnRmKHN0ciwgImJSZXF1ZXN0VHlwZSAlMDJ4IGJSZXF1ZXN0ICUw Mnggd1ZhbHVlICUwMnglMDJ4ICIKKwkJCQkid0luZGV4ICUwMnglMDJ4IHdMZW5ndGggJWQgbGVu Z3RoICVkICIKKwkJCQkiVEQgc2l6ZSAlZCBpbnRyICVkIHR5cGUgJyVzJyBmbGFncyAlYzolYzol YyIsCisJCQkJZmllbGQwICYgMHhmZiwKKwkJCQkoZmllbGQwICYgMHhmZjAwKSA+PiA4LAorCQkJ CShmaWVsZDAgJiAweGZmMDAwMDAwKSA+PiAyNCwKKwkJCQkoZmllbGQwICYgMHhmZjAwMDApID4+ IDE2LAorCQkJCShmaWVsZDEgJiAweGZmMDApID4+IDgsCisJCQkJZmllbGQxICYgMHhmZiwKKwkJ CQkoZmllbGQxICYgMHhmZjAwMDAwMCkgPj4gMTYgfAorCQkJCShmaWVsZDEgJiAweGZmMDAwMCkg Pj4gMTYsCisJCQkJVFJCX0xFTihmaWVsZDIpLCBHRVRfVERfU0laRShmaWVsZDIpLAorCQkJCUdF VF9JTlRSX1RBUkdFVChmaWVsZDIpLAorCQkJCXVzYnNzcF90cmJfdHlwZV9zdHJpbmcodHlwZSks CisJCQkJZmllbGQzICYgVFJCX0lEVCA/ICdJJyA6ICdpJywKKwkJCQlmaWVsZDMgJiBUUkJfSU9D ID8gJ0knIDogJ2knLAorCQkJCWZpZWxkMyAmIFRSQl9DWUNMRSA/ICdDJyA6ICdjJyk7CisJCWJy ZWFrOworCWNhc2UgVFJCX0RBVEE6CisJCXNwcmludGYoc3RyLCAiQnVmZmVyICUwOHglMDh4IGxl bmd0aCAlZCBURCBzaXplICVkIGludHIgJWQgIgorCQkJCSJ0eXBlICclcycgZmxhZ3MgJWM6JWM6 JWM6JWM6JWM6JWM6JWMiLAorCQkJCWZpZWxkMSwgZmllbGQwLCBUUkJfTEVOKGZpZWxkMiksCisJ CQkJR0VUX1REX1NJWkUoZmllbGQyKSwKKwkJCQlHRVRfSU5UUl9UQVJHRVQoZmllbGQyKSwKKwkJ CQl1c2Jzc3BfdHJiX3R5cGVfc3RyaW5nKHR5cGUpLAorCQkJCWZpZWxkMyAmIFRSQl9JRFQgPyAn SScgOiAnaScsCisJCQkJZmllbGQzICYgVFJCX0lPQyA/ICdJJyA6ICdpJywKKwkJCQlmaWVsZDMg JiBUUkJfQ0hBSU4gPyAnQycgOiAnYycsCisJCQkJZmllbGQzICYgVFJCX05PX1NOT09QID8gJ1Mn IDogJ3MnLAorCQkJCWZpZWxkMyAmIFRSQl9JU1AgPyAnSScgOiAnaScsCisJCQkJZmllbGQzICYg VFJCX0VOVCA/ICdFJyA6ICdlJywKKwkJCQlmaWVsZDMgJiBUUkJfQ1lDTEUgPyAnQycgOiAnYycp OworCQlicmVhazsKKwljYXNlIFRSQl9TVEFUVVM6CisJCXNwcmludGYoc3RyLCAiQnVmZmVyICUw OHglMDh4IGxlbmd0aCAlZCBURCBzaXplICVkIGludHIiCisJCQkJIiVkIHR5cGUgJyVzJyBmbGFn cyAlYzolYzolYzolYyIsCisJCQkJZmllbGQxLCBmaWVsZDAsIFRSQl9MRU4oZmllbGQyKSwKKwkJ CQlHRVRfVERfU0laRShmaWVsZDIpLAorCQkJCUdFVF9JTlRSX1RBUkdFVChmaWVsZDIpLAorCQkJ CXVzYnNzcF90cmJfdHlwZV9zdHJpbmcodHlwZSksCisJCQkJZmllbGQzICYgVFJCX0lPQyA/ICdJ JyA6ICdpJywKKwkJCQlmaWVsZDMgJiBUUkJfQ0hBSU4gPyAnQycgOiAnYycsCisJCQkJZmllbGQz ICYgVFJCX0VOVCA/ICdFJyA6ICdlJywKKwkJCQlmaWVsZDMgJiBUUkJfQ1lDTEUgPyAnQycgOiAn YycpOworCQlicmVhazsKKwljYXNlIFRSQl9OT1JNQUw6CisJY2FzZSBUUkJfSVNPQzoKKwljYXNl IFRSQl9FVkVOVF9EQVRBOgorCWNhc2UgVFJCX1RSX05PT1A6CisJCXNwcmludGYoc3RyLAorCQkJ IkJ1ZmZlciAlMDh4JTA4eCBsZW5ndGggJWQgVEQgc2l6ZSAlZCBpbnRyICVkICIKKwkJCSJ0eXBl ICclcycgZmxhZ3MgJWM6JWM6JWM6JWM6JWM6JWM6JWM6JWMiLAorCQkJZmllbGQxLCBmaWVsZDAs IFRSQl9MRU4oZmllbGQyKSwgR0VUX1REX1NJWkUoZmllbGQyKSwKKwkJCUdFVF9JTlRSX1RBUkdF VChmaWVsZDIpLAorCQkJdXNic3NwX3RyYl90eXBlX3N0cmluZyh0eXBlKSwKKwkJCWZpZWxkMyAm IFRSQl9CRUkgPyAnQicgOiAnYicsCisJCQlmaWVsZDMgJiBUUkJfSURUID8gJ0knIDogJ2knLAor CQkJZmllbGQzICYgVFJCX0lPQyA/ICdJJyA6ICdpJywKKwkJCWZpZWxkMyAmIFRSQl9DSEFJTiA/ ICdDJyA6ICdjJywKKwkJCWZpZWxkMyAmIFRSQl9OT19TTk9PUCA/ICdTJyA6ICdzJywKKwkJCWZp ZWxkMyAmIFRSQl9JU1AgPyAnSScgOiAnaScsCisJCQlmaWVsZDMgJiBUUkJfRU5UID8gJ0UnIDog J2UnLAorCQkJZmllbGQzICYgVFJCX0NZQ0xFID8gJ0MnIDogJ2MnKTsKKwkJYnJlYWs7CisKKwlj YXNlIFRSQl9DTURfTk9PUDoKKwljYXNlIFRSQl9FTkFCTEVfU0xPVDoKKwkJc3ByaW50ZihzdHIs CisJCQkiJXM6IGZsYWdzICVjIiwKKwkJCXVzYnNzcF90cmJfdHlwZV9zdHJpbmcodHlwZSksCisJ CQlmaWVsZDMgJiBUUkJfQ1lDTEUgPyAnQycgOiAnYycpOworCQlicmVhazsKKwljYXNlIFRSQl9E SVNBQkxFX1NMT1Q6CisJCXNwcmludGYoc3RyLAorCQkJIiVzOiBzbG90ICVkIGZsYWdzICVjIiwK KwkJCXVzYnNzcF90cmJfdHlwZV9zdHJpbmcodHlwZSksCisJCQlUUkJfVE9fU0xPVF9JRChmaWVs ZDMpLAorCQkJZmllbGQzICYgVFJCX0NZQ0xFID8gJ0MnIDogJ2MnKTsKKwkJYnJlYWs7CisJY2Fz ZSBUUkJfQUREUl9ERVY6CisJCXNwcmludGYoc3RyLAorCQkJIiVzOiBjdHggJTA4eCUwOHggc2xv dCAlZCBmbGFncyAlYzolYyIsCisJCQl1c2Jzc3BfdHJiX3R5cGVfc3RyaW5nKHR5cGUpLAorCQkJ ZmllbGQxLCBmaWVsZDAsCisJCQlUUkJfVE9fU0xPVF9JRChmaWVsZDMpLAorCQkJZmllbGQzICYg VFJCX0JTUiA/ICdCJyA6ICdiJywKKwkJCWZpZWxkMyAmIFRSQl9DWUNMRSA/ICdDJyA6ICdjJyk7 CisJCWJyZWFrOworCWNhc2UgVFJCX0NPTkZJR19FUDoKKwkJc3ByaW50ZihzdHIsCisJCQkiJXM6 IGN0eCAlMDh4JTA4eCBzbG90ICVkIGZsYWdzICVjOiVjIiwKKwkJCXVzYnNzcF90cmJfdHlwZV9z dHJpbmcodHlwZSksCisJCQlmaWVsZDEsIGZpZWxkMCwKKwkJCVRSQl9UT19TTE9UX0lEKGZpZWxk MyksCisJCQlmaWVsZDMgJiBUUkJfREMgPyAnRCcgOiAnZCcsCisJCQlmaWVsZDMgJiBUUkJfQ1lD TEUgPyAnQycgOiAnYycpOworCQlicmVhazsKKwljYXNlIFRSQl9FVkFMX0NPTlRFWFQ6CisJCXNw cmludGYoc3RyLAorCQkJIiVzOiBjdHggJTA4eCUwOHggc2xvdCAlZCBmbGFncyAlYyIsCisJCQl1 c2Jzc3BfdHJiX3R5cGVfc3RyaW5nKHR5cGUpLAorCQkJZmllbGQxLCBmaWVsZDAsCisJCQlUUkJf VE9fU0xPVF9JRChmaWVsZDMpLAorCQkJZmllbGQzICYgVFJCX0NZQ0xFID8gJ0MnIDogJ2MnKTsK KwkJYnJlYWs7CisJY2FzZSBUUkJfUkVTRVRfRVA6CisJCXNwcmludGYoc3RyLAorCQkJIiVzOiBj dHggJTA4eCUwOHggc2xvdCAlZCBlcCAlZCBmbGFncyAlYyIsCisJCQl1c2Jzc3BfdHJiX3R5cGVf c3RyaW5nKHR5cGUpLAorCQkJZmllbGQxLCBmaWVsZDAsCisJCQlUUkJfVE9fU0xPVF9JRChmaWVs ZDMpLAorCQkJLyogTWFjcm8gZGVjcmVtZW50cyAxLCBtYXliZSBpdCBzaG91bGRuJ3Q/IT8gKi8K KwkJCVRSQl9UT19FUF9JTkRFWChmaWVsZDMpICsgMSwKKwkJCWZpZWxkMyAmIFRSQl9DWUNMRSA/ ICdDJyA6ICdjJyk7CisJCWJyZWFrOworCWNhc2UgVFJCX1NUT1BfUklORzoKKwkJc3ByaW50Zihz dHIsCisJCQkiJXM6IHNsb3QgJWQgc3AgJWQgZXAgJWQgZmxhZ3MgJWMiLAorCQkJdXNic3NwX3Ry Yl90eXBlX3N0cmluZyh0eXBlKSwKKwkJCVRSQl9UT19TTE9UX0lEKGZpZWxkMyksCisJCQlUUkJf VE9fU1VTUEVORF9QT1JUKGZpZWxkMyksCisJCQkvKiBNYWNybyBkZWNyZW1lbnRzIDEsIG1heWJl IGl0IHNob3VsZG4ndD8hPyAqLworCQkJVFJCX1RPX0VQX0lOREVYKGZpZWxkMykgKyAxLAorCQkJ ZmllbGQzICYgVFJCX0NZQ0xFID8gJ0MnIDogJ2MnKTsKKwkJYnJlYWs7CisJY2FzZSBUUkJfU0VU X0RFUToKKwkJc3ByaW50ZihzdHIsCisJCQkiJXM6IGRlcSAlMDh4JTA4eCBzdHJlYW0gJWQgc2xv dCAlZCBlcCAlZCBmbGFncyAlYyIsCisJCQl1c2Jzc3BfdHJiX3R5cGVfc3RyaW5nKHR5cGUpLAor CQkJZmllbGQxLCBmaWVsZDAsCisJCQlUUkJfVE9fU1RSRUFNX0lEKGZpZWxkMiksCisJCQlUUkJf VE9fU0xPVF9JRChmaWVsZDMpLAorCQkJLyogTWFjcm8gZGVjcmVtZW50cyAxLCBtYXliZSBpdCBz aG91bGRuJ3Q/IT8gKi8KKwkJCVRSQl9UT19FUF9JTkRFWChmaWVsZDMpICsgMSwKKwkJCWZpZWxk MyAmIFRSQl9DWUNMRSA/ICdDJyA6ICdjJyk7CisJCWJyZWFrOworCWNhc2UgVFJCX1JFU0VUX0RF VjoKKwkJc3ByaW50ZihzdHIsCisJCQkiJXM6IHNsb3QgJWQgZmxhZ3MgJWMiLAorCQkJdXNic3Nw X3RyYl90eXBlX3N0cmluZyh0eXBlKSwKKwkJCVRSQl9UT19TTE9UX0lEKGZpZWxkMyksCisJCQlm aWVsZDMgJiBUUkJfQ1lDTEUgPyAnQycgOiAnYycpOworCQlicmVhazsKKwljYXNlIFRSQl9GT1JD RV9FVkVOVDoKKwkJc3ByaW50ZihzdHIsCisJCQkiJXM6IGV2ZW50ICUwOHglMDh4IHZmIGludHIg JWQgdmYgaWQgJWQgZmxhZ3MgJWMiLAorCQkJdXNic3NwX3RyYl90eXBlX3N0cmluZyh0eXBlKSwK KwkJCWZpZWxkMSwgZmllbGQwLAorCQkJVFJCX1RPX1ZGX0lOVFJfVEFSR0VUKGZpZWxkMiksCisJ CQlUUkJfVE9fVkZfSUQoZmllbGQzKSwKKwkJCWZpZWxkMyAmIFRSQl9DWUNMRSA/ICdDJyA6ICdj Jyk7CisJCWJyZWFrOworCWNhc2UgVFJCX1NFVF9MVDoKKwkJc3ByaW50ZihzdHIsCisJCQkiJXM6 IGJlbHQgJWQgZmxhZ3MgJWMiLAorCQkJdXNic3NwX3RyYl90eXBlX3N0cmluZyh0eXBlKSwKKwkJ CVRSQl9UT19CRUxUKGZpZWxkMyksCisJCQlmaWVsZDMgJiBUUkJfQ1lDTEUgPyAnQycgOiAnYycp OworCQlicmVhazsKKwljYXNlIFRSQl9GT1JDRV9IRUFERVI6CisJCXNwcmludGYoc3RyLAorCQkJ IiVzOiBpbmZvICUwOHglMDh4JTA4eCBwa3QgdHlwZSAlZCByb290aHViIHBvcnQgJWQgZmxhZ3Mg JWMiLAorCQkJdXNic3NwX3RyYl90eXBlX3N0cmluZyh0eXBlKSwKKwkJCWZpZWxkMiwgZmllbGQx LCBmaWVsZDAgJiAweGZmZmZmZmUwLAorCQkJVFJCX1RPX1BBQ0tFVF9UWVBFKGZpZWxkMCksCisJ CQlUUkJfVE9fREVWX1BPUlQoZmllbGQzKSwKKwkJCWZpZWxkMyAmIFRSQl9DWUNMRSA/ICdDJyA6 ICdjJyk7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXNwcmludGYoc3RyLAorCQkJInR5cGUgJyVz JyAtPiByYXcgJTA4eCAlMDh4ICUwOHggJTA4eCIsCisJCQl1c2Jzc3BfdHJiX3R5cGVfc3RyaW5n KHR5cGUpLAorCQkJZmllbGQwLCBmaWVsZDEsIGZpZWxkMiwgZmllbGQzKTsKKwl9CisKKwlyZXR1 cm4gc3RyOworfQorCitzdGF0aWMgaW5saW5lIGNvbnN0IGNoYXIgKnVzYnNzcF9kZWNvZGVfc2xv dF9jb250ZXh0KHUzMiBpbmZvLCB1MzIgaW5mbzIsCisJCXUzMiBpbnRfdGFyZ2V0LCB1MzIgc3Rh dGUpCit7CisJc3RhdGljIGNoYXIgc3RyWzEwMjRdOworCXUzMiBzcGVlZDsKKwlpbnQgcmV0ID0g MDsKKworCXNwZWVkID0gaW5mbyAmIERFVl9TUEVFRDsKKworCXJldCA9IHNwcmludGYoc3RyLCAi JXMgQ3R4IEVudHJpZXMgJWQgTUVMICVkIHVzIiwKKwkJCSh7IGNoYXIgKnM7CisJCQlzd2l0Y2gg KHNwZWVkKSB7CisJCQljYXNlIFNMT1RfU1BFRURfRlM6CisJCQkJcyA9ICJmdWxsLXNwZWVkIjsK KwkJCQlicmVhazsKKwkJCWNhc2UgU0xPVF9TUEVFRF9MUzoKKwkJCQlzID0gImxvdy1zcGVlZCI7 CisJCQkJYnJlYWs7CisJCQljYXNlIFNMT1RfU1BFRURfSFM6CisJCQkJcyA9ICJoaWdoLXNwZWVk IjsKKwkJCQlicmVhazsKKwkJCWNhc2UgU0xPVF9TUEVFRF9TUzoKKwkJCQlzID0gInN1cGVyLXNw ZWVkIjsKKwkJCQlicmVhazsKKwkJCWNhc2UgU0xPVF9TUEVFRF9TU1A6CisJCQkJcyA9ICJzdXBl ci1zcGVlZCBwbHVzIjsKKwkJCQlicmVhazsKKwkJCWRlZmF1bHQ6CisJCQkJcyA9ICJVTktOT1dO IHNwZWVkIjsKKwkJCX0gczsgfSksCisJCQkoaW5mbyAmIExBU1RfQ1RYX01BU0spID4+IDI3LAor CQkJaW5mbzIgJiBNQVhfRVhJVCk7CisKKwlyZXQgKz0gc3ByaW50ZihzdHIgKyByZXQsICIgW0lu dHIgJWRdIEFkZHIgJWQgU3RhdGUgJXMiLAorCQkJR0VUX0lOVFJfVEFSR0VUKGludF90YXJnZXQp LAorCQkJc3RhdGUgJiBERVZfQUREUl9NQVNLLAorCQkJdXNic3NwX3Nsb3Rfc3RhdGVfc3RyaW5n KEdFVF9TTE9UX1NUQVRFKHN0YXRlKSkpOworCisJcmV0dXJuIHN0cjsKK30KKworCitzdGF0aWMg aW5saW5lIGNvbnN0IGNoYXIgKnVzYnNzcF9wb3J0c2NfbGlua19zdGF0ZV9zdHJpbmcodTMyIHBv cnRzYykKK3sKKwlzd2l0Y2ggKHBvcnRzYyAmIFBPUlRfUExTX01BU0spIHsKKwljYXNlIFhERVZf VTA6CisJCXJldHVybiAiVTAiOworCWNhc2UgWERFVl9VMToKKwkJcmV0dXJuICJVMSI7CisJY2Fz ZSBYREVWX1UyOgorCQlyZXR1cm4gIlUyIjsKKwljYXNlIFhERVZfVTM6CisJCXJldHVybiAiVTMi OworCWNhc2UgWERFVl9ESVNBQkxFRDoKKwkJcmV0dXJuICJEaXNhYmxlZCI7CisJY2FzZSBYREVW X1JYREVURUNUOgorCQlyZXR1cm4gIlJ4RGV0ZWN0IjsKKwljYXNlIFhERVZfSU5BQ1RJVkU6CisJ CXJldHVybiAiSW5hY3RpdmUiOworCWNhc2UgWERFVl9QT0xMSU5HOgorCQlyZXR1cm4gIlBvbGxp bmciOworCWNhc2UgWERFVl9SRUNPVkVSWToKKwkJcmV0dXJuICJSZWNvdmVyeSI7CisJY2FzZSBY REVWX0hPVF9SRVNFVDoKKwkJcmV0dXJuICJIb3QgUmVzZXQiOworCWNhc2UgWERFVl9DT01QX01P REU6CisJCXJldHVybiAiQ29tcGxpYW5jZSBtb2RlIjsKKwljYXNlIFhERVZfVEVTVF9NT0RFOgor CQlyZXR1cm4gIlRlc3QgbW9kZSI7CisJY2FzZSBYREVWX1JFU1VNRToKKwkJcmV0dXJuICJSZXN1 bWUiOworCWRlZmF1bHQ6CisJCWJyZWFrOworCX0KKwlyZXR1cm4gIlVua25vd24iOworfQorCitz dGF0aWMgaW5saW5lIGNvbnN0IGNoYXIgKnVzYnNzcF9kZWNvZGVfcG9ydHNjKHUzMiBwb3J0c2Mp Cit7CisJc3RhdGljIGNoYXIgc3RyWzI1Nl07CisJaW50IHJldDsKKworCXJldCA9IHNwcmludGYo c3RyLCAiJXMgJXMgJXMgTGluazolcyBQb3J0U3BlZWQ6JWQgIiwKKwkJCXBvcnRzYyAmIFBPUlRf UE9XRVIJPyAiUG93ZXJlZCIgOiAiUG93ZXJlZC1vZmYiLAorCQkJcG9ydHNjICYgUE9SVF9DT05O RUNUCT8gIkNvbm5lY3RlZCIgOiAiTm90LWNvbm5lY3RlZCIsCisJCQlwb3J0c2MgJiBQT1JUX1BF CT8gIkVuYWJsZWQiIDogIkRpc2FibGVkIiwKKwkJCXVzYnNzcF9wb3J0c2NfbGlua19zdGF0ZV9z dHJpbmcocG9ydHNjKSwKKwkJCURFVl9QT1JUX1NQRUVEKHBvcnRzYykpOworCisJaWYgKHBvcnRz YyAmIFBPUlRfT0MpCisJCXJldCArPSBzcHJpbnRmKHN0ciArIHJldCwgIk92ZXJDdXJyZW50ICIp OworCWlmIChwb3J0c2MgJiBQT1JUX1JFU0VUKQorCQlyZXQgKz0gc3ByaW50ZihzdHIgKyByZXQs ICJJbi1SZXNldCAiKTsKKworCXJldCArPSBzcHJpbnRmKHN0ciArIHJldCwgIkNoYW5nZTogIik7 CisJaWYgKHBvcnRzYyAmIFBPUlRfQ1NDKQorCQlyZXQgKz0gc3ByaW50ZihzdHIgKyByZXQsICJD U0MgIik7CisJaWYgKHBvcnRzYyAmIFBPUlRfUEVDKQorCQlyZXQgKz0gc3ByaW50ZihzdHIgKyBy ZXQsICJQRUMgIik7CisJaWYgKHBvcnRzYyAmIFBPUlRfV1JDKQorCQlyZXQgKz0gc3ByaW50Zihz dHIgKyByZXQsICJXUkMgIik7CisJaWYgKHBvcnRzYyAmIFBPUlRfT0NDKQorCQlyZXQgKz0gc3By aW50ZihzdHIgKyByZXQsICJPQ0MgIik7CisJaWYgKHBvcnRzYyAmIFBPUlRfUkMpCisJCXJldCAr PSBzcHJpbnRmKHN0ciArIHJldCwgIlBSQyAiKTsKKwlpZiAocG9ydHNjICYgUE9SVF9QTEMpCisJ CXJldCArPSBzcHJpbnRmKHN0ciArIHJldCwgIlBMQyAiKTsKKwlpZiAocG9ydHNjICYgUE9SVF9D RUMpCisJCXJldCArPSBzcHJpbnRmKHN0ciArIHJldCwgIkNFQyAiKTsKKwlyZXQgKz0gc3ByaW50 ZihzdHIgKyByZXQsICJXYWtlOiAiKTsKKwlpZiAocG9ydHNjICYgUE9SVF9XS0NPTk5fRSkKKwkJ cmV0ICs9IHNwcmludGYoc3RyICsgcmV0LCAiV0NFICIpOworCWlmIChwb3J0c2MgJiBQT1JUX1dL RElTQ19FKQorCQlyZXQgKz0gc3ByaW50ZihzdHIgKyByZXQsICJXREUgIik7CisJaWYgKHBvcnRz YyAmIFBPUlRfV0tPQ19FKQorCQlyZXQgKz0gc3ByaW50ZihzdHIgKyByZXQsICJXT0UgIik7CisK KwlyZXR1cm4gc3RyOworfQorCitzdGF0aWMgaW5saW5lIGNvbnN0IGNoYXIgKnVzYnNzcF9lcF9z dGF0ZV9zdHJpbmcodTggc3RhdGUpCit7CisJc3dpdGNoIChzdGF0ZSkgeworCWNhc2UgRVBfU1RB VEVfRElTQUJMRUQ6CisJCXJldHVybiAiZGlzYWJsZWQiOworCWNhc2UgRVBfU1RBVEVfUlVOTklO RzoKKwkJcmV0dXJuICJydW5uaW5nIjsKKwljYXNlIEVQX1NUQVRFX0hBTFRFRDoKKwkJcmV0dXJu ICJoYWx0ZWQiOworCWNhc2UgRVBfU1RBVEVfU1RPUFBFRDoKKwkJcmV0dXJuICJzdG9wcGVkIjsK KwljYXNlIEVQX1NUQVRFX0VSUk9SOgorCQlyZXR1cm4gImVycm9yIjsKKwlkZWZhdWx0OgorCQly ZXR1cm4gIklOVkFMSUQiOworCX0KK30KKworc3RhdGljIGlubGluZSBjb25zdCBjaGFyICp1c2Jz c3BfZXBfdHlwZV9zdHJpbmcodTggdHlwZSkKK3sKKwlzd2l0Y2ggKHR5cGUpIHsKKwljYXNlIElT T0NfT1VUX0VQOgorCQlyZXR1cm4gIklzb2MgT1VUIjsKKwljYXNlIEJVTEtfT1VUX0VQOgorCQly ZXR1cm4gIkJ1bGsgT1VUIjsKKwljYXNlIElOVF9PVVRfRVA6CisJCXJldHVybiAiSW50IE9VVCI7 CisJY2FzZSBDVFJMX0VQOgorCQlyZXR1cm4gIkN0cmwiOworCWNhc2UgSVNPQ19JTl9FUDoKKwkJ cmV0dXJuICJJc29jIElOIjsKKwljYXNlIEJVTEtfSU5fRVA6CisJCXJldHVybiAiQnVsayBJTiI7 CisJY2FzZSBJTlRfSU5fRVA6CisJCXJldHVybiAiSW50IElOIjsKKwlkZWZhdWx0OgorCQlyZXR1 cm4gIklOVkFMSUQiOworCX0KK30KKworc3RhdGljIGlubGluZSBjb25zdCBjaGFyICp1c2Jzc3Bf ZGVjb2RlX2VwX2NvbnRleHQodTMyIGluZm8sIHUzMiBpbmZvMiwgdTY0IGRlcSwKKwkJdTMyIHR4 X2luZm8pCit7CisJc3RhdGljIGNoYXIgc3RyWzEwMjRdOworCWludCByZXQ7CisKKwl1MzIgZXNp dDsKKwl1MTYgbWF4cDsKKwl1MTYgYXZnOworCisJdTggbWF4X3BzdHI7CisJdTggZXBfc3RhdGU7 CisJdTggaW50ZXJ2YWw7CisJdTggZXBfdHlwZTsKKwl1OCBidXJzdDsKKwl1OCBjZXJyOworCXU4 IG11bHQ7CisKKwlib29sIGxzYTsKKwlib29sIGhpZDsKKworCWVzaXQgPSBDVFhfVE9fTUFYX0VT SVRfUEFZTE9BRF9ISShpbmZvKSA8PCAxNiB8CisJCUNUWF9UT19NQVhfRVNJVF9QQVlMT0FEKHR4 X2luZm8pOworCisJZXBfc3RhdGUgPSBpbmZvICYgRVBfU1RBVEVfTUFTSzsKKwltYXhfcHN0ciA9 IENUWF9UT19FUF9NQVhQU1RSRUFNUyhpbmZvKTsKKwlpbnRlcnZhbCA9IENUWF9UT19FUF9JTlRF UlZBTChpbmZvKTsKKwltdWx0ID0gQ1RYX1RPX0VQX01VTFQoaW5mbykgKyAxOworCWxzYSA9ICEh KGluZm8gJiBFUF9IQVNfTFNBKTsKKworCWNlcnIgPSAoaW5mbzIgJiAoMyA8PCAxKSkgPj4gMTsK KwllcF90eXBlID0gQ1RYX1RPX0VQX1RZUEUoaW5mbzIpOworCWhpZCA9ICEhKGluZm8yICYgKDEg PDwgNykpOworCWJ1cnN0ID0gQ1RYX1RPX01BWF9CVVJTVChpbmZvMik7CisJbWF4cCA9IE1BWF9Q QUNLRVRfREVDT0RFRChpbmZvMik7CisKKwlhdmcgPSBFUF9BVkdfVFJCX0xFTkdUSCh0eF9pbmZv KTsKKworCXJldCA9IHNwcmludGYoc3RyLCAiU3RhdGUgJXMgbXVsdCAlZCBtYXggUC4gU3RyZWFt cyAlZCAlcyIsCisJCQl1c2Jzc3BfZXBfc3RhdGVfc3RyaW5nKGVwX3N0YXRlKSwgbXVsdCwKKwkJ CW1heF9wc3RyLCBsc2EgPyAiTFNBICIgOiAiIik7CisKKwlyZXQgKz0gc3ByaW50ZihzdHIgKyBy ZXQsICJpbnRlcnZhbCAlZCB1cyBtYXggRVNJVCBwYXlsb2FkICVkIENFcnIgJWQgIiwKKwkJCSgx IDw8IGludGVydmFsKSAqIDEyNSwgZXNpdCwgY2Vycik7CisKKwlyZXQgKz0gc3ByaW50ZihzdHIg KyByZXQsICJUeXBlICVzICVzYnVyc3QgJWQgbWF4cCAlZCBkZXEgJTAxNmxseCAiLAorCQkJdXNi c3NwX2VwX3R5cGVfc3RyaW5nKGVwX3R5cGUpLCBoaWQgPyAiSElEIiA6ICIiLAorCQkJYnVyc3Qs IG1heHAsIGRlcSk7CisKKwlyZXQgKz0gc3ByaW50ZihzdHIgKyByZXQsICJhdmcgdHJiIGxlbiAl ZCIsIGF2Zyk7CisKKwlyZXR1cm4gc3RyOworfQorCisvKioKKyAqIG5leHRfcmVxdWVzdCAtIGdl dHMgdGhlIG5leHQgcmVxdWVzdCBvbiB0aGUgZ2l2ZW4gbGlzdAorICogQGxpc3Q6IHRoZSByZXF1 ZXN0IGxpc3QgdG8gb3BlcmF0ZSBvbgorICoKKyAqIENhbGxlciBzaG91bGQgdGFrZSBjYXJlIG9m IGxvY2tpbmcuIFRoaXMgZnVuY3Rpb24gcmV0dXJuICVOVUxMIG9yIHRoZSBmaXJzdAorICogcmVx dWVzdCBhdmFpbGFibGUgb24gQGxpc3QuCisgKi8KK3N0YXRpYyBpbmxpbmUgc3RydWN0IHVzYnNz cF9yZXF1ZXN0ICpuZXh0X3JlcXVlc3Qoc3RydWN0IGxpc3RfaGVhZCAqbGlzdCkKK3sKKwlyZXR1 cm4gbGlzdF9maXJzdF9lbnRyeV9vcl9udWxsKGxpc3QsIHN0cnVjdCB1c2Jzc3BfcmVxdWVzdCwg bGlzdCk7Cit9CisKK3N0cnVjdCB1c2Jzc3BfdWRjOworI2RlZmluZSB0b191c2Jzc3BfZXAoZXAp IChjb250YWluZXJfb2YoZXAsIHN0cnVjdCB1c2Jzc3BfZXAsIGVuZHBvaW50KSkKKyNkZWZpbmUg Z2FkZ2V0X3RvX3VzYnNzcChnKSAoY29udGFpbmVyX29mKGcsIHN0cnVjdCB1c2Jzc3BfdWRjLCBn YWRnZXQpKQorI2RlZmluZSByZXF1ZXN0X3RvX3VzYnNzcF9yZXF1ZXN0KHIpIChjb250YWluZXJf b2Yociwgc3RydWN0IHVzYnNzcF9yZXF1ZXN0LCByZXF1ZXN0KSkKKworI2RlZmluZSB0b191c2Jz c3BfcmVxdWVzdChyKSAoY29udGFpbmVyX29mKHIsIHN0cnVjdCB1c2Jzc3BfcmVxdWVzdCwgcmVx dWVzdCkpCisKICNlbmRpZiAvKiBfX0xJTlVYX1VTQlNTUF9HQURHRVRfSCAqLwo=