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=-18.7 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,MSGID_FROM_MTA_HEADER,SPF_HELO_NONE, SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable 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 00284C433E8 for ; Tue, 30 Mar 2021 14:11:42 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id DEEBD619D0 for ; Tue, 30 Mar 2021 14:11:42 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231986AbhC3OLO (ORCPT ); Tue, 30 Mar 2021 10:11:14 -0400 Received: from mail-dm6nam12on2133.outbound.protection.outlook.com ([40.107.243.133]:61537 "EHLO NAM12-DM6-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S231918AbhC3OLE (ORCPT ); Tue, 30 Mar 2021 10:11:04 -0400 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=BD0NkUI4i4XvHK5E7Yhnta32tCSaOfURtZwaBAXvUSsmBBpaMaHTBl7KCHVkrfyXOvNyB0v51uTHD4KBqNKKfc5Xau2kkNaY9L/ZirHTCVbpd65ktSjYL3nxg+Qk3HhV1yOns0rFVBNj1wHHoVWuKFa44Ugwu5Ve5fQP3OxC4K5Ao6CbibHIdcrd20cHLInEDJQ/Bcfbdb+cFTqMHb1TZhDY/1Z6/b4uMBSwu84J8dHcw9zM8qtfnIMvvNlsFxP0BZ7PtBkV2iF13t1B22nO1JmyGM6vqiIxWl+8QuIpJ3YF+zRSltR2/nJrZ6WRxbPM7yfQG+3ad8LO4xLPPJpgQw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=Bl7AbniGyQZLNJ7+Q4QC8JWrE1KO2/ydCpx9+Flx7Co=; b=jP4Q2IoluGDzM9khjJIvCW6gx9CwmTvrs+pGOb8FY73w9HKx3f7odi3wvoc5n18fUedASYt7MKd/xj43dpoaPLpBa63Fl3g+CSCxyo7AtsGrq4b6vrDt0HWbt0iBsHPUSnRdR6L3bgtI/6jR4SCx++P+ql66jibcpfv3rLq1XbYIXhesl0vG2KyhSn+/sWk2fgNrBtMzCthf1l8FEi+CjTjJmgeuOHvsuYjiZG9uI42iz56sJlPUJJcawucoE0xFVd0YZ8uF8/tw+xeyzqqPBdqfEXV/2jti8taIq/WxTWRMtoGXU/VPbLXqy10ZQZPUcox2zPBvIhN3OP4xJRjmVQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=os.amperecomputing.com; dmarc=pass action=none header.from=os.amperecomputing.com; dkim=pass header.d=os.amperecomputing.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=os.amperecomputing.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=Bl7AbniGyQZLNJ7+Q4QC8JWrE1KO2/ydCpx9+Flx7Co=; b=tMlLZG8OFm33cpsiqH+YEmLlNWh/Dl8yM+lSIZUduRgyKjYUTJfDwJmnmYjhsvLTlqHPsTpbCZ0oVHUD0mMhcw6s//8LD3g36/s0n9tAkxGSqPQxKKXRHoZS6hKfoJ85KE6zEuZZdfV+23PGxb2cmEC2uHkh4hEMimJcKPHLNqM= Authentication-Results: acm.org; dkim=none (message not signed) header.d=none;acm.org; dmarc=none action=none header.from=os.amperecomputing.com; Received: from MW2PR0102MB3482.prod.exchangelabs.com (2603:10b6:302:c::32) by MW4PR01MB6338.prod.exchangelabs.com (2603:10b6:303:7b::15) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.3977.30; Tue, 30 Mar 2021 14:10:59 +0000 Received: from MW2PR0102MB3482.prod.exchangelabs.com ([fe80::d840:7aa7:58d4:b503]) by MW2PR0102MB3482.prod.exchangelabs.com ([fe80::d840:7aa7:58d4:b503%5]) with mapi id 15.20.3977.033; Tue, 30 Mar 2021 14:10:59 +0000 From: Quan Nguyen To: Corey Minyard , Rob Herring , Joel Stanley , Andrew Jeffery , Wolfram Sang , Philipp Zabel , openipmi-developer@lists.sourceforge.net, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-aspeed@lists.ozlabs.org, linux-kernel@vger.kernel.org, linux-i2c@vger.kernel.org Cc: openbmc@lists.ozlabs.org, Open Source Submission , Phong Vo , "Thang Q . Nguyen" Subject: [PATCH v2 2/3] drivers: char: ipmi: Add Aspeed SSIF BMC driver Date: Tue, 30 Mar 2021 21:10:28 +0700 Message-Id: <20210330141029.20412-3-quan@os.amperecomputing.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20210330141029.20412-1-quan@os.amperecomputing.com> References: <20210330141029.20412-1-quan@os.amperecomputing.com> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Originating-IP: [118.69.219.201] X-ClientProxiedBy: HK0PR03CA0120.apcprd03.prod.outlook.com (2603:1096:203:b0::36) To MW2PR0102MB3482.prod.exchangelabs.com (2603:10b6:302:c::32) MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 Received: from hcm-sw-17.amperecomputing.com (118.69.219.201) by HK0PR03CA0120.apcprd03.prod.outlook.com (2603:1096:203:b0::36) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.3977.29 via Frontend Transport; Tue, 30 Mar 2021 14:10:55 +0000 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 44c4c0f9-ef12-4f20-552d-08d8f385a45c X-MS-TrafficTypeDiagnostic: MW4PR01MB6338: X-MS-Exchange-Transport-Forked: True X-Microsoft-Antispam-PRVS: X-MS-Oob-TLC-OOBClassifiers: OLM:3044; X-MS-Exchange-SenderADCheck: 1 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: gSpemlJkYk4VOSTL4nB6teVURY3xRD5fkvmz3oCx5L/5ylI84aSl6nzGEY5go7swV5z18iWF8qCk24xj3YqFLmKMmi3fh210fivPq/XsrdZsNhNJ8d/6HjPpGZXw3iLGY5QB30KySG5POnDaNVH+v5dD1fRo4TFiWxV6qsSGbqNJQjBxPHOQvedWsbZtEbznkNY89WOUY6cryqIuEUs17d+KkGEp0SRch5HF2gwJqj3Kj1A+++f4Tlxb4ES+4J1PJXfQPYGDylFDC2Kt1xPHWzho5222XEU1ZgIYWF4tgH/xgQpaDzYbChs33/QHLxfSBqmkjwSLEYz5RV8EWOwTGWvCKxTLDr/Rf/S0P3Z7ksc9az0rbKMkVQrp36oz8/M8ibZ9n3+fgueg8ww8vK31XqHEJJM+kOEepB7Z2DQ/tJojOU0a7nShNXj9c6N6OcNXrgz+6PjUVtNxJ6Nsfd8cCmMXI8twU3NeLHgBxvJXtRC4OpHovHWzpts3nHMw2pOgSEAVPoBsSBpeW1JqXeeDLN1UC6hOsQHQ39G/C8Svsg/ye/dQuEk4MNbfXrnFV91pHWP+W5Oym9ZLXHEkemfBsZ8WOhNfUpjxeDrufeT392ZoQALgYsaCOuoKlEpVDsAOtZsMG+FbyXv0VCjiwcK125EC31PLbeIdi4HL9PkRW1n3ueV7A9J7Ehu8560Eq7hnwOmadPEZvmn/RRsyhn3oBOoRa/Uy4Z6vjI2rdMUHNGIDjdn3+plFBxfAVeqAvj2/Z81Y1d/xLG1QGIXWuEvGYw== X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:MW2PR0102MB3482.prod.exchangelabs.com;PTR:;CAT:NONE;SFS:(4636009)(366004)(2616005)(5660300002)(2906002)(956004)(186003)(16526019)(6512007)(66556008)(66476007)(6666004)(921005)(107886003)(52116002)(8676002)(7416002)(8936002)(86362001)(38100700001)(66946007)(110136005)(6506007)(83380400001)(498600001)(6486002)(4326008)(1076003)(30864003)(26005)(54906003)(2004002);DIR:OUT;SFP:1102; X-MS-Exchange-AntiSpam-MessageData: =?utf-8?B?NjNRc1AyMXBIby9YNTFNQ3I1NzJWcXp6dXo2NjZmZExqQVFVZG1oOWFVR3Ns?= =?utf-8?B?dkpQWTBhMnc1VVZ0Lzd5OE1pMjYwd3Rmd04zaUF3ZGJOKzQvdElYYWhuL2Vz?= =?utf-8?B?aW1tUHpXYUR5bnowUFFxM1Irc1NldUVISUZaMzRjZnBjTUtvTXZxTlJzd0Vk?= =?utf-8?B?OURGdDhPRjNFY3hlSVRUOHVzZjB1Wkg4bnN0QnFXMFFqV04yOTJqY2FmZHl3?= =?utf-8?B?bVM0R2pUMVlpR0t1b3ZpMlpHOWYwNEpNQUJSRVhYaEIrU1MvcEhVOU5yTWkx?= =?utf-8?B?M0ZHbE9aMjVPYjVpeWsvUEtqT0xTc0JxYk5yRC85dDlWSWprUUFYMDlZKzVR?= =?utf-8?B?Rm1ybG9pY29wbDdxR1dMbzhwREh2ZlJYaXpIblpGdDZ5bU5rQW5NODM3anBZ?= =?utf-8?B?US9TY3A5V2pDMmQvZFlWS20wbTFNTHpPaXNIek9aN3hvdzFkYjRadzJsM0tV?= =?utf-8?B?dmJhODVqekhQTE5pQmhKUVRDU0lDbFlNRzV6UlpoaWw4R0hTUlpoUHd6dGVD?= =?utf-8?B?VFp2R2ZqTmU1Q1VHS3lwMEtYcURMV0wyUWZzUktDbDdoNGZtc1J3UEh5MjY3?= =?utf-8?B?NERGNngrNCtnNU9ybDFSWW9NS0RhcjNUdEtIakpqci9HWUluK0h0VmxZSTdU?= =?utf-8?B?Vnl4MkpkYTR5RzJWR3M2emE1UHUvQkM0NVlEVmM5TmVqcXptOEpkUzBoTElN?= =?utf-8?B?QlFzQU1NbDRoajJYRnl1Y29CcGpnR2pGVS9WeUhtYkdnL3NMUVZMNEYvMGpk?= =?utf-8?B?WVFmVld2Z3BudUl0MkZvdkowSFAySFlhZEM5RVJCYXUwN2hycHlnQnY5RWZi?= =?utf-8?B?WU15WmxGWVh4b05hbmNKK2NGSEZsZmhHZTNoYTBWdU1PRE5Pc2FjcFFiZDJZ?= =?utf-8?B?ZjFFOVo4RFlFMXNvWXVQbGpxMllobHlaTlpORFcxekNUNkhuWWFXaktReFMy?= =?utf-8?B?U255K09pdzVzcjhnODlUZjVqTE9YUmh2bWRNQ0tFRjRIT0xNNm1mTGhuQ1ln?= =?utf-8?B?TFFKNW8ydVdMNE1xWGZ5dnRqN0hHYTZ6dHVEQW5qQWtGSjA3NWtYM1B2ZkZ3?= =?utf-8?B?RWF4ckVSZVVQZnJTd2dSWjhSVXFxbVR1ZkxlbFZLZExsLzhXQmpaT2w2RUVu?= =?utf-8?B?elhoeGNybDRQdmEzM29nNjg0ZWZKbW10NHZFeGtEREFWdVZQalVJR1BvMnRB?= =?utf-8?B?TkhZSDZSZjRBMzkyTlBVelAyVzJlNkRaZUlGNStZaTlGVmNKbG5BOU12Y0Yx?= =?utf-8?B?Z1BTNWxCK2dvV29QUFY0Sk9YeEl0bmgvUlVGWW1wS2RGKzVvMTRFT2hqYUdP?= =?utf-8?B?b2dFS2JaT0ZyS3FGR1dWZU1PRXNjUUY5YzJHZzdMRjBUYVZLWmVSd0U4OU1z?= =?utf-8?B?dXgwU2tZeUR5TkVpNytRejkzdXZxZ0srTnVVUThDcjkvandEaEFaNUJmMmZF?= =?utf-8?B?VFBycVBHblRiVTBkRmdWeExqZ2FQMjBpWndKMkp5OER6ZERlb1BCaDBVcE1z?= =?utf-8?B?QVk0WVBhbGQvamFtRlg0N2pUT2hFNjNqSXhuaUFNajIvYzU4VlFFazY0Qkd0?= =?utf-8?B?a2xoV0ZhejZsbE5xR2NDZHNkdlR2aGVRMWc1Qk45TENpM2lMQkR0dFVHZjhS?= =?utf-8?B?RE1PZkJldWpPWk4ybmxXL1VSM1ZuWkJPSDVUUFpzK3VNWXVtQ2RpVDVscGcw?= =?utf-8?B?eHE5YlFZa3ViM0ZOMUV6NnNJQWpqaWJIcWtORUlud28vUzNsSERRVDFUUFF2?= =?utf-8?Q?uOvWFARjh7aAlW3g1iyHNhEp+K2ttGAJqs5Uy63?= X-OriginatorOrg: os.amperecomputing.com X-MS-Exchange-CrossTenant-Network-Message-Id: 44c4c0f9-ef12-4f20-552d-08d8f385a45c X-MS-Exchange-CrossTenant-AuthSource: MW2PR0102MB3482.prod.exchangelabs.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 30 Mar 2021 14:10:59.1656 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 3bc2b170-fd94-476d-b0ce-4229bdc904a7 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: WUJuAzAV1NTx1k5k1de2OfGuZQdwbYLOL7QU2pZxE1mLb82pQBb6Cuzm503waeM8phJP9kpdo0/7USbWJJ+MsyW2hnuCdGgzu4szQ0lN1fE= X-MS-Exchange-Transport-CrossTenantHeadersStamped: MW4PR01MB6338 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The SMBus system interface (SSIF) IPMI BMC driver can be used to perform in-band IPMI communication with their host in management (BMC) side. This commits adds support specifically for Aspeed AST2500 which commonly used as Board Management Controllers. Signed-off-by: Quan Nguyen --- drivers/char/ipmi/Kconfig | 22 + drivers/char/ipmi/Makefile | 2 + drivers/char/ipmi/ssif_bmc.c | 645 ++++++++++++++++++++++++++++ drivers/char/ipmi/ssif_bmc.h | 92 ++++ drivers/char/ipmi/ssif_bmc_aspeed.c | 132 ++++++ 5 files changed, 893 insertions(+) create mode 100644 drivers/char/ipmi/ssif_bmc.c create mode 100644 drivers/char/ipmi/ssif_bmc.h create mode 100644 drivers/char/ipmi/ssif_bmc_aspeed.c diff --git a/drivers/char/ipmi/Kconfig b/drivers/char/ipmi/Kconfig index 07847d9a459a..45be57023577 100644 --- a/drivers/char/ipmi/Kconfig +++ b/drivers/char/ipmi/Kconfig @@ -133,6 +133,28 @@ config ASPEED_BT_IPMI_BMC found on Aspeed SOCs (AST2400 and AST2500). The driver implements the BMC side of the BT interface. +config SSIF_IPMI_BMC + tristate "SSIF IPMI BMC driver" + select I2C + select I2C_SLAVE + help + This enables the IPMI SMBus system interface (SSIF) at the + management (BMC) side. + + The driver implements the BMC side of the SMBus system + interface (SSIF). + +config ASPEED_SSIF_IPMI_BMC + depends on ARCH_ASPEED || COMPILE_TEST + select SSIF_IPMI_BMC + tristate "Aspeed SSIF IPMI BMC driver" + help + Provides a driver for the SSIF IPMI interface found on + Aspeed AST2500 SoC. + + The driver implements the BMC side of the SMBus system + interface (SSIF), specific for Aspeed AST2500 SoC. + config IPMB_DEVICE_INTERFACE tristate 'IPMB Interface handler' depends on I2C diff --git a/drivers/char/ipmi/Makefile b/drivers/char/ipmi/Makefile index 0822adc2ec41..05b993f7335b 100644 --- a/drivers/char/ipmi/Makefile +++ b/drivers/char/ipmi/Makefile @@ -27,3 +27,5 @@ obj-$(CONFIG_ASPEED_BT_IPMI_BMC) += bt-bmc.o obj-$(CONFIG_ASPEED_KCS_IPMI_BMC) += kcs_bmc_aspeed.o obj-$(CONFIG_NPCM7XX_KCS_IPMI_BMC) += kcs_bmc_npcm7xx.o obj-$(CONFIG_IPMB_DEVICE_INTERFACE) += ipmb_dev_int.o +obj-$(CONFIG_SSIF_IPMI_BMC) += ssif_bmc.o +obj-$(CONFIG_ASPEED_SSIF_IPMI_BMC) += ssif_bmc_aspeed.o diff --git a/drivers/char/ipmi/ssif_bmc.c b/drivers/char/ipmi/ssif_bmc.c new file mode 100644 index 000000000000..ae6e8750c795 --- /dev/null +++ b/drivers/char/ipmi/ssif_bmc.c @@ -0,0 +1,645 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * The driver for BMC side of SSIF interface + * + * Copyright (c) 2021, Ampere Computing LLC + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "ssif_bmc.h" + +/* + * Call in WRITE context + */ +static int send_ssif_bmc_response(struct ssif_bmc_ctx *ssif_bmc, bool non_blocking) +{ + unsigned long flags; + int ret; + + if (!non_blocking) { +retry: + ret = wait_event_interruptible(ssif_bmc->wait_queue, + !ssif_bmc->response_in_progress); + if (ret) + return ret; + } + + spin_lock_irqsave(&ssif_bmc->lock, flags); + if (ssif_bmc->response_in_progress) { + spin_unlock_irqrestore(&ssif_bmc->lock, flags); + if (non_blocking) + return -EAGAIN; + + goto retry; + } + + /* + * Check the response data length from userspace to determine the type + * of the response message whether it is single-part or multi-part. + */ + ssif_bmc->is_singlepart_read = + (ssif_msg_len(&ssif_bmc->response) <= (MAX_PAYLOAD_PER_TRANSACTION + 1)) ? + true : false; /* 1: byte of length */ + + ssif_bmc->response_in_progress = true; + spin_unlock_irqrestore(&ssif_bmc->lock, flags); + + return 0; +} + +/* + * Call in READ context + */ +static int receive_ssif_bmc_request(struct ssif_bmc_ctx *ssif_bmc, bool non_blocking) +{ + unsigned long flags; + int ret; + + if (!non_blocking) { +retry: + ret = wait_event_interruptible(ssif_bmc->wait_queue, + ssif_bmc->request_available); + if (ret) + return ret; + } + + spin_lock_irqsave(&ssif_bmc->lock, flags); + if (!ssif_bmc->request_available) { + spin_unlock_irqrestore(&ssif_bmc->lock, flags); + if (non_blocking) + return -EAGAIN; + goto retry; + } + spin_unlock_irqrestore(&ssif_bmc->lock, flags); + + return 0; +} + +/* Handle SSIF message that will be sent to user */ +static ssize_t ssif_bmc_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) +{ + struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file); + struct ssif_msg msg; + unsigned long flags; + ssize_t ret; + + mutex_lock(&ssif_bmc->file_mutex); + + ret = receive_ssif_bmc_request(ssif_bmc, file->f_flags & O_NONBLOCK); + if (ret < 0) + goto out; + + spin_lock_irqsave(&ssif_bmc->lock, flags); + count = min_t(ssize_t, count, ssif_msg_len(&ssif_bmc->request)); + memcpy(&msg, &ssif_bmc->request, count); + ssif_bmc->request_available = false; + spin_unlock_irqrestore(&ssif_bmc->lock, flags); + + ret = copy_to_user(buf, &msg, count); +out: + mutex_unlock(&ssif_bmc->file_mutex); + + return (ret < 0) ? ret : count; +} + +/* Handle SSIF message that is written by user */ +static ssize_t ssif_bmc_write(struct file *file, const char __user *buf, size_t count, + loff_t *ppos) +{ + struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file); + struct ssif_msg msg; + unsigned long flags; + ssize_t ret; + + if (count > sizeof(struct ssif_msg)) + return -EINVAL; + + mutex_lock(&ssif_bmc->file_mutex); + + ret = copy_from_user(&msg, buf, count); + if (ret) + goto out; + + spin_lock_irqsave(&ssif_bmc->lock, flags); + if (count >= ssif_msg_len(&ssif_bmc->response)) + memcpy(&ssif_bmc->response, &msg, count); + else + ret = -EINVAL; + spin_unlock_irqrestore(&ssif_bmc->lock, flags); + + if (ret) + goto out; + + ret = send_ssif_bmc_response(ssif_bmc, file->f_flags & O_NONBLOCK); + if (!ret && ssif_bmc->set_ssif_bmc_status) + ssif_bmc->set_ssif_bmc_status(ssif_bmc, SSIF_BMC_READY); +out: + mutex_unlock(&ssif_bmc->file_mutex); + + return (ret < 0) ? ret : count; +} + +static long ssif_bmc_ioctl(struct file *file, unsigned int cmd, unsigned long param) +{ + return 0; +} + +static unsigned int ssif_bmc_poll(struct file *file, poll_table *wait) +{ + struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file); + unsigned int mask = 0; + + mutex_lock(&ssif_bmc->file_mutex); + poll_wait(file, &ssif_bmc->wait_queue, wait); + + /* + * The request message is now available so userspace application can + * get the request + */ + if (ssif_bmc->request_available) + mask |= POLLIN; + + mutex_unlock(&ssif_bmc->file_mutex); + return mask; +} + +/* + * System calls to device interface for user apps + */ +static const struct file_operations ssif_bmc_fops = { + .owner = THIS_MODULE, + .read = ssif_bmc_read, + .write = ssif_bmc_write, + .poll = ssif_bmc_poll, + .unlocked_ioctl = ssif_bmc_ioctl, +}; + +/* Called with ssif_bmc->lock held. */ +static int handle_request(struct ssif_bmc_ctx *ssif_bmc) +{ + if (ssif_bmc->set_ssif_bmc_status) + ssif_bmc->set_ssif_bmc_status(ssif_bmc, SSIF_BMC_BUSY); + + /* Request message is available to process */ + ssif_bmc->request_available = true; + /* + * This is the new READ request. + * Clear the response buffer of the previous transaction + */ + memset(&ssif_bmc->response, 0, sizeof(struct ssif_msg)); + wake_up_all(&ssif_bmc->wait_queue); + return 0; +} + +/* Called with ssif_bmc->lock held. */ +static int complete_response(struct ssif_bmc_ctx *ssif_bmc) +{ + /* Invalidate response in buffer to denote it having been sent. */ + ssif_bmc->response.len = 0; + ssif_bmc->response_in_progress = false; + ssif_bmc->nbytes_processed = 0; + ssif_bmc->remain_len = 0; + memset(&ssif_bmc->response_buf, 0, MAX_PAYLOAD_PER_TRANSACTION); + wake_up_all(&ssif_bmc->wait_queue); + return 0; +} + +static void set_multipart_response_buffer(struct ssif_bmc_ctx *ssif_bmc, u8 *val) +{ + u8 response_len = 0; + int idx = 0; + u8 data_len; + + data_len = ssif_bmc->response.len; + switch (ssif_bmc->smbus_cmd) { + case SSIF_IPMI_MULTIPART_READ_START: + /* + * Read Start length is 32 bytes. + * Read Start transfer first 30 bytes of IPMI response + * and 2 special code 0x00, 0x01. + */ + *val = MAX_PAYLOAD_PER_TRANSACTION; + ssif_bmc->remain_len = data_len - MAX_IPMI_DATA_PER_START_TRANSACTION; + ssif_bmc->block_num = 0; + + ssif_bmc->response_buf[idx++] = 0x00; /* Start Flag */ + ssif_bmc->response_buf[idx++] = 0x01; /* Start Flag */ + ssif_bmc->response_buf[idx++] = ssif_bmc->response.netfn_lun; + ssif_bmc->response_buf[idx++] = ssif_bmc->response.cmd; + ssif_bmc->response_buf[idx++] = ssif_bmc->response.payload[0]; + + response_len = MAX_PAYLOAD_PER_TRANSACTION - idx; + + memcpy(&ssif_bmc->response_buf[idx], &ssif_bmc->response.payload[1], + response_len); + break; + + case SSIF_IPMI_MULTIPART_READ_MIDDLE: + /* + * IPMI READ Middle or READ End messages can carry up to 31 bytes + * IPMI data plus block number byte. + */ + if (ssif_bmc->remain_len < MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION) { + /* + * This is READ End message + * Return length is the remaining response data length + * plus block number + * Block number 0xFF is to indicate this is last message + * + * Return length is: remain response plus block number + */ + *val = ssif_bmc->remain_len + 1; + ssif_bmc->block_num = 0xFF; + ssif_bmc->response_buf[idx++] = ssif_bmc->block_num; + response_len = ssif_bmc->remain_len; + } else { + /* + * This is READ Middle message + * Response length is the maximum SMBUS transfer length + * Block number byte is incremented + * Return length is maximum SMBUS transfer length + */ + *val = MAX_PAYLOAD_PER_TRANSACTION; + ssif_bmc->remain_len -= MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION; + response_len = MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION; + ssif_bmc->response_buf[idx++] = ssif_bmc->block_num; + ssif_bmc->block_num++; + } + + memcpy(&ssif_bmc->response_buf[idx], + ssif_bmc->response.payload + 1 + ssif_bmc->nbytes_processed, + response_len); + break; + + default: + /* Do not expect to go to this case */ + pr_err("Error: Unexpected SMBus command received 0x%x\n", ssif_bmc->smbus_cmd); + break; + } + + ssif_bmc->nbytes_processed += response_len; +} + +static void set_singlepart_response_buffer(struct ssif_bmc_ctx *ssif_bmc, u8 *val) +{ + u8 *buf = (u8 *)&ssif_bmc->response; + + /* + * Do not expect the IPMI response has data length 0. + * With some I2C SMBus controllers (Aspeed I2C), return 0 for + * the SMBus Read Request callback might cause bad state for + * the bus. So return 1 byte length so that master will + * resend the Read Request because the length of response is + * less than a normal IPMI response. + * + * Otherwise, return the length of IPMI response + */ + *val = (buf[ssif_bmc->msg_idx]) ? buf[ssif_bmc->msg_idx] : 0x1; +} + +/* Process the IPMI response that will be read by master */ +static void handle_read_processed(struct ssif_bmc_ctx *ssif_bmc, u8 *val) +{ + u8 *buf; + u8 pec_len, addr, len; + u8 pec = 0; + + pec_len = ssif_bmc->pec_support ? 1 : 0; + /* PEC - Start Read Address */ + addr = GET_8BIT_ADDR(ssif_bmc->client->addr); + pec = i2c_smbus_pec(pec, &addr, 1); + /* PEC - SSIF Command */ + pec = i2c_smbus_pec(pec, &ssif_bmc->smbus_cmd, 1); + /* PEC - Restart Write Address */ + addr = addr | 0x01; + pec = i2c_smbus_pec(pec, &addr, 1); + + if (ssif_bmc->is_singlepart_read) { + /* Single-part Read processing */ + buf = (u8 *)&ssif_bmc->response; + + if (ssif_bmc->response.len && ssif_bmc->msg_idx < ssif_bmc->response.len) { + ssif_bmc->msg_idx++; + *val = buf[ssif_bmc->msg_idx]; + } else if (ssif_bmc->response.len && + (ssif_bmc->msg_idx == ssif_bmc->response.len)) { + ssif_bmc->msg_idx++; + *val = i2c_smbus_pec(pec, buf, ssif_msg_len(&ssif_bmc->response)); + } else { + *val = 0; + } + /* Invalidate response buffer to denote it is sent */ + if (ssif_bmc->msg_idx + 1 >= (ssif_msg_len(&ssif_bmc->response) + pec_len)) + complete_response(ssif_bmc); + } else { + /* Multi-part Read processing */ + switch (ssif_bmc->smbus_cmd) { + case SSIF_IPMI_MULTIPART_READ_START: + case SSIF_IPMI_MULTIPART_READ_MIDDLE: + buf = (u8 *)&ssif_bmc->response_buf; + *val = buf[ssif_bmc->msg_idx]; + ssif_bmc->msg_idx++; + break; + default: + /* Do not expect to go to this case */ + pr_err("Error: Unexpected SMBus command received 0x%x\n", + ssif_bmc->smbus_cmd); + break; + } + len = (ssif_bmc->block_num == 0xFF) ? + ssif_bmc->remain_len + 1 : MAX_PAYLOAD_PER_TRANSACTION; + if (ssif_bmc->msg_idx == (len + 1)) { + pec = i2c_smbus_pec(pec, &len, 1); + *val = i2c_smbus_pec(pec, ssif_bmc->response_buf, len); + } + /* Invalidate response buffer to denote last response is sent */ + if (ssif_bmc->block_num == 0xFF && + ssif_bmc->msg_idx > (ssif_bmc->remain_len + pec_len)) { + complete_response(ssif_bmc); + } + } +} + +static void handle_write_received(struct ssif_bmc_ctx *ssif_bmc, u8 *val) +{ + u8 *buf; + u8 smbus_cmd; + + buf = (u8 *)&ssif_bmc->request; + if (ssif_bmc->msg_idx >= sizeof(struct ssif_msg)) + return; + + smbus_cmd = ssif_bmc->smbus_cmd; + switch (smbus_cmd) { + case SSIF_IPMI_SINGLEPART_WRITE: + /* Single-part write */ + buf[ssif_bmc->msg_idx - 1] = *val; + ssif_bmc->msg_idx++; + + break; + case SSIF_IPMI_MULTIPART_WRITE_START: + /* Reset length to zero */ + if (ssif_bmc->msg_idx == 1) + ssif_bmc->request.len = 0; + + fallthrough; + case SSIF_IPMI_MULTIPART_WRITE_MIDDLE: + case SSIF_IPMI_MULTIPART_WRITE_END: + /* Multi-part write, 2nd byte received is length */ + if (ssif_bmc->msg_idx == 1) { + ssif_bmc->request.len += *val; + ssif_bmc->recv_len = *val; + } else { + buf[ssif_bmc->msg_idx - 1 + + ssif_bmc->request.len - ssif_bmc->recv_len] = *val; + } + + ssif_bmc->msg_idx++; + + break; + default: + /* Do not expect to go to this case */ + pr_err("Error: Unexpected SMBus command received 0x%x\n", ssif_bmc->smbus_cmd); + break; + } +} + +static bool validate_pec(struct ssif_bmc_ctx *ssif_bmc) +{ + u8 rpec = 0, cpec = 0; + bool ret = true; + u8 addr, index; + u8 *buf; + + buf = (u8 *)&ssif_bmc->request; + switch (ssif_bmc->smbus_cmd) { + case SSIF_IPMI_SINGLEPART_WRITE: + if ((ssif_bmc->msg_idx - 1) == ssif_msg_len(&ssif_bmc->request)) { + /* PEC is not included */ + ssif_bmc->pec_support = false; + return true; + } + + if ((ssif_bmc->msg_idx - 1) != (ssif_msg_len(&ssif_bmc->request) + 1)) + goto error; + + /* PEC is included */ + ssif_bmc->pec_support = true; + rpec = buf[ssif_bmc->msg_idx - 2]; + addr = GET_8BIT_ADDR(ssif_bmc->client->addr); + cpec = i2c_smbus_pec(cpec, &addr, 1); + cpec = i2c_smbus_pec(cpec, &ssif_bmc->smbus_cmd, 1); + cpec = i2c_smbus_pec(cpec, buf, ssif_msg_len(&ssif_bmc->request)); + if (rpec != cpec) { + pr_err("Bad PEC 0x%02x vs. 0x%02x\n", rpec, cpec); + ret = false; + } + + break; + case SSIF_IPMI_MULTIPART_WRITE_START: + case SSIF_IPMI_MULTIPART_WRITE_MIDDLE: + case SSIF_IPMI_MULTIPART_WRITE_END: + index = ssif_bmc->request.len - ssif_bmc->recv_len; + if ((ssif_bmc->msg_idx - 1 + index) == ssif_msg_len(&ssif_bmc->request)) { + /* PEC is not included */ + ssif_bmc->pec_support = false; + return true; + } + + if ((ssif_bmc->msg_idx - 1 + index) != (ssif_msg_len(&ssif_bmc->request) + 1)) + goto error; + + /* PEC is included */ + ssif_bmc->pec_support = true; + rpec = buf[ssif_bmc->msg_idx - 2 + index]; + addr = GET_8BIT_ADDR(ssif_bmc->client->addr); + cpec = i2c_smbus_pec(cpec, &addr, 1); + cpec = i2c_smbus_pec(cpec, &ssif_bmc->smbus_cmd, 1); + cpec = i2c_smbus_pec(cpec, &ssif_bmc->recv_len, 1); + /* As SMBus specification does not allow the length + * (byte count) in the Write-Block protocol to be zero. + * Therefore, it is illegal to have the last Middle + * transaction in the sequence carry 32-bytes and have + * a length of ‘0’ in the End transaction. + * But some users may try to use this way and we should + * prevent ssif_bmc driver broken in this case. + */ + if (ssif_bmc->recv_len != 0) + cpec = i2c_smbus_pec(cpec, buf + 1 + index, ssif_bmc->recv_len); + + if (rpec != cpec) { + pr_err("Bad PEC 0x%02x vs. 0x%02x\n", rpec, cpec); + ret = false; + } + + break; + default: + break; + } + + return ret; +error: + /* Do not expect to go to this case */ + pr_err("Error: Unexpected length received %d\n", ssif_msg_len(&ssif_bmc->request)); + + return false; +} + +static void complete_write_received(struct ssif_bmc_ctx *ssif_bmc) +{ + u8 cmd = ssif_bmc->smbus_cmd; + + /* A BMC that receives an invalid PEC shall drop the data for the write + * transaction and any further transactions (read or write) until + * the next valid read or write Start transaction is received + */ + if (!validate_pec(ssif_bmc)) { + pr_err("Received invalid PEC\n"); + return; + } + + if (cmd == SSIF_IPMI_SINGLEPART_WRITE || cmd == SSIF_IPMI_MULTIPART_WRITE_END) + handle_request(ssif_bmc); +} + +/* + * Callback function to handle I2C slave events + */ +static int ssif_bmc_cb(struct i2c_client *client, enum i2c_slave_event event, u8 *val) +{ + struct ssif_bmc_ctx *ssif_bmc = i2c_get_clientdata(client); + + spin_lock(&ssif_bmc->lock); + + /* I2C Event Handler: + * I2C_SLAVE_READ_REQUESTED 0x0 + * I2C_SLAVE_WRITE_REQUESTED 0x1 + * I2C_SLAVE_READ_PROCESSED 0x2 + * I2C_SLAVE_WRITE_RECEIVED 0x3 + * I2C_SLAVE_STOP 0x4 + */ + switch (event) { + case I2C_SLAVE_READ_REQUESTED: + ssif_bmc->msg_idx = 0; + if (ssif_bmc->is_singlepart_read) + set_singlepart_response_buffer(ssif_bmc, val); + else + set_multipart_response_buffer(ssif_bmc, val); + break; + + case I2C_SLAVE_WRITE_REQUESTED: + ssif_bmc->msg_idx = 0; + break; + + case I2C_SLAVE_READ_PROCESSED: + handle_read_processed(ssif_bmc, val); + break; + + case I2C_SLAVE_WRITE_RECEIVED: + /* + * First byte is SMBUS command, not a part of SSIF message. + * SSIF request buffer starts with msg_idx 1 for the first + * buffer byte. + */ + if (ssif_bmc->msg_idx == 0) { + /* SMBUS command can vary (single or multi-part) */ + ssif_bmc->smbus_cmd = *val; + ssif_bmc->msg_idx++; + } else { + handle_write_received(ssif_bmc, val); + } + + break; + + case I2C_SLAVE_STOP: + /* + * PEC byte is appended at the end of each transaction. + * Detect PEC is support or not after receiving write request + * completely. + */ + if (ssif_bmc->last_event == I2C_SLAVE_WRITE_RECEIVED) + complete_write_received(ssif_bmc); + /* Reset message index */ + ssif_bmc->msg_idx = 0; + break; + + default: + break; + } + ssif_bmc->last_event = event; + spin_unlock(&ssif_bmc->lock); + + return 0; +} + +struct ssif_bmc_ctx *ssif_bmc_alloc(struct i2c_client *client, int sizeof_priv) +{ + struct ssif_bmc_ctx *ssif_bmc; + int ret; + + ssif_bmc = devm_kzalloc(&client->dev, sizeof(*ssif_bmc) + sizeof_priv, GFP_KERNEL); + if (!ssif_bmc) + return ERR_PTR(-ENOMEM); + + spin_lock_init(&ssif_bmc->lock); + + init_waitqueue_head(&ssif_bmc->wait_queue); + ssif_bmc->request_available = false; + ssif_bmc->response_in_progress = false; + + mutex_init(&ssif_bmc->file_mutex); + + /* Register misc device interface */ + ssif_bmc->miscdev.minor = MISC_DYNAMIC_MINOR; + ssif_bmc->miscdev.name = DEVICE_NAME; + ssif_bmc->miscdev.fops = &ssif_bmc_fops; + ssif_bmc->miscdev.parent = &client->dev; + ret = misc_register(&ssif_bmc->miscdev); + if (ret) + goto out; + + ssif_bmc->client = client; + ssif_bmc->client->flags |= I2C_CLIENT_SLAVE; + + /* Register I2C slave */ + i2c_set_clientdata(client, ssif_bmc); + ret = i2c_slave_register(client, ssif_bmc_cb); + if (ret) { + misc_deregister(&ssif_bmc->miscdev); + goto out; + } + + return ssif_bmc; + +out: + devm_kfree(&client->dev, ssif_bmc); + return ERR_PTR(ret); +} +EXPORT_SYMBOL(ssif_bmc_alloc); + +MODULE_AUTHOR("Chuong Tran "); +MODULE_AUTHOR("Quan Nguyen "); +MODULE_DESCRIPTION("Linux device driver of the BMC IPMI SSIF interface."); +MODULE_LICENSE("GPL v2"); diff --git a/drivers/char/ipmi/ssif_bmc.h b/drivers/char/ipmi/ssif_bmc.h new file mode 100644 index 000000000000..a2ee090572db --- /dev/null +++ b/drivers/char/ipmi/ssif_bmc.h @@ -0,0 +1,92 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * The driver for BMC side of SSIF interface + * + * Copyright (c) 2021, Ampere Computing LLC + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#ifndef __SSIF_BMC_H__ +#define __SSIF_BMC_H__ + +#define DEVICE_NAME "ipmi-ssif-host" + +#define GET_8BIT_ADDR(addr_7bit) (((addr_7bit) << 1) & 0xff) + +#define MSG_PAYLOAD_LEN_MAX 252 + +/* A standard SMBus Transaction is limited to 32 data bytes */ +#define MAX_PAYLOAD_PER_TRANSACTION 32 + +#define MAX_IPMI_DATA_PER_START_TRANSACTION 30 +#define MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION 31 + +#define SSIF_IPMI_SINGLEPART_WRITE 0x2 +#define SSIF_IPMI_SINGLEPART_READ 0x3 +#define SSIF_IPMI_MULTIPART_WRITE_START 0x6 +#define SSIF_IPMI_MULTIPART_WRITE_MIDDLE 0x7 +#define SSIF_IPMI_MULTIPART_WRITE_END 0x8 +#define SSIF_IPMI_MULTIPART_READ_START 0x3 +#define SSIF_IPMI_MULTIPART_READ_MIDDLE 0x9 + +struct ssif_msg { + u8 len; + u8 netfn_lun; + u8 cmd; + u8 payload[MSG_PAYLOAD_LEN_MAX]; +} __packed; + +static inline u32 ssif_msg_len(struct ssif_msg *ssif_msg) +{ + return ssif_msg->len + 1; +} + +#define SSIF_BMC_BUSY 0x01 +#define SSIF_BMC_READY 0x02 + +struct ssif_bmc_ctx { + struct i2c_client *client; + struct miscdevice miscdev; + u8 smbus_cmd; + struct ssif_msg request; + bool request_available; + struct ssif_msg response; + bool response_in_progress; + /* Response buffer for Multi-part Read Transaction */ + u8 response_buf[MAX_PAYLOAD_PER_TRANSACTION]; + /* Flag to identify a Multi-part Read Transaction */ + bool is_singlepart_read; + u8 nbytes_processed; + u8 remain_len; + u8 recv_len; + /* Block Number of a Multi-part Read Transaction */ + u8 block_num; + size_t msg_idx; + enum i2c_slave_event last_event; + bool pec_support; + spinlock_t lock; + wait_queue_head_t wait_queue; + struct mutex file_mutex; + void (*set_ssif_bmc_status)(struct ssif_bmc_ctx *ssif_bmc, unsigned int flags); + void *priv; +}; + +static inline struct ssif_bmc_ctx *to_ssif_bmc(struct file *file) +{ + return container_of(file->private_data, struct ssif_bmc_ctx, miscdev); +} + +struct ssif_bmc_ctx *ssif_bmc_alloc(struct i2c_client *client, int sizeof_priv); + +#endif /* __SSIF_BMC_H__ */ diff --git a/drivers/char/ipmi/ssif_bmc_aspeed.c b/drivers/char/ipmi/ssif_bmc_aspeed.c new file mode 100644 index 000000000000..a563fcff5acc --- /dev/null +++ b/drivers/char/ipmi/ssif_bmc_aspeed.c @@ -0,0 +1,132 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * The driver for BMC side of Aspeed SSIF interface + * + * Copyright (c) 2021, Ampere Computing LLC + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include +#include +#include +#include + +#include "ssif_bmc.h" + +struct aspeed_i2c_bus { + struct i2c_adapter adap; + struct device *dev; + void __iomem *base; + struct reset_control *rst; + /* Synchronizes I/O mem access to base. */ + spinlock_t lock; +}; + +#define ASPEED_I2C_INTR_CTRL_REG 0x0c +#define ASPEED_I2CD_INTR_SLAVE_MATCH BIT(7) +#define ASPEED_I2CD_INTR_RX_DONE BIT(2) +static void aspeed_i2c_enable_interrupt(struct aspeed_i2c_bus *bus, unsigned long mask) +{ + unsigned long current_mask; + + current_mask = readl(bus->base + ASPEED_I2C_INTR_CTRL_REG); + writel(current_mask | mask, bus->base + ASPEED_I2C_INTR_CTRL_REG); +} + +static void aspeed_i2c_disable_interrupt(struct aspeed_i2c_bus *bus, unsigned long mask) +{ + unsigned long current_mask; + + current_mask = readl(bus->base + ASPEED_I2C_INTR_CTRL_REG); + writel(current_mask & ~mask, bus->base + ASPEED_I2C_INTR_CTRL_REG); +} + +static void aspeed_set_ssif_bmc_status(struct ssif_bmc_ctx *ssif_bmc, unsigned int status) +{ + struct aspeed_i2c_bus *bus; + unsigned long flags; + + bus = (struct aspeed_i2c_bus *)ssif_bmc->priv; + if (!bus) + return; + + spin_lock_irqsave(&bus->lock, flags); + + if (status & SSIF_BMC_BUSY) { + /* Ignore RX_DONE and SLAVE_MATCH when slave busy processing */ + aspeed_i2c_disable_interrupt(bus, ASPEED_I2CD_INTR_RX_DONE); + aspeed_i2c_disable_interrupt(bus, ASPEED_I2CD_INTR_SLAVE_MATCH); + } else if (status & SSIF_BMC_READY) { + /* Enable RX_DONE and SLAVE_MATCH when slave ready */ + aspeed_i2c_enable_interrupt(bus, ASPEED_I2CD_INTR_RX_DONE); + aspeed_i2c_enable_interrupt(bus, ASPEED_I2CD_INTR_SLAVE_MATCH); + } + + spin_unlock_irqrestore(&bus->lock, flags); +} + +static int ssif_bmc_probe(struct i2c_client *client, const struct i2c_device_id *id) +{ + struct ssif_bmc_ctx *ssif_bmc; + + ssif_bmc = ssif_bmc_alloc(client, sizeof(struct aspeed_i2c_bus)); + if (IS_ERR(ssif_bmc)) + return PTR_ERR(ssif_bmc); + + ssif_bmc->priv = i2c_get_adapdata(client->adapter); + ssif_bmc->set_ssif_bmc_status = aspeed_set_ssif_bmc_status; + + return 0; +} + +static int ssif_bmc_remove(struct i2c_client *client) +{ + struct ssif_bmc_ctx *ssif_bmc = i2c_get_clientdata(client); + + i2c_slave_unregister(client); + misc_deregister(&ssif_bmc->miscdev); + + return 0; +} + +static const struct of_device_id ssif_bmc_match[] = { + { .compatible = "aspeed,ast2500-ssif-bmc" }, + { }, +}; + +static const struct i2c_device_id ssif_bmc_id[] = { + { DEVICE_NAME, 0 }, + { }, +}; + +MODULE_DEVICE_TABLE(i2c, ssif_bmc_id); + +static struct i2c_driver ssif_bmc_driver = { + .driver = { + .name = DEVICE_NAME, + .of_match_table = ssif_bmc_match, + }, + .probe = ssif_bmc_probe, + .remove = ssif_bmc_remove, + .id_table = ssif_bmc_id, +}; + +module_i2c_driver(ssif_bmc_driver); + +MODULE_AUTHOR("Chuong Tran "); +MODULE_AUTHOR("Quan Nguyen "); +MODULE_DESCRIPTION("Linux device driver of Aspeed BMC IPMI SSIF interface."); +MODULE_LICENSE("GPL v2"); -- 2.28.0 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=-18.7 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,MSGID_FROM_MTA_HEADER,SPF_HELO_NONE, SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable 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 EA287C433DB for ; Tue, 30 Mar 2021 14:12:30 +0000 (UTC) Received: from lists.ozlabs.org (lists.ozlabs.org [112.213.38.117]) (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 66C27619BA for ; Tue, 30 Mar 2021 14:12:30 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 66C27619BA Authentication-Results: mail.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=os.amperecomputing.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=openbmc-bounces+openbmc=archiver.kernel.org@lists.ozlabs.org Received: from boromir.ozlabs.org (localhost [IPv6:::1]) by lists.ozlabs.org (Postfix) with ESMTP id 4F8rxS47qZz3c43 for ; Wed, 31 Mar 2021 01:12:28 +1100 (AEDT) Authentication-Results: lists.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=os.amperecomputing.com header.i=@os.amperecomputing.com header.a=rsa-sha256 header.s=selector2 header.b=tMlLZG8O; dkim-atps=neutral Authentication-Results: lists.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=os.amperecomputing.com (client-ip=40.107.243.101; helo=nam12-dm6-obe.outbound.protection.outlook.com; envelope-from=quan@os.amperecomputing.com; receiver=) Authentication-Results: lists.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=os.amperecomputing.com header.i=@os.amperecomputing.com header.a=rsa-sha256 header.s=selector2 header.b=tMlLZG8O; dkim-atps=neutral Received: from NAM12-DM6-obe.outbound.protection.outlook.com (mail-dm6nam12on2101.outbound.protection.outlook.com [40.107.243.101]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by lists.ozlabs.org (Postfix) with ESMTPS id 4F8rvr0hMRz3bqy; Wed, 31 Mar 2021 01:11:04 +1100 (AEDT) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=BD0NkUI4i4XvHK5E7Yhnta32tCSaOfURtZwaBAXvUSsmBBpaMaHTBl7KCHVkrfyXOvNyB0v51uTHD4KBqNKKfc5Xau2kkNaY9L/ZirHTCVbpd65ktSjYL3nxg+Qk3HhV1yOns0rFVBNj1wHHoVWuKFa44Ugwu5Ve5fQP3OxC4K5Ao6CbibHIdcrd20cHLInEDJQ/Bcfbdb+cFTqMHb1TZhDY/1Z6/b4uMBSwu84J8dHcw9zM8qtfnIMvvNlsFxP0BZ7PtBkV2iF13t1B22nO1JmyGM6vqiIxWl+8QuIpJ3YF+zRSltR2/nJrZ6WRxbPM7yfQG+3ad8LO4xLPPJpgQw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=Bl7AbniGyQZLNJ7+Q4QC8JWrE1KO2/ydCpx9+Flx7Co=; b=jP4Q2IoluGDzM9khjJIvCW6gx9CwmTvrs+pGOb8FY73w9HKx3f7odi3wvoc5n18fUedASYt7MKd/xj43dpoaPLpBa63Fl3g+CSCxyo7AtsGrq4b6vrDt0HWbt0iBsHPUSnRdR6L3bgtI/6jR4SCx++P+ql66jibcpfv3rLq1XbYIXhesl0vG2KyhSn+/sWk2fgNrBtMzCthf1l8FEi+CjTjJmgeuOHvsuYjiZG9uI42iz56sJlPUJJcawucoE0xFVd0YZ8uF8/tw+xeyzqqPBdqfEXV/2jti8taIq/WxTWRMtoGXU/VPbLXqy10ZQZPUcox2zPBvIhN3OP4xJRjmVQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=os.amperecomputing.com; dmarc=pass action=none header.from=os.amperecomputing.com; dkim=pass header.d=os.amperecomputing.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=os.amperecomputing.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=Bl7AbniGyQZLNJ7+Q4QC8JWrE1KO2/ydCpx9+Flx7Co=; b=tMlLZG8OFm33cpsiqH+YEmLlNWh/Dl8yM+lSIZUduRgyKjYUTJfDwJmnmYjhsvLTlqHPsTpbCZ0oVHUD0mMhcw6s//8LD3g36/s0n9tAkxGSqPQxKKXRHoZS6hKfoJ85KE6zEuZZdfV+23PGxb2cmEC2uHkh4hEMimJcKPHLNqM= Authentication-Results: acm.org; dkim=none (message not signed) header.d=none;acm.org; dmarc=none action=none header.from=os.amperecomputing.com; Received: from MW2PR0102MB3482.prod.exchangelabs.com (2603:10b6:302:c::32) by MW4PR01MB6338.prod.exchangelabs.com (2603:10b6:303:7b::15) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.3977.30; Tue, 30 Mar 2021 14:10:59 +0000 Received: from MW2PR0102MB3482.prod.exchangelabs.com ([fe80::d840:7aa7:58d4:b503]) by MW2PR0102MB3482.prod.exchangelabs.com ([fe80::d840:7aa7:58d4:b503%5]) with mapi id 15.20.3977.033; Tue, 30 Mar 2021 14:10:59 +0000 From: Quan Nguyen To: Corey Minyard , Rob Herring , Joel Stanley , Andrew Jeffery , Wolfram Sang , Philipp Zabel , openipmi-developer@lists.sourceforge.net, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-aspeed@lists.ozlabs.org, linux-kernel@vger.kernel.org, linux-i2c@vger.kernel.org Subject: [PATCH v2 2/3] drivers: char: ipmi: Add Aspeed SSIF BMC driver Date: Tue, 30 Mar 2021 21:10:28 +0700 Message-Id: <20210330141029.20412-3-quan@os.amperecomputing.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20210330141029.20412-1-quan@os.amperecomputing.com> References: <20210330141029.20412-1-quan@os.amperecomputing.com> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Originating-IP: [118.69.219.201] X-ClientProxiedBy: HK0PR03CA0120.apcprd03.prod.outlook.com (2603:1096:203:b0::36) To MW2PR0102MB3482.prod.exchangelabs.com (2603:10b6:302:c::32) MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 Received: from hcm-sw-17.amperecomputing.com (118.69.219.201) by HK0PR03CA0120.apcprd03.prod.outlook.com (2603:1096:203:b0::36) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.3977.29 via Frontend Transport; Tue, 30 Mar 2021 14:10:55 +0000 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 44c4c0f9-ef12-4f20-552d-08d8f385a45c X-MS-TrafficTypeDiagnostic: MW4PR01MB6338: X-MS-Exchange-Transport-Forked: True X-Microsoft-Antispam-PRVS: X-MS-Oob-TLC-OOBClassifiers: OLM:3044; X-MS-Exchange-SenderADCheck: 1 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: gSpemlJkYk4VOSTL4nB6teVURY3xRD5fkvmz3oCx5L/5ylI84aSl6nzGEY5go7swV5z18iWF8qCk24xj3YqFLmKMmi3fh210fivPq/XsrdZsNhNJ8d/6HjPpGZXw3iLGY5QB30KySG5POnDaNVH+v5dD1fRo4TFiWxV6qsSGbqNJQjBxPHOQvedWsbZtEbznkNY89WOUY6cryqIuEUs17d+KkGEp0SRch5HF2gwJqj3Kj1A+++f4Tlxb4ES+4J1PJXfQPYGDylFDC2Kt1xPHWzho5222XEU1ZgIYWF4tgH/xgQpaDzYbChs33/QHLxfSBqmkjwSLEYz5RV8EWOwTGWvCKxTLDr/Rf/S0P3Z7ksc9az0rbKMkVQrp36oz8/M8ibZ9n3+fgueg8ww8vK31XqHEJJM+kOEepB7Z2DQ/tJojOU0a7nShNXj9c6N6OcNXrgz+6PjUVtNxJ6Nsfd8cCmMXI8twU3NeLHgBxvJXtRC4OpHovHWzpts3nHMw2pOgSEAVPoBsSBpeW1JqXeeDLN1UC6hOsQHQ39G/C8Svsg/ye/dQuEk4MNbfXrnFV91pHWP+W5Oym9ZLXHEkemfBsZ8WOhNfUpjxeDrufeT392ZoQALgYsaCOuoKlEpVDsAOtZsMG+FbyXv0VCjiwcK125EC31PLbeIdi4HL9PkRW1n3ueV7A9J7Ehu8560Eq7hnwOmadPEZvmn/RRsyhn3oBOoRa/Uy4Z6vjI2rdMUHNGIDjdn3+plFBxfAVeqAvj2/Z81Y1d/xLG1QGIXWuEvGYw== X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:MW2PR0102MB3482.prod.exchangelabs.com; PTR:; CAT:NONE; SFS:(4636009)(366004)(2616005)(5660300002)(2906002)(956004)(186003)(16526019)(6512007)(66556008)(66476007)(6666004)(921005)(107886003)(52116002)(8676002)(7416002)(8936002)(86362001)(38100700001)(66946007)(110136005)(6506007)(83380400001)(498600001)(6486002)(4326008)(1076003)(30864003)(26005)(54906003)(2004002); DIR:OUT; SFP:1102; X-MS-Exchange-AntiSpam-MessageData: =?utf-8?B?NjNRc1AyMXBIby9YNTFNQ3I1NzJWcXp6dXo2NjZmZExqQVFVZG1oOWFVR3Ns?= =?utf-8?B?dkpQWTBhMnc1VVZ0Lzd5OE1pMjYwd3Rmd04zaUF3ZGJOKzQvdElYYWhuL2Vz?= =?utf-8?B?aW1tUHpXYUR5bnowUFFxM1Irc1NldUVISUZaMzRjZnBjTUtvTXZxTlJzd0Vk?= =?utf-8?B?OURGdDhPRjNFY3hlSVRUOHVzZjB1Wkg4bnN0QnFXMFFqV04yOTJqY2FmZHl3?= =?utf-8?B?bVM0R2pUMVlpR0t1b3ZpMlpHOWYwNEpNQUJSRVhYaEIrU1MvcEhVOU5yTWkx?= =?utf-8?B?M0ZHbE9aMjVPYjVpeWsvUEtqT0xTc0JxYk5yRC85dDlWSWprUUFYMDlZKzVR?= =?utf-8?B?Rm1ybG9pY29wbDdxR1dMbzhwREh2ZlJYaXpIblpGdDZ5bU5rQW5NODM3anBZ?= =?utf-8?B?US9TY3A5V2pDMmQvZFlWS20wbTFNTHpPaXNIek9aN3hvdzFkYjRadzJsM0tV?= =?utf-8?B?dmJhODVqekhQTE5pQmhKUVRDU0lDbFlNRzV6UlpoaWw4R0hTUlpoUHd6dGVD?= =?utf-8?B?VFp2R2ZqTmU1Q1VHS3lwMEtYcURMV0wyUWZzUktDbDdoNGZtc1J3UEh5MjY3?= =?utf-8?B?NERGNngrNCtnNU9ybDFSWW9NS0RhcjNUdEtIakpqci9HWUluK0h0VmxZSTdU?= =?utf-8?B?Vnl4MkpkYTR5RzJWR3M2emE1UHUvQkM0NVlEVmM5TmVqcXptOEpkUzBoTElN?= =?utf-8?B?QlFzQU1NbDRoajJYRnl1Y29CcGpnR2pGVS9WeUhtYkdnL3NMUVZMNEYvMGpk?= =?utf-8?B?WVFmVld2Z3BudUl0MkZvdkowSFAySFlhZEM5RVJCYXUwN2hycHlnQnY5RWZi?= =?utf-8?B?WU15WmxGWVh4b05hbmNKK2NGSEZsZmhHZTNoYTBWdU1PRE5Pc2FjcFFiZDJZ?= =?utf-8?B?ZjFFOVo4RFlFMXNvWXVQbGpxMllobHlaTlpORFcxekNUNkhuWWFXaktReFMy?= =?utf-8?B?U255K09pdzVzcjhnODlUZjVqTE9YUmh2bWRNQ0tFRjRIT0xNNm1mTGhuQ1ln?= =?utf-8?B?TFFKNW8ydVdMNE1xWGZ5dnRqN0hHYTZ6dHVEQW5qQWtGSjA3NWtYM1B2ZkZ3?= =?utf-8?B?RWF4ckVSZVVQZnJTd2dSWjhSVXFxbVR1ZkxlbFZLZExsLzhXQmpaT2w2RUVu?= =?utf-8?B?elhoeGNybDRQdmEzM29nNjg0ZWZKbW10NHZFeGtEREFWdVZQalVJR1BvMnRB?= =?utf-8?B?TkhZSDZSZjRBMzkyTlBVelAyVzJlNkRaZUlGNStZaTlGVmNKbG5BOU12Y0Yx?= =?utf-8?B?Z1BTNWxCK2dvV29QUFY0Sk9YeEl0bmgvUlVGWW1wS2RGKzVvMTRFT2hqYUdP?= =?utf-8?B?b2dFS2JaT0ZyS3FGR1dWZU1PRXNjUUY5YzJHZzdMRjBUYVZLWmVSd0U4OU1z?= =?utf-8?B?dXgwU2tZeUR5TkVpNytRejkzdXZxZ0srTnVVUThDcjkvandEaEFaNUJmMmZF?= =?utf-8?B?VFBycVBHblRiVTBkRmdWeExqZ2FQMjBpWndKMkp5OER6ZERlb1BCaDBVcE1z?= =?utf-8?B?QVk0WVBhbGQvamFtRlg0N2pUT2hFNjNqSXhuaUFNajIvYzU4VlFFazY0Qkd0?= =?utf-8?B?a2xoV0ZhejZsbE5xR2NDZHNkdlR2aGVRMWc1Qk45TENpM2lMQkR0dFVHZjhS?= =?utf-8?B?RE1PZkJldWpPWk4ybmxXL1VSM1ZuWkJPSDVUUFpzK3VNWXVtQ2RpVDVscGcw?= =?utf-8?B?eHE5YlFZa3ViM0ZOMUV6NnNJQWpqaWJIcWtORUlud28vUzNsSERRVDFUUFF2?= =?utf-8?Q?uOvWFARjh7aAlW3g1iyHNhEp+K2ttGAJqs5Uy63?= X-OriginatorOrg: os.amperecomputing.com X-MS-Exchange-CrossTenant-Network-Message-Id: 44c4c0f9-ef12-4f20-552d-08d8f385a45c X-MS-Exchange-CrossTenant-AuthSource: MW2PR0102MB3482.prod.exchangelabs.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 30 Mar 2021 14:10:59.1656 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 3bc2b170-fd94-476d-b0ce-4229bdc904a7 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: WUJuAzAV1NTx1k5k1de2OfGuZQdwbYLOL7QU2pZxE1mLb82pQBb6Cuzm503waeM8phJP9kpdo0/7USbWJJ+MsyW2hnuCdGgzu4szQ0lN1fE= X-MS-Exchange-Transport-CrossTenantHeadersStamped: MW4PR01MB6338 X-BeenThere: openbmc@lists.ozlabs.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Development list for OpenBMC List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: openbmc@lists.ozlabs.org, "Thang Q . Nguyen" , Open Source Submission , Phong Vo Errors-To: openbmc-bounces+openbmc=archiver.kernel.org@lists.ozlabs.org Sender: "openbmc" The SMBus system interface (SSIF) IPMI BMC driver can be used to perform in-band IPMI communication with their host in management (BMC) side. This commits adds support specifically for Aspeed AST2500 which commonly used as Board Management Controllers. Signed-off-by: Quan Nguyen --- drivers/char/ipmi/Kconfig | 22 + drivers/char/ipmi/Makefile | 2 + drivers/char/ipmi/ssif_bmc.c | 645 ++++++++++++++++++++++++++++ drivers/char/ipmi/ssif_bmc.h | 92 ++++ drivers/char/ipmi/ssif_bmc_aspeed.c | 132 ++++++ 5 files changed, 893 insertions(+) create mode 100644 drivers/char/ipmi/ssif_bmc.c create mode 100644 drivers/char/ipmi/ssif_bmc.h create mode 100644 drivers/char/ipmi/ssif_bmc_aspeed.c diff --git a/drivers/char/ipmi/Kconfig b/drivers/char/ipmi/Kconfig index 07847d9a459a..45be57023577 100644 --- a/drivers/char/ipmi/Kconfig +++ b/drivers/char/ipmi/Kconfig @@ -133,6 +133,28 @@ config ASPEED_BT_IPMI_BMC found on Aspeed SOCs (AST2400 and AST2500). The driver implements the BMC side of the BT interface. +config SSIF_IPMI_BMC + tristate "SSIF IPMI BMC driver" + select I2C + select I2C_SLAVE + help + This enables the IPMI SMBus system interface (SSIF) at the + management (BMC) side. + + The driver implements the BMC side of the SMBus system + interface (SSIF). + +config ASPEED_SSIF_IPMI_BMC + depends on ARCH_ASPEED || COMPILE_TEST + select SSIF_IPMI_BMC + tristate "Aspeed SSIF IPMI BMC driver" + help + Provides a driver for the SSIF IPMI interface found on + Aspeed AST2500 SoC. + + The driver implements the BMC side of the SMBus system + interface (SSIF), specific for Aspeed AST2500 SoC. + config IPMB_DEVICE_INTERFACE tristate 'IPMB Interface handler' depends on I2C diff --git a/drivers/char/ipmi/Makefile b/drivers/char/ipmi/Makefile index 0822adc2ec41..05b993f7335b 100644 --- a/drivers/char/ipmi/Makefile +++ b/drivers/char/ipmi/Makefile @@ -27,3 +27,5 @@ obj-$(CONFIG_ASPEED_BT_IPMI_BMC) += bt-bmc.o obj-$(CONFIG_ASPEED_KCS_IPMI_BMC) += kcs_bmc_aspeed.o obj-$(CONFIG_NPCM7XX_KCS_IPMI_BMC) += kcs_bmc_npcm7xx.o obj-$(CONFIG_IPMB_DEVICE_INTERFACE) += ipmb_dev_int.o +obj-$(CONFIG_SSIF_IPMI_BMC) += ssif_bmc.o +obj-$(CONFIG_ASPEED_SSIF_IPMI_BMC) += ssif_bmc_aspeed.o diff --git a/drivers/char/ipmi/ssif_bmc.c b/drivers/char/ipmi/ssif_bmc.c new file mode 100644 index 000000000000..ae6e8750c795 --- /dev/null +++ b/drivers/char/ipmi/ssif_bmc.c @@ -0,0 +1,645 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * The driver for BMC side of SSIF interface + * + * Copyright (c) 2021, Ampere Computing LLC + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "ssif_bmc.h" + +/* + * Call in WRITE context + */ +static int send_ssif_bmc_response(struct ssif_bmc_ctx *ssif_bmc, bool non_blocking) +{ + unsigned long flags; + int ret; + + if (!non_blocking) { +retry: + ret = wait_event_interruptible(ssif_bmc->wait_queue, + !ssif_bmc->response_in_progress); + if (ret) + return ret; + } + + spin_lock_irqsave(&ssif_bmc->lock, flags); + if (ssif_bmc->response_in_progress) { + spin_unlock_irqrestore(&ssif_bmc->lock, flags); + if (non_blocking) + return -EAGAIN; + + goto retry; + } + + /* + * Check the response data length from userspace to determine the type + * of the response message whether it is single-part or multi-part. + */ + ssif_bmc->is_singlepart_read = + (ssif_msg_len(&ssif_bmc->response) <= (MAX_PAYLOAD_PER_TRANSACTION + 1)) ? + true : false; /* 1: byte of length */ + + ssif_bmc->response_in_progress = true; + spin_unlock_irqrestore(&ssif_bmc->lock, flags); + + return 0; +} + +/* + * Call in READ context + */ +static int receive_ssif_bmc_request(struct ssif_bmc_ctx *ssif_bmc, bool non_blocking) +{ + unsigned long flags; + int ret; + + if (!non_blocking) { +retry: + ret = wait_event_interruptible(ssif_bmc->wait_queue, + ssif_bmc->request_available); + if (ret) + return ret; + } + + spin_lock_irqsave(&ssif_bmc->lock, flags); + if (!ssif_bmc->request_available) { + spin_unlock_irqrestore(&ssif_bmc->lock, flags); + if (non_blocking) + return -EAGAIN; + goto retry; + } + spin_unlock_irqrestore(&ssif_bmc->lock, flags); + + return 0; +} + +/* Handle SSIF message that will be sent to user */ +static ssize_t ssif_bmc_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) +{ + struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file); + struct ssif_msg msg; + unsigned long flags; + ssize_t ret; + + mutex_lock(&ssif_bmc->file_mutex); + + ret = receive_ssif_bmc_request(ssif_bmc, file->f_flags & O_NONBLOCK); + if (ret < 0) + goto out; + + spin_lock_irqsave(&ssif_bmc->lock, flags); + count = min_t(ssize_t, count, ssif_msg_len(&ssif_bmc->request)); + memcpy(&msg, &ssif_bmc->request, count); + ssif_bmc->request_available = false; + spin_unlock_irqrestore(&ssif_bmc->lock, flags); + + ret = copy_to_user(buf, &msg, count); +out: + mutex_unlock(&ssif_bmc->file_mutex); + + return (ret < 0) ? ret : count; +} + +/* Handle SSIF message that is written by user */ +static ssize_t ssif_bmc_write(struct file *file, const char __user *buf, size_t count, + loff_t *ppos) +{ + struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file); + struct ssif_msg msg; + unsigned long flags; + ssize_t ret; + + if (count > sizeof(struct ssif_msg)) + return -EINVAL; + + mutex_lock(&ssif_bmc->file_mutex); + + ret = copy_from_user(&msg, buf, count); + if (ret) + goto out; + + spin_lock_irqsave(&ssif_bmc->lock, flags); + if (count >= ssif_msg_len(&ssif_bmc->response)) + memcpy(&ssif_bmc->response, &msg, count); + else + ret = -EINVAL; + spin_unlock_irqrestore(&ssif_bmc->lock, flags); + + if (ret) + goto out; + + ret = send_ssif_bmc_response(ssif_bmc, file->f_flags & O_NONBLOCK); + if (!ret && ssif_bmc->set_ssif_bmc_status) + ssif_bmc->set_ssif_bmc_status(ssif_bmc, SSIF_BMC_READY); +out: + mutex_unlock(&ssif_bmc->file_mutex); + + return (ret < 0) ? ret : count; +} + +static long ssif_bmc_ioctl(struct file *file, unsigned int cmd, unsigned long param) +{ + return 0; +} + +static unsigned int ssif_bmc_poll(struct file *file, poll_table *wait) +{ + struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file); + unsigned int mask = 0; + + mutex_lock(&ssif_bmc->file_mutex); + poll_wait(file, &ssif_bmc->wait_queue, wait); + + /* + * The request message is now available so userspace application can + * get the request + */ + if (ssif_bmc->request_available) + mask |= POLLIN; + + mutex_unlock(&ssif_bmc->file_mutex); + return mask; +} + +/* + * System calls to device interface for user apps + */ +static const struct file_operations ssif_bmc_fops = { + .owner = THIS_MODULE, + .read = ssif_bmc_read, + .write = ssif_bmc_write, + .poll = ssif_bmc_poll, + .unlocked_ioctl = ssif_bmc_ioctl, +}; + +/* Called with ssif_bmc->lock held. */ +static int handle_request(struct ssif_bmc_ctx *ssif_bmc) +{ + if (ssif_bmc->set_ssif_bmc_status) + ssif_bmc->set_ssif_bmc_status(ssif_bmc, SSIF_BMC_BUSY); + + /* Request message is available to process */ + ssif_bmc->request_available = true; + /* + * This is the new READ request. + * Clear the response buffer of the previous transaction + */ + memset(&ssif_bmc->response, 0, sizeof(struct ssif_msg)); + wake_up_all(&ssif_bmc->wait_queue); + return 0; +} + +/* Called with ssif_bmc->lock held. */ +static int complete_response(struct ssif_bmc_ctx *ssif_bmc) +{ + /* Invalidate response in buffer to denote it having been sent. */ + ssif_bmc->response.len = 0; + ssif_bmc->response_in_progress = false; + ssif_bmc->nbytes_processed = 0; + ssif_bmc->remain_len = 0; + memset(&ssif_bmc->response_buf, 0, MAX_PAYLOAD_PER_TRANSACTION); + wake_up_all(&ssif_bmc->wait_queue); + return 0; +} + +static void set_multipart_response_buffer(struct ssif_bmc_ctx *ssif_bmc, u8 *val) +{ + u8 response_len = 0; + int idx = 0; + u8 data_len; + + data_len = ssif_bmc->response.len; + switch (ssif_bmc->smbus_cmd) { + case SSIF_IPMI_MULTIPART_READ_START: + /* + * Read Start length is 32 bytes. + * Read Start transfer first 30 bytes of IPMI response + * and 2 special code 0x00, 0x01. + */ + *val = MAX_PAYLOAD_PER_TRANSACTION; + ssif_bmc->remain_len = data_len - MAX_IPMI_DATA_PER_START_TRANSACTION; + ssif_bmc->block_num = 0; + + ssif_bmc->response_buf[idx++] = 0x00; /* Start Flag */ + ssif_bmc->response_buf[idx++] = 0x01; /* Start Flag */ + ssif_bmc->response_buf[idx++] = ssif_bmc->response.netfn_lun; + ssif_bmc->response_buf[idx++] = ssif_bmc->response.cmd; + ssif_bmc->response_buf[idx++] = ssif_bmc->response.payload[0]; + + response_len = MAX_PAYLOAD_PER_TRANSACTION - idx; + + memcpy(&ssif_bmc->response_buf[idx], &ssif_bmc->response.payload[1], + response_len); + break; + + case SSIF_IPMI_MULTIPART_READ_MIDDLE: + /* + * IPMI READ Middle or READ End messages can carry up to 31 bytes + * IPMI data plus block number byte. + */ + if (ssif_bmc->remain_len < MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION) { + /* + * This is READ End message + * Return length is the remaining response data length + * plus block number + * Block number 0xFF is to indicate this is last message + * + * Return length is: remain response plus block number + */ + *val = ssif_bmc->remain_len + 1; + ssif_bmc->block_num = 0xFF; + ssif_bmc->response_buf[idx++] = ssif_bmc->block_num; + response_len = ssif_bmc->remain_len; + } else { + /* + * This is READ Middle message + * Response length is the maximum SMBUS transfer length + * Block number byte is incremented + * Return length is maximum SMBUS transfer length + */ + *val = MAX_PAYLOAD_PER_TRANSACTION; + ssif_bmc->remain_len -= MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION; + response_len = MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION; + ssif_bmc->response_buf[idx++] = ssif_bmc->block_num; + ssif_bmc->block_num++; + } + + memcpy(&ssif_bmc->response_buf[idx], + ssif_bmc->response.payload + 1 + ssif_bmc->nbytes_processed, + response_len); + break; + + default: + /* Do not expect to go to this case */ + pr_err("Error: Unexpected SMBus command received 0x%x\n", ssif_bmc->smbus_cmd); + break; + } + + ssif_bmc->nbytes_processed += response_len; +} + +static void set_singlepart_response_buffer(struct ssif_bmc_ctx *ssif_bmc, u8 *val) +{ + u8 *buf = (u8 *)&ssif_bmc->response; + + /* + * Do not expect the IPMI response has data length 0. + * With some I2C SMBus controllers (Aspeed I2C), return 0 for + * the SMBus Read Request callback might cause bad state for + * the bus. So return 1 byte length so that master will + * resend the Read Request because the length of response is + * less than a normal IPMI response. + * + * Otherwise, return the length of IPMI response + */ + *val = (buf[ssif_bmc->msg_idx]) ? buf[ssif_bmc->msg_idx] : 0x1; +} + +/* Process the IPMI response that will be read by master */ +static void handle_read_processed(struct ssif_bmc_ctx *ssif_bmc, u8 *val) +{ + u8 *buf; + u8 pec_len, addr, len; + u8 pec = 0; + + pec_len = ssif_bmc->pec_support ? 1 : 0; + /* PEC - Start Read Address */ + addr = GET_8BIT_ADDR(ssif_bmc->client->addr); + pec = i2c_smbus_pec(pec, &addr, 1); + /* PEC - SSIF Command */ + pec = i2c_smbus_pec(pec, &ssif_bmc->smbus_cmd, 1); + /* PEC - Restart Write Address */ + addr = addr | 0x01; + pec = i2c_smbus_pec(pec, &addr, 1); + + if (ssif_bmc->is_singlepart_read) { + /* Single-part Read processing */ + buf = (u8 *)&ssif_bmc->response; + + if (ssif_bmc->response.len && ssif_bmc->msg_idx < ssif_bmc->response.len) { + ssif_bmc->msg_idx++; + *val = buf[ssif_bmc->msg_idx]; + } else if (ssif_bmc->response.len && + (ssif_bmc->msg_idx == ssif_bmc->response.len)) { + ssif_bmc->msg_idx++; + *val = i2c_smbus_pec(pec, buf, ssif_msg_len(&ssif_bmc->response)); + } else { + *val = 0; + } + /* Invalidate response buffer to denote it is sent */ + if (ssif_bmc->msg_idx + 1 >= (ssif_msg_len(&ssif_bmc->response) + pec_len)) + complete_response(ssif_bmc); + } else { + /* Multi-part Read processing */ + switch (ssif_bmc->smbus_cmd) { + case SSIF_IPMI_MULTIPART_READ_START: + case SSIF_IPMI_MULTIPART_READ_MIDDLE: + buf = (u8 *)&ssif_bmc->response_buf; + *val = buf[ssif_bmc->msg_idx]; + ssif_bmc->msg_idx++; + break; + default: + /* Do not expect to go to this case */ + pr_err("Error: Unexpected SMBus command received 0x%x\n", + ssif_bmc->smbus_cmd); + break; + } + len = (ssif_bmc->block_num == 0xFF) ? + ssif_bmc->remain_len + 1 : MAX_PAYLOAD_PER_TRANSACTION; + if (ssif_bmc->msg_idx == (len + 1)) { + pec = i2c_smbus_pec(pec, &len, 1); + *val = i2c_smbus_pec(pec, ssif_bmc->response_buf, len); + } + /* Invalidate response buffer to denote last response is sent */ + if (ssif_bmc->block_num == 0xFF && + ssif_bmc->msg_idx > (ssif_bmc->remain_len + pec_len)) { + complete_response(ssif_bmc); + } + } +} + +static void handle_write_received(struct ssif_bmc_ctx *ssif_bmc, u8 *val) +{ + u8 *buf; + u8 smbus_cmd; + + buf = (u8 *)&ssif_bmc->request; + if (ssif_bmc->msg_idx >= sizeof(struct ssif_msg)) + return; + + smbus_cmd = ssif_bmc->smbus_cmd; + switch (smbus_cmd) { + case SSIF_IPMI_SINGLEPART_WRITE: + /* Single-part write */ + buf[ssif_bmc->msg_idx - 1] = *val; + ssif_bmc->msg_idx++; + + break; + case SSIF_IPMI_MULTIPART_WRITE_START: + /* Reset length to zero */ + if (ssif_bmc->msg_idx == 1) + ssif_bmc->request.len = 0; + + fallthrough; + case SSIF_IPMI_MULTIPART_WRITE_MIDDLE: + case SSIF_IPMI_MULTIPART_WRITE_END: + /* Multi-part write, 2nd byte received is length */ + if (ssif_bmc->msg_idx == 1) { + ssif_bmc->request.len += *val; + ssif_bmc->recv_len = *val; + } else { + buf[ssif_bmc->msg_idx - 1 + + ssif_bmc->request.len - ssif_bmc->recv_len] = *val; + } + + ssif_bmc->msg_idx++; + + break; + default: + /* Do not expect to go to this case */ + pr_err("Error: Unexpected SMBus command received 0x%x\n", ssif_bmc->smbus_cmd); + break; + } +} + +static bool validate_pec(struct ssif_bmc_ctx *ssif_bmc) +{ + u8 rpec = 0, cpec = 0; + bool ret = true; + u8 addr, index; + u8 *buf; + + buf = (u8 *)&ssif_bmc->request; + switch (ssif_bmc->smbus_cmd) { + case SSIF_IPMI_SINGLEPART_WRITE: + if ((ssif_bmc->msg_idx - 1) == ssif_msg_len(&ssif_bmc->request)) { + /* PEC is not included */ + ssif_bmc->pec_support = false; + return true; + } + + if ((ssif_bmc->msg_idx - 1) != (ssif_msg_len(&ssif_bmc->request) + 1)) + goto error; + + /* PEC is included */ + ssif_bmc->pec_support = true; + rpec = buf[ssif_bmc->msg_idx - 2]; + addr = GET_8BIT_ADDR(ssif_bmc->client->addr); + cpec = i2c_smbus_pec(cpec, &addr, 1); + cpec = i2c_smbus_pec(cpec, &ssif_bmc->smbus_cmd, 1); + cpec = i2c_smbus_pec(cpec, buf, ssif_msg_len(&ssif_bmc->request)); + if (rpec != cpec) { + pr_err("Bad PEC 0x%02x vs. 0x%02x\n", rpec, cpec); + ret = false; + } + + break; + case SSIF_IPMI_MULTIPART_WRITE_START: + case SSIF_IPMI_MULTIPART_WRITE_MIDDLE: + case SSIF_IPMI_MULTIPART_WRITE_END: + index = ssif_bmc->request.len - ssif_bmc->recv_len; + if ((ssif_bmc->msg_idx - 1 + index) == ssif_msg_len(&ssif_bmc->request)) { + /* PEC is not included */ + ssif_bmc->pec_support = false; + return true; + } + + if ((ssif_bmc->msg_idx - 1 + index) != (ssif_msg_len(&ssif_bmc->request) + 1)) + goto error; + + /* PEC is included */ + ssif_bmc->pec_support = true; + rpec = buf[ssif_bmc->msg_idx - 2 + index]; + addr = GET_8BIT_ADDR(ssif_bmc->client->addr); + cpec = i2c_smbus_pec(cpec, &addr, 1); + cpec = i2c_smbus_pec(cpec, &ssif_bmc->smbus_cmd, 1); + cpec = i2c_smbus_pec(cpec, &ssif_bmc->recv_len, 1); + /* As SMBus specification does not allow the length + * (byte count) in the Write-Block protocol to be zero. + * Therefore, it is illegal to have the last Middle + * transaction in the sequence carry 32-bytes and have + * a length of ‘0’ in the End transaction. + * But some users may try to use this way and we should + * prevent ssif_bmc driver broken in this case. + */ + if (ssif_bmc->recv_len != 0) + cpec = i2c_smbus_pec(cpec, buf + 1 + index, ssif_bmc->recv_len); + + if (rpec != cpec) { + pr_err("Bad PEC 0x%02x vs. 0x%02x\n", rpec, cpec); + ret = false; + } + + break; + default: + break; + } + + return ret; +error: + /* Do not expect to go to this case */ + pr_err("Error: Unexpected length received %d\n", ssif_msg_len(&ssif_bmc->request)); + + return false; +} + +static void complete_write_received(struct ssif_bmc_ctx *ssif_bmc) +{ + u8 cmd = ssif_bmc->smbus_cmd; + + /* A BMC that receives an invalid PEC shall drop the data for the write + * transaction and any further transactions (read or write) until + * the next valid read or write Start transaction is received + */ + if (!validate_pec(ssif_bmc)) { + pr_err("Received invalid PEC\n"); + return; + } + + if (cmd == SSIF_IPMI_SINGLEPART_WRITE || cmd == SSIF_IPMI_MULTIPART_WRITE_END) + handle_request(ssif_bmc); +} + +/* + * Callback function to handle I2C slave events + */ +static int ssif_bmc_cb(struct i2c_client *client, enum i2c_slave_event event, u8 *val) +{ + struct ssif_bmc_ctx *ssif_bmc = i2c_get_clientdata(client); + + spin_lock(&ssif_bmc->lock); + + /* I2C Event Handler: + * I2C_SLAVE_READ_REQUESTED 0x0 + * I2C_SLAVE_WRITE_REQUESTED 0x1 + * I2C_SLAVE_READ_PROCESSED 0x2 + * I2C_SLAVE_WRITE_RECEIVED 0x3 + * I2C_SLAVE_STOP 0x4 + */ + switch (event) { + case I2C_SLAVE_READ_REQUESTED: + ssif_bmc->msg_idx = 0; + if (ssif_bmc->is_singlepart_read) + set_singlepart_response_buffer(ssif_bmc, val); + else + set_multipart_response_buffer(ssif_bmc, val); + break; + + case I2C_SLAVE_WRITE_REQUESTED: + ssif_bmc->msg_idx = 0; + break; + + case I2C_SLAVE_READ_PROCESSED: + handle_read_processed(ssif_bmc, val); + break; + + case I2C_SLAVE_WRITE_RECEIVED: + /* + * First byte is SMBUS command, not a part of SSIF message. + * SSIF request buffer starts with msg_idx 1 for the first + * buffer byte. + */ + if (ssif_bmc->msg_idx == 0) { + /* SMBUS command can vary (single or multi-part) */ + ssif_bmc->smbus_cmd = *val; + ssif_bmc->msg_idx++; + } else { + handle_write_received(ssif_bmc, val); + } + + break; + + case I2C_SLAVE_STOP: + /* + * PEC byte is appended at the end of each transaction. + * Detect PEC is support or not after receiving write request + * completely. + */ + if (ssif_bmc->last_event == I2C_SLAVE_WRITE_RECEIVED) + complete_write_received(ssif_bmc); + /* Reset message index */ + ssif_bmc->msg_idx = 0; + break; + + default: + break; + } + ssif_bmc->last_event = event; + spin_unlock(&ssif_bmc->lock); + + return 0; +} + +struct ssif_bmc_ctx *ssif_bmc_alloc(struct i2c_client *client, int sizeof_priv) +{ + struct ssif_bmc_ctx *ssif_bmc; + int ret; + + ssif_bmc = devm_kzalloc(&client->dev, sizeof(*ssif_bmc) + sizeof_priv, GFP_KERNEL); + if (!ssif_bmc) + return ERR_PTR(-ENOMEM); + + spin_lock_init(&ssif_bmc->lock); + + init_waitqueue_head(&ssif_bmc->wait_queue); + ssif_bmc->request_available = false; + ssif_bmc->response_in_progress = false; + + mutex_init(&ssif_bmc->file_mutex); + + /* Register misc device interface */ + ssif_bmc->miscdev.minor = MISC_DYNAMIC_MINOR; + ssif_bmc->miscdev.name = DEVICE_NAME; + ssif_bmc->miscdev.fops = &ssif_bmc_fops; + ssif_bmc->miscdev.parent = &client->dev; + ret = misc_register(&ssif_bmc->miscdev); + if (ret) + goto out; + + ssif_bmc->client = client; + ssif_bmc->client->flags |= I2C_CLIENT_SLAVE; + + /* Register I2C slave */ + i2c_set_clientdata(client, ssif_bmc); + ret = i2c_slave_register(client, ssif_bmc_cb); + if (ret) { + misc_deregister(&ssif_bmc->miscdev); + goto out; + } + + return ssif_bmc; + +out: + devm_kfree(&client->dev, ssif_bmc); + return ERR_PTR(ret); +} +EXPORT_SYMBOL(ssif_bmc_alloc); + +MODULE_AUTHOR("Chuong Tran "); +MODULE_AUTHOR("Quan Nguyen "); +MODULE_DESCRIPTION("Linux device driver of the BMC IPMI SSIF interface."); +MODULE_LICENSE("GPL v2"); diff --git a/drivers/char/ipmi/ssif_bmc.h b/drivers/char/ipmi/ssif_bmc.h new file mode 100644 index 000000000000..a2ee090572db --- /dev/null +++ b/drivers/char/ipmi/ssif_bmc.h @@ -0,0 +1,92 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * The driver for BMC side of SSIF interface + * + * Copyright (c) 2021, Ampere Computing LLC + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#ifndef __SSIF_BMC_H__ +#define __SSIF_BMC_H__ + +#define DEVICE_NAME "ipmi-ssif-host" + +#define GET_8BIT_ADDR(addr_7bit) (((addr_7bit) << 1) & 0xff) + +#define MSG_PAYLOAD_LEN_MAX 252 + +/* A standard SMBus Transaction is limited to 32 data bytes */ +#define MAX_PAYLOAD_PER_TRANSACTION 32 + +#define MAX_IPMI_DATA_PER_START_TRANSACTION 30 +#define MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION 31 + +#define SSIF_IPMI_SINGLEPART_WRITE 0x2 +#define SSIF_IPMI_SINGLEPART_READ 0x3 +#define SSIF_IPMI_MULTIPART_WRITE_START 0x6 +#define SSIF_IPMI_MULTIPART_WRITE_MIDDLE 0x7 +#define SSIF_IPMI_MULTIPART_WRITE_END 0x8 +#define SSIF_IPMI_MULTIPART_READ_START 0x3 +#define SSIF_IPMI_MULTIPART_READ_MIDDLE 0x9 + +struct ssif_msg { + u8 len; + u8 netfn_lun; + u8 cmd; + u8 payload[MSG_PAYLOAD_LEN_MAX]; +} __packed; + +static inline u32 ssif_msg_len(struct ssif_msg *ssif_msg) +{ + return ssif_msg->len + 1; +} + +#define SSIF_BMC_BUSY 0x01 +#define SSIF_BMC_READY 0x02 + +struct ssif_bmc_ctx { + struct i2c_client *client; + struct miscdevice miscdev; + u8 smbus_cmd; + struct ssif_msg request; + bool request_available; + struct ssif_msg response; + bool response_in_progress; + /* Response buffer for Multi-part Read Transaction */ + u8 response_buf[MAX_PAYLOAD_PER_TRANSACTION]; + /* Flag to identify a Multi-part Read Transaction */ + bool is_singlepart_read; + u8 nbytes_processed; + u8 remain_len; + u8 recv_len; + /* Block Number of a Multi-part Read Transaction */ + u8 block_num; + size_t msg_idx; + enum i2c_slave_event last_event; + bool pec_support; + spinlock_t lock; + wait_queue_head_t wait_queue; + struct mutex file_mutex; + void (*set_ssif_bmc_status)(struct ssif_bmc_ctx *ssif_bmc, unsigned int flags); + void *priv; +}; + +static inline struct ssif_bmc_ctx *to_ssif_bmc(struct file *file) +{ + return container_of(file->private_data, struct ssif_bmc_ctx, miscdev); +} + +struct ssif_bmc_ctx *ssif_bmc_alloc(struct i2c_client *client, int sizeof_priv); + +#endif /* __SSIF_BMC_H__ */ diff --git a/drivers/char/ipmi/ssif_bmc_aspeed.c b/drivers/char/ipmi/ssif_bmc_aspeed.c new file mode 100644 index 000000000000..a563fcff5acc --- /dev/null +++ b/drivers/char/ipmi/ssif_bmc_aspeed.c @@ -0,0 +1,132 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * The driver for BMC side of Aspeed SSIF interface + * + * Copyright (c) 2021, Ampere Computing LLC + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include +#include +#include +#include + +#include "ssif_bmc.h" + +struct aspeed_i2c_bus { + struct i2c_adapter adap; + struct device *dev; + void __iomem *base; + struct reset_control *rst; + /* Synchronizes I/O mem access to base. */ + spinlock_t lock; +}; + +#define ASPEED_I2C_INTR_CTRL_REG 0x0c +#define ASPEED_I2CD_INTR_SLAVE_MATCH BIT(7) +#define ASPEED_I2CD_INTR_RX_DONE BIT(2) +static void aspeed_i2c_enable_interrupt(struct aspeed_i2c_bus *bus, unsigned long mask) +{ + unsigned long current_mask; + + current_mask = readl(bus->base + ASPEED_I2C_INTR_CTRL_REG); + writel(current_mask | mask, bus->base + ASPEED_I2C_INTR_CTRL_REG); +} + +static void aspeed_i2c_disable_interrupt(struct aspeed_i2c_bus *bus, unsigned long mask) +{ + unsigned long current_mask; + + current_mask = readl(bus->base + ASPEED_I2C_INTR_CTRL_REG); + writel(current_mask & ~mask, bus->base + ASPEED_I2C_INTR_CTRL_REG); +} + +static void aspeed_set_ssif_bmc_status(struct ssif_bmc_ctx *ssif_bmc, unsigned int status) +{ + struct aspeed_i2c_bus *bus; + unsigned long flags; + + bus = (struct aspeed_i2c_bus *)ssif_bmc->priv; + if (!bus) + return; + + spin_lock_irqsave(&bus->lock, flags); + + if (status & SSIF_BMC_BUSY) { + /* Ignore RX_DONE and SLAVE_MATCH when slave busy processing */ + aspeed_i2c_disable_interrupt(bus, ASPEED_I2CD_INTR_RX_DONE); + aspeed_i2c_disable_interrupt(bus, ASPEED_I2CD_INTR_SLAVE_MATCH); + } else if (status & SSIF_BMC_READY) { + /* Enable RX_DONE and SLAVE_MATCH when slave ready */ + aspeed_i2c_enable_interrupt(bus, ASPEED_I2CD_INTR_RX_DONE); + aspeed_i2c_enable_interrupt(bus, ASPEED_I2CD_INTR_SLAVE_MATCH); + } + + spin_unlock_irqrestore(&bus->lock, flags); +} + +static int ssif_bmc_probe(struct i2c_client *client, const struct i2c_device_id *id) +{ + struct ssif_bmc_ctx *ssif_bmc; + + ssif_bmc = ssif_bmc_alloc(client, sizeof(struct aspeed_i2c_bus)); + if (IS_ERR(ssif_bmc)) + return PTR_ERR(ssif_bmc); + + ssif_bmc->priv = i2c_get_adapdata(client->adapter); + ssif_bmc->set_ssif_bmc_status = aspeed_set_ssif_bmc_status; + + return 0; +} + +static int ssif_bmc_remove(struct i2c_client *client) +{ + struct ssif_bmc_ctx *ssif_bmc = i2c_get_clientdata(client); + + i2c_slave_unregister(client); + misc_deregister(&ssif_bmc->miscdev); + + return 0; +} + +static const struct of_device_id ssif_bmc_match[] = { + { .compatible = "aspeed,ast2500-ssif-bmc" }, + { }, +}; + +static const struct i2c_device_id ssif_bmc_id[] = { + { DEVICE_NAME, 0 }, + { }, +}; + +MODULE_DEVICE_TABLE(i2c, ssif_bmc_id); + +static struct i2c_driver ssif_bmc_driver = { + .driver = { + .name = DEVICE_NAME, + .of_match_table = ssif_bmc_match, + }, + .probe = ssif_bmc_probe, + .remove = ssif_bmc_remove, + .id_table = ssif_bmc_id, +}; + +module_i2c_driver(ssif_bmc_driver); + +MODULE_AUTHOR("Chuong Tran "); +MODULE_AUTHOR("Quan Nguyen "); +MODULE_DESCRIPTION("Linux device driver of Aspeed BMC IPMI SSIF interface."); +MODULE_LICENSE("GPL v2"); -- 2.28.0 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=-16.8 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,MSGID_FROM_MTA_HEADER,SPF_HELO_NONE, 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 545DEC433E0 for ; Tue, 30 Mar 2021 14:13:26 +0000 (UTC) Received: from desiato.infradead.org (desiato.infradead.org [90.155.92.199]) (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 7A45E619C8 for ; Tue, 30 Mar 2021 14:13:25 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 7A45E619C8 Authentication-Results: mail.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=os.amperecomputing.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=desiato.20200630; h=Sender:Content-Transfer-Encoding :Content-Type:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To:Message-Id:Date: Subject:Cc:To:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=fYBkN3Eijuq76VXVmDeTlO+vBkqHirxQD9LDO6Y2NPY=; b=BMqh8Pq73q9gBsArKVlxqyNKC 9LNWOGTLJMyOCchfzu5x4wwtbGUcvpxB0V8W75W4UB6Rus6f/IxLA7DkFxlPDJwAvqYfnv8YJOjXf ey0aVi3nQmBmpgT0g7/hi9hPY5OWtcnoLT0gRuM14yh56biDA8ywjOgyL57I+2A6TvYg5Jgzosb/g zBscCIwQ9DNQZMxPUrKfOZ3nJoBoeD9atOGYfcAvrRuNFRUzif+JvRDi4oIUORdYfo3cV8YKckAW2 pSOGortGNXd/g819j+/D2azjgYWyRE/ZSsSX0M8cDZQGvgMvSpeZkQvbBMFiNo+AjDapxOhZtohQb j5JWOxXOA==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lRF5o-003wi1-Rt; Tue, 30 Mar 2021 14:11:41 +0000 Received: from mail-dm6nam12on2092.outbound.protection.outlook.com ([40.107.243.92] helo=NAM12-DM6-obe.outbound.protection.outlook.com) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lRF5F-003waA-En for linux-arm-kernel@lists.infradead.org; Tue, 30 Mar 2021 14:11:09 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=BD0NkUI4i4XvHK5E7Yhnta32tCSaOfURtZwaBAXvUSsmBBpaMaHTBl7KCHVkrfyXOvNyB0v51uTHD4KBqNKKfc5Xau2kkNaY9L/ZirHTCVbpd65ktSjYL3nxg+Qk3HhV1yOns0rFVBNj1wHHoVWuKFa44Ugwu5Ve5fQP3OxC4K5Ao6CbibHIdcrd20cHLInEDJQ/Bcfbdb+cFTqMHb1TZhDY/1Z6/b4uMBSwu84J8dHcw9zM8qtfnIMvvNlsFxP0BZ7PtBkV2iF13t1B22nO1JmyGM6vqiIxWl+8QuIpJ3YF+zRSltR2/nJrZ6WRxbPM7yfQG+3ad8LO4xLPPJpgQw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=Bl7AbniGyQZLNJ7+Q4QC8JWrE1KO2/ydCpx9+Flx7Co=; b=jP4Q2IoluGDzM9khjJIvCW6gx9CwmTvrs+pGOb8FY73w9HKx3f7odi3wvoc5n18fUedASYt7MKd/xj43dpoaPLpBa63Fl3g+CSCxyo7AtsGrq4b6vrDt0HWbt0iBsHPUSnRdR6L3bgtI/6jR4SCx++P+ql66jibcpfv3rLq1XbYIXhesl0vG2KyhSn+/sWk2fgNrBtMzCthf1l8FEi+CjTjJmgeuOHvsuYjiZG9uI42iz56sJlPUJJcawucoE0xFVd0YZ8uF8/tw+xeyzqqPBdqfEXV/2jti8taIq/WxTWRMtoGXU/VPbLXqy10ZQZPUcox2zPBvIhN3OP4xJRjmVQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=os.amperecomputing.com; dmarc=pass action=none header.from=os.amperecomputing.com; dkim=pass header.d=os.amperecomputing.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=os.amperecomputing.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=Bl7AbniGyQZLNJ7+Q4QC8JWrE1KO2/ydCpx9+Flx7Co=; b=tMlLZG8OFm33cpsiqH+YEmLlNWh/Dl8yM+lSIZUduRgyKjYUTJfDwJmnmYjhsvLTlqHPsTpbCZ0oVHUD0mMhcw6s//8LD3g36/s0n9tAkxGSqPQxKKXRHoZS6hKfoJ85KE6zEuZZdfV+23PGxb2cmEC2uHkh4hEMimJcKPHLNqM= Authentication-Results: acm.org; dkim=none (message not signed) header.d=none;acm.org; dmarc=none action=none header.from=os.amperecomputing.com; Received: from MW2PR0102MB3482.prod.exchangelabs.com (2603:10b6:302:c::32) by MW4PR01MB6338.prod.exchangelabs.com (2603:10b6:303:7b::15) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.3977.30; Tue, 30 Mar 2021 14:10:59 +0000 Received: from MW2PR0102MB3482.prod.exchangelabs.com ([fe80::d840:7aa7:58d4:b503]) by MW2PR0102MB3482.prod.exchangelabs.com ([fe80::d840:7aa7:58d4:b503%5]) with mapi id 15.20.3977.033; Tue, 30 Mar 2021 14:10:59 +0000 From: Quan Nguyen To: Corey Minyard , Rob Herring , Joel Stanley , Andrew Jeffery , Wolfram Sang , Philipp Zabel , openipmi-developer@lists.sourceforge.net, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-aspeed@lists.ozlabs.org, linux-kernel@vger.kernel.org, linux-i2c@vger.kernel.org Cc: openbmc@lists.ozlabs.org, Open Source Submission , Phong Vo , "Thang Q . Nguyen" Subject: [PATCH v2 2/3] drivers: char: ipmi: Add Aspeed SSIF BMC driver Date: Tue, 30 Mar 2021 21:10:28 +0700 Message-Id: <20210330141029.20412-3-quan@os.amperecomputing.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20210330141029.20412-1-quan@os.amperecomputing.com> References: <20210330141029.20412-1-quan@os.amperecomputing.com> X-Originating-IP: [118.69.219.201] X-ClientProxiedBy: HK0PR03CA0120.apcprd03.prod.outlook.com (2603:1096:203:b0::36) To MW2PR0102MB3482.prod.exchangelabs.com (2603:10b6:302:c::32) MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 Received: from hcm-sw-17.amperecomputing.com (118.69.219.201) by HK0PR03CA0120.apcprd03.prod.outlook.com (2603:1096:203:b0::36) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.3977.29 via Frontend Transport; Tue, 30 Mar 2021 14:10:55 +0000 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 44c4c0f9-ef12-4f20-552d-08d8f385a45c X-MS-TrafficTypeDiagnostic: MW4PR01MB6338: X-MS-Exchange-Transport-Forked: True X-Microsoft-Antispam-PRVS: X-MS-Oob-TLC-OOBClassifiers: OLM:3044; X-MS-Exchange-SenderADCheck: 1 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: gSpemlJkYk4VOSTL4nB6teVURY3xRD5fkvmz3oCx5L/5ylI84aSl6nzGEY5go7swV5z18iWF8qCk24xj3YqFLmKMmi3fh210fivPq/XsrdZsNhNJ8d/6HjPpGZXw3iLGY5QB30KySG5POnDaNVH+v5dD1fRo4TFiWxV6qsSGbqNJQjBxPHOQvedWsbZtEbznkNY89WOUY6cryqIuEUs17d+KkGEp0SRch5HF2gwJqj3Kj1A+++f4Tlxb4ES+4J1PJXfQPYGDylFDC2Kt1xPHWzho5222XEU1ZgIYWF4tgH/xgQpaDzYbChs33/QHLxfSBqmkjwSLEYz5RV8EWOwTGWvCKxTLDr/Rf/S0P3Z7ksc9az0rbKMkVQrp36oz8/M8ibZ9n3+fgueg8ww8vK31XqHEJJM+kOEepB7Z2DQ/tJojOU0a7nShNXj9c6N6OcNXrgz+6PjUVtNxJ6Nsfd8cCmMXI8twU3NeLHgBxvJXtRC4OpHovHWzpts3nHMw2pOgSEAVPoBsSBpeW1JqXeeDLN1UC6hOsQHQ39G/C8Svsg/ye/dQuEk4MNbfXrnFV91pHWP+W5Oym9ZLXHEkemfBsZ8WOhNfUpjxeDrufeT392ZoQALgYsaCOuoKlEpVDsAOtZsMG+FbyXv0VCjiwcK125EC31PLbeIdi4HL9PkRW1n3ueV7A9J7Ehu8560Eq7hnwOmadPEZvmn/RRsyhn3oBOoRa/Uy4Z6vjI2rdMUHNGIDjdn3+plFBxfAVeqAvj2/Z81Y1d/xLG1QGIXWuEvGYw== X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:MW2PR0102MB3482.prod.exchangelabs.com; PTR:; CAT:NONE; SFS:(4636009)(366004)(2616005)(5660300002)(2906002)(956004)(186003)(16526019)(6512007)(66556008)(66476007)(6666004)(921005)(107886003)(52116002)(8676002)(7416002)(8936002)(86362001)(38100700001)(66946007)(110136005)(6506007)(83380400001)(498600001)(6486002)(4326008)(1076003)(30864003)(26005)(54906003)(2004002); DIR:OUT; SFP:1102; X-MS-Exchange-AntiSpam-MessageData: =?utf-8?B?NjNRc1AyMXBIby9YNTFNQ3I1NzJWcXp6dXo2NjZmZExqQVFVZG1oOWFVR3Ns?= =?utf-8?B?dkpQWTBhMnc1VVZ0Lzd5OE1pMjYwd3Rmd04zaUF3ZGJOKzQvdElYYWhuL2Vz?= =?utf-8?B?aW1tUHpXYUR5bnowUFFxM1Irc1NldUVISUZaMzRjZnBjTUtvTXZxTlJzd0Vk?= =?utf-8?B?OURGdDhPRjNFY3hlSVRUOHVzZjB1Wkg4bnN0QnFXMFFqV04yOTJqY2FmZHl3?= =?utf-8?B?bVM0R2pUMVlpR0t1b3ZpMlpHOWYwNEpNQUJSRVhYaEIrU1MvcEhVOU5yTWkx?= =?utf-8?B?M0ZHbE9aMjVPYjVpeWsvUEtqT0xTc0JxYk5yRC85dDlWSWprUUFYMDlZKzVR?= =?utf-8?B?Rm1ybG9pY29wbDdxR1dMbzhwREh2ZlJYaXpIblpGdDZ5bU5rQW5NODM3anBZ?= =?utf-8?B?US9TY3A5V2pDMmQvZFlWS20wbTFNTHpPaXNIek9aN3hvdzFkYjRadzJsM0tV?= =?utf-8?B?dmJhODVqekhQTE5pQmhKUVRDU0lDbFlNRzV6UlpoaWw4R0hTUlpoUHd6dGVD?= =?utf-8?B?VFp2R2ZqTmU1Q1VHS3lwMEtYcURMV0wyUWZzUktDbDdoNGZtc1J3UEh5MjY3?= =?utf-8?B?NERGNngrNCtnNU9ybDFSWW9NS0RhcjNUdEtIakpqci9HWUluK0h0VmxZSTdU?= =?utf-8?B?Vnl4MkpkYTR5RzJWR3M2emE1UHUvQkM0NVlEVmM5TmVqcXptOEpkUzBoTElN?= =?utf-8?B?QlFzQU1NbDRoajJYRnl1Y29CcGpnR2pGVS9WeUhtYkdnL3NMUVZMNEYvMGpk?= =?utf-8?B?WVFmVld2Z3BudUl0MkZvdkowSFAySFlhZEM5RVJCYXUwN2hycHlnQnY5RWZi?= =?utf-8?B?WU15WmxGWVh4b05hbmNKK2NGSEZsZmhHZTNoYTBWdU1PRE5Pc2FjcFFiZDJZ?= =?utf-8?B?ZjFFOVo4RFlFMXNvWXVQbGpxMllobHlaTlpORFcxekNUNkhuWWFXaktReFMy?= =?utf-8?B?U255K09pdzVzcjhnODlUZjVqTE9YUmh2bWRNQ0tFRjRIT0xNNm1mTGhuQ1ln?= =?utf-8?B?TFFKNW8ydVdMNE1xWGZ5dnRqN0hHYTZ6dHVEQW5qQWtGSjA3NWtYM1B2ZkZ3?= =?utf-8?B?RWF4ckVSZVVQZnJTd2dSWjhSVXFxbVR1ZkxlbFZLZExsLzhXQmpaT2w2RUVu?= =?utf-8?B?elhoeGNybDRQdmEzM29nNjg0ZWZKbW10NHZFeGtEREFWdVZQalVJR1BvMnRB?= =?utf-8?B?TkhZSDZSZjRBMzkyTlBVelAyVzJlNkRaZUlGNStZaTlGVmNKbG5BOU12Y0Yx?= =?utf-8?B?Z1BTNWxCK2dvV29QUFY0Sk9YeEl0bmgvUlVGWW1wS2RGKzVvMTRFT2hqYUdP?= =?utf-8?B?b2dFS2JaT0ZyS3FGR1dWZU1PRXNjUUY5YzJHZzdMRjBUYVZLWmVSd0U4OU1z?= =?utf-8?B?dXgwU2tZeUR5TkVpNytRejkzdXZxZ0srTnVVUThDcjkvandEaEFaNUJmMmZF?= =?utf-8?B?VFBycVBHblRiVTBkRmdWeExqZ2FQMjBpWndKMkp5OER6ZERlb1BCaDBVcE1z?= =?utf-8?B?QVk0WVBhbGQvamFtRlg0N2pUT2hFNjNqSXhuaUFNajIvYzU4VlFFazY0Qkd0?= =?utf-8?B?a2xoV0ZhejZsbE5xR2NDZHNkdlR2aGVRMWc1Qk45TENpM2lMQkR0dFVHZjhS?= =?utf-8?B?RE1PZkJldWpPWk4ybmxXL1VSM1ZuWkJPSDVUUFpzK3VNWXVtQ2RpVDVscGcw?= =?utf-8?B?eHE5YlFZa3ViM0ZOMUV6NnNJQWpqaWJIcWtORUlud28vUzNsSERRVDFUUFF2?= =?utf-8?Q?uOvWFARjh7aAlW3g1iyHNhEp+K2ttGAJqs5Uy63?= X-OriginatorOrg: os.amperecomputing.com X-MS-Exchange-CrossTenant-Network-Message-Id: 44c4c0f9-ef12-4f20-552d-08d8f385a45c X-MS-Exchange-CrossTenant-AuthSource: MW2PR0102MB3482.prod.exchangelabs.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 30 Mar 2021 14:10:59.1656 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 3bc2b170-fd94-476d-b0ce-4229bdc904a7 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: WUJuAzAV1NTx1k5k1de2OfGuZQdwbYLOL7QU2pZxE1mLb82pQBb6Cuzm503waeM8phJP9kpdo0/7USbWJJ+MsyW2hnuCdGgzu4szQ0lN1fE= X-MS-Exchange-Transport-CrossTenantHeadersStamped: MW4PR01MB6338 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210330_151105_804696_B64824F4 X-CRM114-Status: GOOD ( 23.76 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org VGhlIFNNQnVzIHN5c3RlbSBpbnRlcmZhY2UgKFNTSUYpIElQTUkgQk1DIGRyaXZlciBjYW4gYmUg dXNlZCB0byBwZXJmb3JtCmluLWJhbmQgSVBNSSBjb21tdW5pY2F0aW9uIHdpdGggdGhlaXIgaG9z dCBpbiBtYW5hZ2VtZW50IChCTUMpIHNpZGUuCgpUaGlzIGNvbW1pdHMgYWRkcyBzdXBwb3J0IHNw ZWNpZmljYWxseSBmb3IgQXNwZWVkIEFTVDI1MDAgd2hpY2ggY29tbW9ubHkKdXNlZCBhcyBCb2Fy ZCBNYW5hZ2VtZW50IENvbnRyb2xsZXJzLgoKU2lnbmVkLW9mZi1ieTogUXVhbiBOZ3V5ZW4gPHF1 YW5Ab3MuYW1wZXJlY29tcHV0aW5nLmNvbT4KLS0tCiBkcml2ZXJzL2NoYXIvaXBtaS9LY29uZmln ICAgICAgICAgICB8ICAyMiArCiBkcml2ZXJzL2NoYXIvaXBtaS9NYWtlZmlsZSAgICAgICAgICB8 ICAgMiArCiBkcml2ZXJzL2NoYXIvaXBtaS9zc2lmX2JtYy5jICAgICAgICB8IDY0NSArKysrKysr KysrKysrKysrKysrKysrKysrKysrCiBkcml2ZXJzL2NoYXIvaXBtaS9zc2lmX2JtYy5oICAgICAg ICB8ICA5MiArKysrCiBkcml2ZXJzL2NoYXIvaXBtaS9zc2lmX2JtY19hc3BlZWQuYyB8IDEzMiAr KysrKysKIDUgZmlsZXMgY2hhbmdlZCwgODkzIGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEw MDY0NCBkcml2ZXJzL2NoYXIvaXBtaS9zc2lmX2JtYy5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJp dmVycy9jaGFyL2lwbWkvc3NpZl9ibWMuaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvY2hh ci9pcG1pL3NzaWZfYm1jX2FzcGVlZC5jCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL2lwbWkv S2NvbmZpZyBiL2RyaXZlcnMvY2hhci9pcG1pL0tjb25maWcKaW5kZXggMDc4NDdkOWE0NTlhLi40 NWJlNTcwMjM1NzcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2hhci9pcG1pL0tjb25maWcKKysrIGIv ZHJpdmVycy9jaGFyL2lwbWkvS2NvbmZpZwpAQCAtMTMzLDYgKzEzMywyOCBAQCBjb25maWcgQVNQ RUVEX0JUX0lQTUlfQk1DCiAJICBmb3VuZCBvbiBBc3BlZWQgU09DcyAoQVNUMjQwMCBhbmQgQVNU MjUwMCkuIFRoZSBkcml2ZXIKIAkgIGltcGxlbWVudHMgdGhlIEJNQyBzaWRlIG9mIHRoZSBCVCBp bnRlcmZhY2UuCiAKK2NvbmZpZyBTU0lGX0lQTUlfQk1DCisJdHJpc3RhdGUgIlNTSUYgSVBNSSBC TUMgZHJpdmVyIgorCXNlbGVjdCBJMkMKKwlzZWxlY3QgSTJDX1NMQVZFCisJaGVscAorCSAgVGhp cyBlbmFibGVzIHRoZSBJUE1JIFNNQnVzIHN5c3RlbSBpbnRlcmZhY2UgKFNTSUYpIGF0IHRoZQor CSAgbWFuYWdlbWVudCAoQk1DKSBzaWRlLgorCisJICBUaGUgZHJpdmVyIGltcGxlbWVudHMgdGhl IEJNQyBzaWRlIG9mIHRoZSBTTUJ1cyBzeXN0ZW0KKwkgIGludGVyZmFjZSAoU1NJRikuCisKK2Nv bmZpZyBBU1BFRURfU1NJRl9JUE1JX0JNQworCWRlcGVuZHMgb24gQVJDSF9BU1BFRUQgfHwgQ09N UElMRV9URVNUCisJc2VsZWN0IFNTSUZfSVBNSV9CTUMKKwl0cmlzdGF0ZSAiQXNwZWVkIFNTSUYg SVBNSSBCTUMgZHJpdmVyIgorCWhlbHAKKwkgIFByb3ZpZGVzIGEgZHJpdmVyIGZvciB0aGUgU1NJ RiBJUE1JIGludGVyZmFjZSBmb3VuZCBvbgorCSAgQXNwZWVkIEFTVDI1MDAgU29DLgorCisJICBU aGUgZHJpdmVyIGltcGxlbWVudHMgdGhlIEJNQyBzaWRlIG9mIHRoZSBTTUJ1cyBzeXN0ZW0KKwkg IGludGVyZmFjZSAoU1NJRiksIHNwZWNpZmljIGZvciBBc3BlZWQgQVNUMjUwMCBTb0MuCisKIGNv bmZpZyBJUE1CX0RFVklDRV9JTlRFUkZBQ0UKIAl0cmlzdGF0ZSAnSVBNQiBJbnRlcmZhY2UgaGFu ZGxlcicKIAlkZXBlbmRzIG9uIEkyQwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL2lwbWkvTWFr ZWZpbGUgYi9kcml2ZXJzL2NoYXIvaXBtaS9NYWtlZmlsZQppbmRleCAwODIyYWRjMmVjNDEuLjA1 Yjk5M2Y3MzM1YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL2lwbWkvTWFrZWZpbGUKKysrIGIv ZHJpdmVycy9jaGFyL2lwbWkvTWFrZWZpbGUKQEAgLTI3LDMgKzI3LDUgQEAgb2JqLSQoQ09ORklH X0FTUEVFRF9CVF9JUE1JX0JNQykgKz0gYnQtYm1jLm8KIG9iai0kKENPTkZJR19BU1BFRURfS0NT X0lQTUlfQk1DKSArPSBrY3NfYm1jX2FzcGVlZC5vCiBvYmotJChDT05GSUdfTlBDTTdYWF9LQ1Nf SVBNSV9CTUMpICs9IGtjc19ibWNfbnBjbTd4eC5vCiBvYmotJChDT05GSUdfSVBNQl9ERVZJQ0Vf SU5URVJGQUNFKSArPSBpcG1iX2Rldl9pbnQubworb2JqLSQoQ09ORklHX1NTSUZfSVBNSV9CTUMp ICs9IHNzaWZfYm1jLm8KK29iai0kKENPTkZJR19BU1BFRURfU1NJRl9JUE1JX0JNQykgKz0gc3Np Zl9ibWNfYXNwZWVkLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9pcG1pL3NzaWZfYm1jLmMg Yi9kcml2ZXJzL2NoYXIvaXBtaS9zc2lmX2JtYy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMC4uYWU2ZTg3NTBjNzk1Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9j aGFyL2lwbWkvc3NpZl9ibWMuYwpAQCAtMCwwICsxLDY0NSBAQAorLy8gU1BEWC1MaWNlbnNlLUlk ZW50aWZpZXI6IEdQTC0yLjArCisvKgorICogVGhlIGRyaXZlciBmb3IgQk1DIHNpZGUgb2YgU1NJ RiBpbnRlcmZhY2UKKyAqCisgKiBDb3B5cmlnaHQgKGMpIDIwMjEsIEFtcGVyZSBDb21wdXRpbmcg TExDCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0 cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05V IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mCisgKiB0aGUgTGljZW5zZSwgb3Ig KGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0g aXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1 dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5 IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBP U0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRh aWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbS4gIElmIG5v dCwgc2VlIDxodHRwczovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uCisgKi8KKworI2luY2x1ZGUg PGxpbnV4L2kyYy5oPgorI2luY2x1ZGUgPGxpbnV4L21pc2NkZXZpY2UuaD4KKyNpbmNsdWRlIDxs aW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9vZi5oPgorI2luY2x1ZGUgPGxpbnV4L3Bs YXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3BvbGwuaD4KKyNpbmNsdWRlIDxsaW51 eC9zY2hlZC5oPgorI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+CisjaW5jbHVkZSA8bGludXgvc3Bp bmxvY2suaD4KKworI2luY2x1ZGUgInNzaWZfYm1jLmgiCisKKy8qCisgKiBDYWxsIGluIFdSSVRF IGNvbnRleHQKKyAqLworc3RhdGljIGludCBzZW5kX3NzaWZfYm1jX3Jlc3BvbnNlKHN0cnVjdCBz c2lmX2JtY19jdHggKnNzaWZfYm1jLCBib29sIG5vbl9ibG9ja2luZykKK3sKKwl1bnNpZ25lZCBs b25nIGZsYWdzOworCWludCByZXQ7CisKKwlpZiAoIW5vbl9ibG9ja2luZykgeworcmV0cnk6CisJ CXJldCA9IHdhaXRfZXZlbnRfaW50ZXJydXB0aWJsZShzc2lmX2JtYy0+d2FpdF9xdWV1ZSwKKwkJ CQkJICAgICAgICFzc2lmX2JtYy0+cmVzcG9uc2VfaW5fcHJvZ3Jlc3MpOworCQlpZiAocmV0KQor CQkJcmV0dXJuIHJldDsKKwl9CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmc3NpZl9ibWMtPmxvY2ss IGZsYWdzKTsKKwlpZiAoc3NpZl9ibWMtPnJlc3BvbnNlX2luX3Byb2dyZXNzKSB7CisJCXNwaW5f dW5sb2NrX2lycXJlc3RvcmUoJnNzaWZfYm1jLT5sb2NrLCBmbGFncyk7CisJCWlmIChub25fYmxv Y2tpbmcpCisJCQlyZXR1cm4gLUVBR0FJTjsKKworCQlnb3RvIHJldHJ5OworCX0KKworCS8qCisJ ICogQ2hlY2sgdGhlIHJlc3BvbnNlIGRhdGEgbGVuZ3RoIGZyb20gdXNlcnNwYWNlIHRvIGRldGVy bWluZSB0aGUgdHlwZQorCSAqIG9mIHRoZSByZXNwb25zZSBtZXNzYWdlIHdoZXRoZXIgaXQgaXMg c2luZ2xlLXBhcnQgb3IgbXVsdGktcGFydC4KKwkgKi8KKwlzc2lmX2JtYy0+aXNfc2luZ2xlcGFy dF9yZWFkID0KKwkJKHNzaWZfbXNnX2xlbigmc3NpZl9ibWMtPnJlc3BvbnNlKSA8PSAoTUFYX1BB WUxPQURfUEVSX1RSQU5TQUNUSU9OICsgMSkpID8KKwkJdHJ1ZSA6IGZhbHNlOyAvKiAxOiBieXRl IG9mIGxlbmd0aCAqLworCisJc3NpZl9ibWMtPnJlc3BvbnNlX2luX3Byb2dyZXNzID0gdHJ1ZTsK KwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzc2lmX2JtYy0+bG9jaywgZmxhZ3MpOworCisJcmV0 dXJuIDA7Cit9CisKKy8qCisgKiBDYWxsIGluIFJFQUQgY29udGV4dAorICovCitzdGF0aWMgaW50 IHJlY2VpdmVfc3NpZl9ibWNfcmVxdWVzdChzdHJ1Y3Qgc3NpZl9ibWNfY3R4ICpzc2lmX2JtYywg Ym9vbCBub25fYmxvY2tpbmcpCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlpbnQgcmV0Owor CisJaWYgKCFub25fYmxvY2tpbmcpIHsKK3JldHJ5OgorCQlyZXQgPSB3YWl0X2V2ZW50X2ludGVy cnVwdGlibGUoc3NpZl9ibWMtPndhaXRfcXVldWUsCisJCQkJCSAgICAgICBzc2lmX2JtYy0+cmVx dWVzdF9hdmFpbGFibGUpOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsKKwl9CisKKwlzcGlu X2xvY2tfaXJxc2F2ZSgmc3NpZl9ibWMtPmxvY2ssIGZsYWdzKTsKKwlpZiAoIXNzaWZfYm1jLT5y ZXF1ZXN0X2F2YWlsYWJsZSkgeworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzc2lmX2JtYy0+ bG9jaywgZmxhZ3MpOworCQlpZiAobm9uX2Jsb2NraW5nKQorCQkJcmV0dXJuIC1FQUdBSU47CisJ CWdvdG8gcmV0cnk7CisJfQorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnNzaWZfYm1jLT5sb2Nr LCBmbGFncyk7CisKKwlyZXR1cm4gMDsKK30KKworLyogSGFuZGxlIFNTSUYgbWVzc2FnZSB0aGF0 IHdpbGwgYmUgc2VudCB0byB1c2VyICovCitzdGF0aWMgc3NpemVfdCBzc2lmX2JtY19yZWFkKHN0 cnVjdCBmaWxlICpmaWxlLCBjaGFyIF9fdXNlciAqYnVmLCBzaXplX3QgY291bnQsIGxvZmZfdCAq cHBvcykKK3sKKwlzdHJ1Y3Qgc3NpZl9ibWNfY3R4ICpzc2lmX2JtYyA9IHRvX3NzaWZfYm1jKGZp bGUpOworCXN0cnVjdCBzc2lmX21zZyBtc2c7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlzc2l6 ZV90IHJldDsKKworCW11dGV4X2xvY2soJnNzaWZfYm1jLT5maWxlX211dGV4KTsKKworCXJldCA9 IHJlY2VpdmVfc3NpZl9ibWNfcmVxdWVzdChzc2lmX2JtYywgZmlsZS0+Zl9mbGFncyAmIE9fTk9O QkxPQ0spOworCWlmIChyZXQgPCAwKQorCQlnb3RvIG91dDsKKworCXNwaW5fbG9ja19pcnFzYXZl KCZzc2lmX2JtYy0+bG9jaywgZmxhZ3MpOworCWNvdW50ID0gbWluX3Qoc3NpemVfdCwgY291bnQs IHNzaWZfbXNnX2xlbigmc3NpZl9ibWMtPnJlcXVlc3QpKTsKKwltZW1jcHkoJm1zZywgJnNzaWZf Ym1jLT5yZXF1ZXN0LCBjb3VudCk7CisJc3NpZl9ibWMtPnJlcXVlc3RfYXZhaWxhYmxlID0gZmFs c2U7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmc3NpZl9ibWMtPmxvY2ssIGZsYWdzKTsKKwor CXJldCA9IGNvcHlfdG9fdXNlcihidWYsICZtc2csIGNvdW50KTsKK291dDoKKwltdXRleF91bmxv Y2soJnNzaWZfYm1jLT5maWxlX211dGV4KTsKKworCXJldHVybiAocmV0IDwgMCkgPyByZXQgOiBj b3VudDsKK30KKworLyogSGFuZGxlIFNTSUYgbWVzc2FnZSB0aGF0IGlzIHdyaXR0ZW4gYnkgdXNl ciAqLworc3RhdGljIHNzaXplX3Qgc3NpZl9ibWNfd3JpdGUoc3RydWN0IGZpbGUgKmZpbGUsIGNv bnN0IGNoYXIgX191c2VyICpidWYsIHNpemVfdCBjb3VudCwKKwkJCSAgICAgIGxvZmZfdCAqcHBv cykKK3sKKwlzdHJ1Y3Qgc3NpZl9ibWNfY3R4ICpzc2lmX2JtYyA9IHRvX3NzaWZfYm1jKGZpbGUp OworCXN0cnVjdCBzc2lmX21zZyBtc2c7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlzc2l6ZV90 IHJldDsKKworCWlmIChjb3VudCA+IHNpemVvZihzdHJ1Y3Qgc3NpZl9tc2cpKQorCQlyZXR1cm4g LUVJTlZBTDsKKworCW11dGV4X2xvY2soJnNzaWZfYm1jLT5maWxlX211dGV4KTsKKworCXJldCA9 IGNvcHlfZnJvbV91c2VyKCZtc2csIGJ1ZiwgY291bnQpOworCWlmIChyZXQpCisJCWdvdG8gb3V0 OworCisJc3Bpbl9sb2NrX2lycXNhdmUoJnNzaWZfYm1jLT5sb2NrLCBmbGFncyk7CisJaWYgKGNv dW50ID49IHNzaWZfbXNnX2xlbigmc3NpZl9ibWMtPnJlc3BvbnNlKSkKKwkJbWVtY3B5KCZzc2lm X2JtYy0+cmVzcG9uc2UsICZtc2csIGNvdW50KTsKKwllbHNlCisJCXJldCA9IC1FSU5WQUw7CisJ c3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmc3NpZl9ibWMtPmxvY2ssIGZsYWdzKTsKKworCWlmIChy ZXQpCisJCWdvdG8gb3V0OworCisJcmV0ID0gc2VuZF9zc2lmX2JtY19yZXNwb25zZShzc2lmX2Jt YywgZmlsZS0+Zl9mbGFncyAmIE9fTk9OQkxPQ0spOworCWlmICghcmV0ICYmIHNzaWZfYm1jLT5z ZXRfc3NpZl9ibWNfc3RhdHVzKQorCQlzc2lmX2JtYy0+c2V0X3NzaWZfYm1jX3N0YXR1cyhzc2lm X2JtYywgU1NJRl9CTUNfUkVBRFkpOworb3V0OgorCW11dGV4X3VubG9jaygmc3NpZl9ibWMtPmZp bGVfbXV0ZXgpOworCisJcmV0dXJuIChyZXQgPCAwKSA/IHJldCA6IGNvdW50OworfQorCitzdGF0 aWMgbG9uZyBzc2lmX2JtY19pb2N0bChzdHJ1Y3QgZmlsZSAqZmlsZSwgdW5zaWduZWQgaW50IGNt ZCwgdW5zaWduZWQgbG9uZyBwYXJhbSkKK3sKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHVuc2ln bmVkIGludCBzc2lmX2JtY19wb2xsKHN0cnVjdCBmaWxlICpmaWxlLCBwb2xsX3RhYmxlICp3YWl0 KQoreworCXN0cnVjdCBzc2lmX2JtY19jdHggKnNzaWZfYm1jID0gdG9fc3NpZl9ibWMoZmlsZSk7 CisJdW5zaWduZWQgaW50IG1hc2sgPSAwOworCisJbXV0ZXhfbG9jaygmc3NpZl9ibWMtPmZpbGVf bXV0ZXgpOworCXBvbGxfd2FpdChmaWxlLCAmc3NpZl9ibWMtPndhaXRfcXVldWUsIHdhaXQpOwor CisJLyoKKwkgKiBUaGUgcmVxdWVzdCBtZXNzYWdlIGlzIG5vdyBhdmFpbGFibGUgc28gdXNlcnNw YWNlIGFwcGxpY2F0aW9uIGNhbgorCSAqIGdldCB0aGUgcmVxdWVzdAorCSAqLworCWlmIChzc2lm X2JtYy0+cmVxdWVzdF9hdmFpbGFibGUpCisJCW1hc2sgfD0gUE9MTElOOworCisJbXV0ZXhfdW5s b2NrKCZzc2lmX2JtYy0+ZmlsZV9tdXRleCk7CisJcmV0dXJuIG1hc2s7Cit9CisKKy8qCisgKiBT eXN0ZW0gY2FsbHMgdG8gZGV2aWNlIGludGVyZmFjZSBmb3IgdXNlciBhcHBzCisgKi8KK3N0YXRp YyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIHNzaWZfYm1jX2ZvcHMgPSB7CisJLm93bmVy CQk9IFRISVNfTU9EVUxFLAorCS5yZWFkCQk9IHNzaWZfYm1jX3JlYWQsCisJLndyaXRlCQk9IHNz aWZfYm1jX3dyaXRlLAorCS5wb2xsCQk9IHNzaWZfYm1jX3BvbGwsCisJLnVubG9ja2VkX2lvY3Rs CT0gc3NpZl9ibWNfaW9jdGwsCit9OworCisvKiBDYWxsZWQgd2l0aCBzc2lmX2JtYy0+bG9jayBo ZWxkLiAqLworc3RhdGljIGludCBoYW5kbGVfcmVxdWVzdChzdHJ1Y3Qgc3NpZl9ibWNfY3R4ICpz c2lmX2JtYykKK3sKKwlpZiAoc3NpZl9ibWMtPnNldF9zc2lmX2JtY19zdGF0dXMpCisJCXNzaWZf Ym1jLT5zZXRfc3NpZl9ibWNfc3RhdHVzKHNzaWZfYm1jLCBTU0lGX0JNQ19CVVNZKTsKKworCS8q IFJlcXVlc3QgbWVzc2FnZSBpcyBhdmFpbGFibGUgdG8gcHJvY2VzcyAqLworCXNzaWZfYm1jLT5y ZXF1ZXN0X2F2YWlsYWJsZSA9IHRydWU7CisJLyoKKwkgKiBUaGlzIGlzIHRoZSBuZXcgUkVBRCBy ZXF1ZXN0LgorCSAqIENsZWFyIHRoZSByZXNwb25zZSBidWZmZXIgb2YgdGhlIHByZXZpb3VzIHRy YW5zYWN0aW9uCisJICovCisJbWVtc2V0KCZzc2lmX2JtYy0+cmVzcG9uc2UsIDAsIHNpemVvZihz dHJ1Y3Qgc3NpZl9tc2cpKTsKKwl3YWtlX3VwX2FsbCgmc3NpZl9ibWMtPndhaXRfcXVldWUpOwor CXJldHVybiAwOworfQorCisvKiBDYWxsZWQgd2l0aCBzc2lmX2JtYy0+bG9jayBoZWxkLiAqLwor c3RhdGljIGludCBjb21wbGV0ZV9yZXNwb25zZShzdHJ1Y3Qgc3NpZl9ibWNfY3R4ICpzc2lmX2Jt YykKK3sKKwkvKiBJbnZhbGlkYXRlIHJlc3BvbnNlIGluIGJ1ZmZlciB0byBkZW5vdGUgaXQgaGF2 aW5nIGJlZW4gc2VudC4gKi8KKwlzc2lmX2JtYy0+cmVzcG9uc2UubGVuID0gMDsKKwlzc2lmX2Jt Yy0+cmVzcG9uc2VfaW5fcHJvZ3Jlc3MgPSBmYWxzZTsKKwlzc2lmX2JtYy0+bmJ5dGVzX3Byb2Nl c3NlZCA9IDA7CisJc3NpZl9ibWMtPnJlbWFpbl9sZW4gPSAwOworCW1lbXNldCgmc3NpZl9ibWMt PnJlc3BvbnNlX2J1ZiwgMCwgTUFYX1BBWUxPQURfUEVSX1RSQU5TQUNUSU9OKTsKKwl3YWtlX3Vw X2FsbCgmc3NpZl9ibWMtPndhaXRfcXVldWUpOworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9p ZCBzZXRfbXVsdGlwYXJ0X3Jlc3BvbnNlX2J1ZmZlcihzdHJ1Y3Qgc3NpZl9ibWNfY3R4ICpzc2lm X2JtYywgdTggKnZhbCkKK3sKKwl1OCByZXNwb25zZV9sZW4gPSAwOworCWludCBpZHggPSAwOwor CXU4IGRhdGFfbGVuOworCisJZGF0YV9sZW4gPSBzc2lmX2JtYy0+cmVzcG9uc2UubGVuOworCXN3 aXRjaCAoc3NpZl9ibWMtPnNtYnVzX2NtZCkgeworCWNhc2UgU1NJRl9JUE1JX01VTFRJUEFSVF9S RUFEX1NUQVJUOgorCQkvKgorCQkgKiBSZWFkIFN0YXJ0IGxlbmd0aCBpcyAzMiBieXRlcy4KKwkJ ICogUmVhZCBTdGFydCB0cmFuc2ZlciBmaXJzdCAzMCBieXRlcyBvZiBJUE1JIHJlc3BvbnNlCisJ CSAqIGFuZCAyIHNwZWNpYWwgY29kZSAweDAwLCAweDAxLgorCQkgKi8KKwkJKnZhbCA9IE1BWF9Q QVlMT0FEX1BFUl9UUkFOU0FDVElPTjsKKwkJc3NpZl9ibWMtPnJlbWFpbl9sZW4gPSBkYXRhX2xl biAtIE1BWF9JUE1JX0RBVEFfUEVSX1NUQVJUX1RSQU5TQUNUSU9OOworCQlzc2lmX2JtYy0+Ymxv Y2tfbnVtID0gMDsKKworCQlzc2lmX2JtYy0+cmVzcG9uc2VfYnVmW2lkeCsrXSA9IDB4MDA7IC8q IFN0YXJ0IEZsYWcgKi8KKwkJc3NpZl9ibWMtPnJlc3BvbnNlX2J1ZltpZHgrK10gPSAweDAxOyAv KiBTdGFydCBGbGFnICovCisJCXNzaWZfYm1jLT5yZXNwb25zZV9idWZbaWR4KytdID0gc3NpZl9i bWMtPnJlc3BvbnNlLm5ldGZuX2x1bjsKKwkJc3NpZl9ibWMtPnJlc3BvbnNlX2J1ZltpZHgrK10g PSBzc2lmX2JtYy0+cmVzcG9uc2UuY21kOworCQlzc2lmX2JtYy0+cmVzcG9uc2VfYnVmW2lkeCsr XSA9IHNzaWZfYm1jLT5yZXNwb25zZS5wYXlsb2FkWzBdOworCisJCXJlc3BvbnNlX2xlbiA9IE1B WF9QQVlMT0FEX1BFUl9UUkFOU0FDVElPTiAtIGlkeDsKKworCQltZW1jcHkoJnNzaWZfYm1jLT5y ZXNwb25zZV9idWZbaWR4XSwgJnNzaWZfYm1jLT5yZXNwb25zZS5wYXlsb2FkWzFdLAorCQkgICAg ICAgcmVzcG9uc2VfbGVuKTsKKwkJYnJlYWs7CisKKwljYXNlIFNTSUZfSVBNSV9NVUxUSVBBUlRf UkVBRF9NSURETEU6CisJCS8qCisJCSAqIElQTUkgUkVBRCBNaWRkbGUgb3IgUkVBRCBFbmQgbWVz c2FnZXMgY2FuIGNhcnJ5IHVwIHRvIDMxIGJ5dGVzCisJCSAqIElQTUkgZGF0YSBwbHVzIGJsb2Nr IG51bWJlciBieXRlLgorCQkgKi8KKwkJaWYgKHNzaWZfYm1jLT5yZW1haW5fbGVuIDwgTUFYX0lQ TUlfREFUQV9QRVJfTUlERExFX1RSQU5TQUNUSU9OKSB7CisJCQkvKgorCQkJICogVGhpcyBpcyBS RUFEIEVuZCBtZXNzYWdlCisJCQkgKiAgUmV0dXJuIGxlbmd0aCBpcyB0aGUgcmVtYWluaW5nIHJl c3BvbnNlIGRhdGEgbGVuZ3RoCisJCQkgKiAgcGx1cyBibG9jayBudW1iZXIKKwkJCSAqICBCbG9j ayBudW1iZXIgMHhGRiBpcyB0byBpbmRpY2F0ZSB0aGlzIGlzIGxhc3QgbWVzc2FnZQorCQkJICoK KwkJCSAqIFJldHVybiBsZW5ndGggaXM6IHJlbWFpbiByZXNwb25zZSBwbHVzIGJsb2NrIG51bWJl cgorCQkJICovCisJCQkqdmFsID0gc3NpZl9ibWMtPnJlbWFpbl9sZW4gKyAxOworCQkJc3NpZl9i bWMtPmJsb2NrX251bSA9IDB4RkY7CisJCQlzc2lmX2JtYy0+cmVzcG9uc2VfYnVmW2lkeCsrXSA9 IHNzaWZfYm1jLT5ibG9ja19udW07CisJCQlyZXNwb25zZV9sZW4gPSBzc2lmX2JtYy0+cmVtYWlu X2xlbjsKKwkJfSBlbHNlIHsKKwkJCS8qCisJCQkgKiBUaGlzIGlzIFJFQUQgTWlkZGxlIG1lc3Nh Z2UKKwkJCSAqICBSZXNwb25zZSBsZW5ndGggaXMgdGhlIG1heGltdW0gU01CVVMgdHJhbnNmZXIg bGVuZ3RoCisJCQkgKiAgQmxvY2sgbnVtYmVyIGJ5dGUgaXMgaW5jcmVtZW50ZWQKKwkJCSAqIFJl dHVybiBsZW5ndGggaXMgbWF4aW11bSBTTUJVUyB0cmFuc2ZlciBsZW5ndGgKKwkJCSAqLworCQkJ KnZhbCA9IE1BWF9QQVlMT0FEX1BFUl9UUkFOU0FDVElPTjsKKwkJCXNzaWZfYm1jLT5yZW1haW5f bGVuIC09IE1BWF9JUE1JX0RBVEFfUEVSX01JRERMRV9UUkFOU0FDVElPTjsKKwkJCXJlc3BvbnNl X2xlbiA9IE1BWF9JUE1JX0RBVEFfUEVSX01JRERMRV9UUkFOU0FDVElPTjsKKwkJCXNzaWZfYm1j LT5yZXNwb25zZV9idWZbaWR4KytdID0gc3NpZl9ibWMtPmJsb2NrX251bTsKKwkJCXNzaWZfYm1j LT5ibG9ja19udW0rKzsKKwkJfQorCisJCW1lbWNweSgmc3NpZl9ibWMtPnJlc3BvbnNlX2J1Zltp ZHhdLAorCQkgICAgICAgc3NpZl9ibWMtPnJlc3BvbnNlLnBheWxvYWQgKyAxICsgc3NpZl9ibWMt Pm5ieXRlc19wcm9jZXNzZWQsCisJCSAgICAgICByZXNwb25zZV9sZW4pOworCQlicmVhazsKKwor CWRlZmF1bHQ6CisJCS8qIERvIG5vdCBleHBlY3QgdG8gZ28gdG8gdGhpcyBjYXNlICovCisJCXBy X2VycigiRXJyb3I6IFVuZXhwZWN0ZWQgU01CdXMgY29tbWFuZCByZWNlaXZlZCAweCV4XG4iLCBz c2lmX2JtYy0+c21idXNfY21kKTsKKwkJYnJlYWs7CisJfQorCisJc3NpZl9ibWMtPm5ieXRlc19w cm9jZXNzZWQgKz0gcmVzcG9uc2VfbGVuOworfQorCitzdGF0aWMgdm9pZCBzZXRfc2luZ2xlcGFy dF9yZXNwb25zZV9idWZmZXIoc3RydWN0IHNzaWZfYm1jX2N0eCAqc3NpZl9ibWMsIHU4ICp2YWwp Cit7CisJdTggKmJ1ZiA9ICh1OCAqKSZzc2lmX2JtYy0+cmVzcG9uc2U7CisKKwkvKgorCSAqIERv IG5vdCBleHBlY3QgdGhlIElQTUkgcmVzcG9uc2UgaGFzIGRhdGEgbGVuZ3RoIDAuCisJICogV2l0 aCBzb21lIEkyQyBTTUJ1cyBjb250cm9sbGVycyAoQXNwZWVkIEkyQyksIHJldHVybiAwIGZvcgor CSAqIHRoZSBTTUJ1cyBSZWFkIFJlcXVlc3QgY2FsbGJhY2sgbWlnaHQgY2F1c2UgYmFkIHN0YXRl IGZvcgorCSAqIHRoZSBidXMuIFNvIHJldHVybiAxIGJ5dGUgbGVuZ3RoIHNvIHRoYXQgbWFzdGVy IHdpbGwKKwkgKiByZXNlbmQgdGhlIFJlYWQgUmVxdWVzdCBiZWNhdXNlIHRoZSBsZW5ndGggb2Yg cmVzcG9uc2UgaXMKKwkgKiBsZXNzIHRoYW4gYSBub3JtYWwgSVBNSSByZXNwb25zZS4KKwkgKgor CSAqIE90aGVyd2lzZSwgcmV0dXJuIHRoZSBsZW5ndGggb2YgSVBNSSByZXNwb25zZQorCSAqLwor CSp2YWwgPSAoYnVmW3NzaWZfYm1jLT5tc2dfaWR4XSkgPyBidWZbc3NpZl9ibWMtPm1zZ19pZHhd IDogMHgxOworfQorCisvKiBQcm9jZXNzIHRoZSBJUE1JIHJlc3BvbnNlIHRoYXQgd2lsbCBiZSBy ZWFkIGJ5IG1hc3RlciAqLworc3RhdGljIHZvaWQgaGFuZGxlX3JlYWRfcHJvY2Vzc2VkKHN0cnVj dCBzc2lmX2JtY19jdHggKnNzaWZfYm1jLCB1OCAqdmFsKQoreworCXU4ICpidWY7CisJdTggcGVj X2xlbiwgYWRkciwgbGVuOworCXU4IHBlYyA9IDA7CisKKwlwZWNfbGVuID0gc3NpZl9ibWMtPnBl Y19zdXBwb3J0ID8gMSA6IDA7CisJLyogUEVDIC0gU3RhcnQgUmVhZCBBZGRyZXNzICovCisJYWRk ciA9IEdFVF84QklUX0FERFIoc3NpZl9ibWMtPmNsaWVudC0+YWRkcik7CisJcGVjID0gaTJjX3Nt YnVzX3BlYyhwZWMsICZhZGRyLCAxKTsKKwkvKiBQRUMgLSBTU0lGIENvbW1hbmQgKi8KKwlwZWMg PSBpMmNfc21idXNfcGVjKHBlYywgJnNzaWZfYm1jLT5zbWJ1c19jbWQsIDEpOworCS8qIFBFQyAt IFJlc3RhcnQgV3JpdGUgQWRkcmVzcyAqLworCWFkZHIgPSBhZGRyIHwgMHgwMTsKKwlwZWMgPSBp MmNfc21idXNfcGVjKHBlYywgJmFkZHIsIDEpOworCisJaWYgKHNzaWZfYm1jLT5pc19zaW5nbGVw YXJ0X3JlYWQpIHsKKwkJLyogU2luZ2xlLXBhcnQgUmVhZCBwcm9jZXNzaW5nICovCisJCWJ1ZiA9 ICh1OCAqKSZzc2lmX2JtYy0+cmVzcG9uc2U7CisKKwkJaWYgKHNzaWZfYm1jLT5yZXNwb25zZS5s ZW4gJiYgc3NpZl9ibWMtPm1zZ19pZHggPCBzc2lmX2JtYy0+cmVzcG9uc2UubGVuKSB7CisJCQlz c2lmX2JtYy0+bXNnX2lkeCsrOworCQkJKnZhbCA9IGJ1Zltzc2lmX2JtYy0+bXNnX2lkeF07CisJ CX0gZWxzZSBpZiAoc3NpZl9ibWMtPnJlc3BvbnNlLmxlbiAmJgorCQkJICAgKHNzaWZfYm1jLT5t c2dfaWR4ID09IHNzaWZfYm1jLT5yZXNwb25zZS5sZW4pKSB7CisJCQlzc2lmX2JtYy0+bXNnX2lk eCsrOworCQkJKnZhbCA9IGkyY19zbWJ1c19wZWMocGVjLCBidWYsIHNzaWZfbXNnX2xlbigmc3Np Zl9ibWMtPnJlc3BvbnNlKSk7CisJCX0gZWxzZSB7CisJCQkqdmFsID0gMDsKKwkJfQorCQkvKiBJ bnZhbGlkYXRlIHJlc3BvbnNlIGJ1ZmZlciB0byBkZW5vdGUgaXQgaXMgc2VudCAqLworCQlpZiAo c3NpZl9ibWMtPm1zZ19pZHggKyAxID49IChzc2lmX21zZ19sZW4oJnNzaWZfYm1jLT5yZXNwb25z ZSkgKyBwZWNfbGVuKSkKKwkJCWNvbXBsZXRlX3Jlc3BvbnNlKHNzaWZfYm1jKTsKKwl9IGVsc2Ug eworCQkvKiBNdWx0aS1wYXJ0IFJlYWQgcHJvY2Vzc2luZyAqLworCQlzd2l0Y2ggKHNzaWZfYm1j LT5zbWJ1c19jbWQpIHsKKwkJY2FzZSBTU0lGX0lQTUlfTVVMVElQQVJUX1JFQURfU1RBUlQ6CisJ CWNhc2UgU1NJRl9JUE1JX01VTFRJUEFSVF9SRUFEX01JRERMRToKKwkJCWJ1ZiA9ICh1OCAqKSZz c2lmX2JtYy0+cmVzcG9uc2VfYnVmOworCQkJKnZhbCA9IGJ1Zltzc2lmX2JtYy0+bXNnX2lkeF07 CisJCQlzc2lmX2JtYy0+bXNnX2lkeCsrOworCQkJYnJlYWs7CisJCWRlZmF1bHQ6CisJCQkvKiBE byBub3QgZXhwZWN0IHRvIGdvIHRvIHRoaXMgY2FzZSAqLworCQkJcHJfZXJyKCJFcnJvcjogVW5l eHBlY3RlZCBTTUJ1cyBjb21tYW5kIHJlY2VpdmVkIDB4JXhcbiIsCisJCQkgICAgICAgc3NpZl9i bWMtPnNtYnVzX2NtZCk7CisJCQlicmVhazsKKwkJfQorCQlsZW4gPSAoc3NpZl9ibWMtPmJsb2Nr X251bSA9PSAweEZGKSA/CisJCSAgICAgICBzc2lmX2JtYy0+cmVtYWluX2xlbiArIDEgOiBNQVhf UEFZTE9BRF9QRVJfVFJBTlNBQ1RJT047CisJCWlmIChzc2lmX2JtYy0+bXNnX2lkeCA9PSAobGVu ICsgMSkpIHsKKwkJCXBlYyA9IGkyY19zbWJ1c19wZWMocGVjLCAmbGVuLCAxKTsKKwkJCSp2YWwg PSBpMmNfc21idXNfcGVjKHBlYywgc3NpZl9ibWMtPnJlc3BvbnNlX2J1ZiwgbGVuKTsKKwkJfQor CQkvKiBJbnZhbGlkYXRlIHJlc3BvbnNlIGJ1ZmZlciB0byBkZW5vdGUgbGFzdCByZXNwb25zZSBp cyBzZW50ICovCisJCWlmIChzc2lmX2JtYy0+YmxvY2tfbnVtID09IDB4RkYgJiYKKwkJICAgIHNz aWZfYm1jLT5tc2dfaWR4ID4gKHNzaWZfYm1jLT5yZW1haW5fbGVuICsgcGVjX2xlbikpIHsKKwkJ CWNvbXBsZXRlX3Jlc3BvbnNlKHNzaWZfYm1jKTsKKwkJfQorCX0KK30KKworc3RhdGljIHZvaWQg aGFuZGxlX3dyaXRlX3JlY2VpdmVkKHN0cnVjdCBzc2lmX2JtY19jdHggKnNzaWZfYm1jLCB1OCAq dmFsKQoreworCXU4ICpidWY7CisJdTggc21idXNfY21kOworCisJYnVmID0gKHU4ICopJnNzaWZf Ym1jLT5yZXF1ZXN0OworCWlmIChzc2lmX2JtYy0+bXNnX2lkeCA+PSBzaXplb2Yoc3RydWN0IHNz aWZfbXNnKSkKKwkJcmV0dXJuOworCisJc21idXNfY21kID0gc3NpZl9ibWMtPnNtYnVzX2NtZDsK Kwlzd2l0Y2ggKHNtYnVzX2NtZCkgeworCWNhc2UgU1NJRl9JUE1JX1NJTkdMRVBBUlRfV1JJVEU6 CisJCS8qIFNpbmdsZS1wYXJ0IHdyaXRlICovCisJCWJ1Zltzc2lmX2JtYy0+bXNnX2lkeCAtIDFd ID0gKnZhbDsKKwkJc3NpZl9ibWMtPm1zZ19pZHgrKzsKKworCQlicmVhazsKKwljYXNlIFNTSUZf SVBNSV9NVUxUSVBBUlRfV1JJVEVfU1RBUlQ6CisJCS8qIFJlc2V0IGxlbmd0aCB0byB6ZXJvICov CisJCWlmIChzc2lmX2JtYy0+bXNnX2lkeCA9PSAxKQorCQkJc3NpZl9ibWMtPnJlcXVlc3QubGVu ID0gMDsKKworCQlmYWxsdGhyb3VnaDsKKwljYXNlIFNTSUZfSVBNSV9NVUxUSVBBUlRfV1JJVEVf TUlERExFOgorCWNhc2UgU1NJRl9JUE1JX01VTFRJUEFSVF9XUklURV9FTkQ6CisJCS8qIE11bHRp LXBhcnQgd3JpdGUsIDJuZCBieXRlIHJlY2VpdmVkIGlzIGxlbmd0aCAqLworCQlpZiAoc3NpZl9i bWMtPm1zZ19pZHggPT0gMSkgeworCQkJc3NpZl9ibWMtPnJlcXVlc3QubGVuICs9ICp2YWw7CisJ CQlzc2lmX2JtYy0+cmVjdl9sZW4gPSAqdmFsOworCQl9IGVsc2UgeworCQkJYnVmW3NzaWZfYm1j LT5tc2dfaWR4IC0gMSArCisJCQkgICAgc3NpZl9ibWMtPnJlcXVlc3QubGVuIC0gc3NpZl9ibWMt PnJlY3ZfbGVuXQk9ICp2YWw7CisJCX0KKworCQlzc2lmX2JtYy0+bXNnX2lkeCsrOworCisJCWJy ZWFrOworCWRlZmF1bHQ6CisJCS8qIERvIG5vdCBleHBlY3QgdG8gZ28gdG8gdGhpcyBjYXNlICov CisJCXByX2VycigiRXJyb3I6IFVuZXhwZWN0ZWQgU01CdXMgY29tbWFuZCByZWNlaXZlZCAweCV4 XG4iLCBzc2lmX2JtYy0+c21idXNfY21kKTsKKwkJYnJlYWs7CisJfQorfQorCitzdGF0aWMgYm9v bCB2YWxpZGF0ZV9wZWMoc3RydWN0IHNzaWZfYm1jX2N0eCAqc3NpZl9ibWMpCit7CisJdTggcnBl YyA9IDAsIGNwZWMgPSAwOworCWJvb2wgcmV0ID0gdHJ1ZTsKKwl1OCBhZGRyLCBpbmRleDsKKwl1 OCAqYnVmOworCisJYnVmID0gKHU4ICopJnNzaWZfYm1jLT5yZXF1ZXN0OworCXN3aXRjaCAoc3Np Zl9ibWMtPnNtYnVzX2NtZCkgeworCWNhc2UgU1NJRl9JUE1JX1NJTkdMRVBBUlRfV1JJVEU6CisJ CWlmICgoc3NpZl9ibWMtPm1zZ19pZHggLSAxKSA9PSBzc2lmX21zZ19sZW4oJnNzaWZfYm1jLT5y ZXF1ZXN0KSkgeworCQkJLyogUEVDIGlzIG5vdCBpbmNsdWRlZCAqLworCQkJc3NpZl9ibWMtPnBl Y19zdXBwb3J0ID0gZmFsc2U7CisJCQlyZXR1cm4gdHJ1ZTsKKwkJfQorCisJCWlmICgoc3NpZl9i bWMtPm1zZ19pZHggLSAxKSAhPSAoc3NpZl9tc2dfbGVuKCZzc2lmX2JtYy0+cmVxdWVzdCkgKyAx KSkKKwkJCWdvdG8gZXJyb3I7CisKKwkJLyogUEVDIGlzIGluY2x1ZGVkICovCisJCXNzaWZfYm1j LT5wZWNfc3VwcG9ydCA9IHRydWU7CisJCXJwZWMgPSBidWZbc3NpZl9ibWMtPm1zZ19pZHggLSAy XTsKKwkJYWRkciA9IEdFVF84QklUX0FERFIoc3NpZl9ibWMtPmNsaWVudC0+YWRkcik7CisJCWNw ZWMgPSBpMmNfc21idXNfcGVjKGNwZWMsICZhZGRyLCAxKTsKKwkJY3BlYyA9IGkyY19zbWJ1c19w ZWMoY3BlYywgJnNzaWZfYm1jLT5zbWJ1c19jbWQsIDEpOworCQljcGVjID0gaTJjX3NtYnVzX3Bl YyhjcGVjLCBidWYsIHNzaWZfbXNnX2xlbigmc3NpZl9ibWMtPnJlcXVlc3QpKTsKKwkJaWYgKHJw ZWMgIT0gY3BlYykgeworCQkJcHJfZXJyKCJCYWQgUEVDIDB4JTAyeCB2cy4gMHglMDJ4XG4iLCBy cGVjLCBjcGVjKTsKKwkJCXJldCA9IGZhbHNlOworCQl9CisKKwkJYnJlYWs7CisJY2FzZSBTU0lG X0lQTUlfTVVMVElQQVJUX1dSSVRFX1NUQVJUOgorCWNhc2UgU1NJRl9JUE1JX01VTFRJUEFSVF9X UklURV9NSURETEU6CisJY2FzZSBTU0lGX0lQTUlfTVVMVElQQVJUX1dSSVRFX0VORDoKKwkJaW5k ZXggPSBzc2lmX2JtYy0+cmVxdWVzdC5sZW4gLSBzc2lmX2JtYy0+cmVjdl9sZW47CisJCWlmICgo c3NpZl9ibWMtPm1zZ19pZHggLSAxICsgaW5kZXgpID09IHNzaWZfbXNnX2xlbigmc3NpZl9ibWMt PnJlcXVlc3QpKSB7CisJCQkvKiBQRUMgaXMgbm90IGluY2x1ZGVkICovCisJCQlzc2lmX2JtYy0+ cGVjX3N1cHBvcnQgPSBmYWxzZTsKKwkJCXJldHVybiB0cnVlOworCQl9CisKKwkJaWYgKChzc2lm X2JtYy0+bXNnX2lkeCAtIDEgKyBpbmRleCkgIT0gKHNzaWZfbXNnX2xlbigmc3NpZl9ibWMtPnJl cXVlc3QpICsgMSkpCisJCQlnb3RvIGVycm9yOworCisJCS8qIFBFQyBpcyBpbmNsdWRlZCAqLwor CQlzc2lmX2JtYy0+cGVjX3N1cHBvcnQgPSB0cnVlOworCQlycGVjID0gYnVmW3NzaWZfYm1jLT5t c2dfaWR4IC0gMiArIGluZGV4XTsKKwkJYWRkciA9IEdFVF84QklUX0FERFIoc3NpZl9ibWMtPmNs aWVudC0+YWRkcik7CisJCWNwZWMgPSBpMmNfc21idXNfcGVjKGNwZWMsICZhZGRyLCAxKTsKKwkJ Y3BlYyA9IGkyY19zbWJ1c19wZWMoY3BlYywgJnNzaWZfYm1jLT5zbWJ1c19jbWQsIDEpOworCQlj cGVjID0gaTJjX3NtYnVzX3BlYyhjcGVjLCAmc3NpZl9ibWMtPnJlY3ZfbGVuLCAxKTsKKwkJLyog QXMgU01CdXMgc3BlY2lmaWNhdGlvbiBkb2VzIG5vdCBhbGxvdyB0aGUgbGVuZ3RoCisJCSAqIChi eXRlIGNvdW50KSBpbiB0aGUgV3JpdGUtQmxvY2sgcHJvdG9jb2wgdG8gYmUgemVyby4KKwkJICog VGhlcmVmb3JlLCBpdCBpcyBpbGxlZ2FsIHRvIGhhdmUgdGhlIGxhc3QgTWlkZGxlCisJCSAqIHRy YW5zYWN0aW9uIGluIHRoZSBzZXF1ZW5jZSBjYXJyeSAzMi1ieXRlcyBhbmQgaGF2ZQorCQkgKiBh IGxlbmd0aCBvZiDigJgw4oCZIGluIHRoZSBFbmQgdHJhbnNhY3Rpb24uCisJCSAqIEJ1dCBzb21l IHVzZXJzIG1heSB0cnkgdG8gdXNlIHRoaXMgd2F5IGFuZCB3ZSBzaG91bGQKKwkJICogcHJldmVu dCBzc2lmX2JtYyBkcml2ZXIgYnJva2VuIGluIHRoaXMgY2FzZS4KKwkJICovCisJCWlmIChzc2lm X2JtYy0+cmVjdl9sZW4gIT0gMCkKKwkJCWNwZWMgPSBpMmNfc21idXNfcGVjKGNwZWMsIGJ1ZiAr IDEgKyBpbmRleCwgc3NpZl9ibWMtPnJlY3ZfbGVuKTsKKworCQlpZiAocnBlYyAhPSBjcGVjKSB7 CisJCQlwcl9lcnIoIkJhZCBQRUMgMHglMDJ4IHZzLiAweCUwMnhcbiIsIHJwZWMsIGNwZWMpOwor CQkJcmV0ID0gZmFsc2U7CisJCX0KKworCQlicmVhazsKKwlkZWZhdWx0OgorCQlicmVhazsKKwl9 CisKKwlyZXR1cm4gcmV0OworZXJyb3I6CisJLyogRG8gbm90IGV4cGVjdCB0byBnbyB0byB0aGlz IGNhc2UgKi8KKwlwcl9lcnIoIkVycm9yOiBVbmV4cGVjdGVkIGxlbmd0aCByZWNlaXZlZCAlZFxu Iiwgc3NpZl9tc2dfbGVuKCZzc2lmX2JtYy0+cmVxdWVzdCkpOworCisJcmV0dXJuIGZhbHNlOwor fQorCitzdGF0aWMgdm9pZCBjb21wbGV0ZV93cml0ZV9yZWNlaXZlZChzdHJ1Y3Qgc3NpZl9ibWNf Y3R4ICpzc2lmX2JtYykKK3sKKwl1OCBjbWQgPSBzc2lmX2JtYy0+c21idXNfY21kOworCisJLyog QSBCTUMgdGhhdCByZWNlaXZlcyBhbiBpbnZhbGlkIFBFQyBzaGFsbCBkcm9wIHRoZSBkYXRhIGZv ciB0aGUgd3JpdGUKKwkgKiB0cmFuc2FjdGlvbiBhbmQgYW55IGZ1cnRoZXIgdHJhbnNhY3Rpb25z IChyZWFkIG9yIHdyaXRlKSB1bnRpbAorCSAqIHRoZSBuZXh0IHZhbGlkIHJlYWQgb3Igd3JpdGUg U3RhcnQgdHJhbnNhY3Rpb24gaXMgcmVjZWl2ZWQKKwkgKi8KKwlpZiAoIXZhbGlkYXRlX3BlYyhz c2lmX2JtYykpIHsKKwkJcHJfZXJyKCJSZWNlaXZlZCBpbnZhbGlkIFBFQ1xuIik7CisJCXJldHVy bjsKKwl9CisKKwlpZiAoY21kID09IFNTSUZfSVBNSV9TSU5HTEVQQVJUX1dSSVRFIHx8IGNtZCA9 PSBTU0lGX0lQTUlfTVVMVElQQVJUX1dSSVRFX0VORCkKKwkJaGFuZGxlX3JlcXVlc3Qoc3NpZl9i bWMpOworfQorCisvKgorICogQ2FsbGJhY2sgZnVuY3Rpb24gdG8gaGFuZGxlIEkyQyBzbGF2ZSBl dmVudHMKKyAqLworc3RhdGljIGludCBzc2lmX2JtY19jYihzdHJ1Y3QgaTJjX2NsaWVudCAqY2xp ZW50LCBlbnVtIGkyY19zbGF2ZV9ldmVudCBldmVudCwgdTggKnZhbCkKK3sKKwlzdHJ1Y3Qgc3Np Zl9ibWNfY3R4ICpzc2lmX2JtYyA9IGkyY19nZXRfY2xpZW50ZGF0YShjbGllbnQpOworCisJc3Bp bl9sb2NrKCZzc2lmX2JtYy0+bG9jayk7CisKKwkvKiBJMkMgRXZlbnQgSGFuZGxlcjoKKwkgKiAg IEkyQ19TTEFWRV9SRUFEX1JFUVVFU1RFRAkweDAKKwkgKiAgIEkyQ19TTEFWRV9XUklURV9SRVFV RVNURUQJMHgxCisJICogICBJMkNfU0xBVkVfUkVBRF9QUk9DRVNTRUQJMHgyCisJICogICBJMkNf U0xBVkVfV1JJVEVfUkVDRUlWRUQJMHgzCisJICogICBJMkNfU0xBVkVfU1RPUAkJMHg0CisJICov CisJc3dpdGNoIChldmVudCkgeworCWNhc2UgSTJDX1NMQVZFX1JFQURfUkVRVUVTVEVEOgorCQlz c2lmX2JtYy0+bXNnX2lkeCA9IDA7CisJCWlmIChzc2lmX2JtYy0+aXNfc2luZ2xlcGFydF9yZWFk KQorCQkJc2V0X3NpbmdsZXBhcnRfcmVzcG9uc2VfYnVmZmVyKHNzaWZfYm1jLCB2YWwpOworCQll bHNlCisJCQlzZXRfbXVsdGlwYXJ0X3Jlc3BvbnNlX2J1ZmZlcihzc2lmX2JtYywgdmFsKTsKKwkJ YnJlYWs7CisKKwljYXNlIEkyQ19TTEFWRV9XUklURV9SRVFVRVNURUQ6CisJCXNzaWZfYm1jLT5t c2dfaWR4ID0gMDsKKwkJYnJlYWs7CisKKwljYXNlIEkyQ19TTEFWRV9SRUFEX1BST0NFU1NFRDoK KwkJaGFuZGxlX3JlYWRfcHJvY2Vzc2VkKHNzaWZfYm1jLCB2YWwpOworCQlicmVhazsKKworCWNh c2UgSTJDX1NMQVZFX1dSSVRFX1JFQ0VJVkVEOgorCQkvKgorCQkgKiBGaXJzdCBieXRlIGlzIFNN QlVTIGNvbW1hbmQsIG5vdCBhIHBhcnQgb2YgU1NJRiBtZXNzYWdlLgorCQkgKiBTU0lGIHJlcXVl c3QgYnVmZmVyIHN0YXJ0cyB3aXRoIG1zZ19pZHggMSBmb3IgdGhlIGZpcnN0CisJCSAqICBidWZm ZXIgYnl0ZS4KKwkJICovCisJCWlmIChzc2lmX2JtYy0+bXNnX2lkeCA9PSAwKSB7CisJCQkvKiBT TUJVUyBjb21tYW5kIGNhbiB2YXJ5IChzaW5nbGUgb3IgbXVsdGktcGFydCkgKi8KKwkJCXNzaWZf Ym1jLT5zbWJ1c19jbWQgPSAqdmFsOworCQkJc3NpZl9ibWMtPm1zZ19pZHgrKzsKKwkJfSBlbHNl IHsKKwkJCWhhbmRsZV93cml0ZV9yZWNlaXZlZChzc2lmX2JtYywgdmFsKTsKKwkJfQorCisJCWJy ZWFrOworCisJY2FzZSBJMkNfU0xBVkVfU1RPUDoKKwkJLyoKKwkJICogUEVDIGJ5dGUgaXMgYXBw ZW5kZWQgYXQgdGhlIGVuZCBvZiBlYWNoIHRyYW5zYWN0aW9uLgorCQkgKiBEZXRlY3QgUEVDIGlz IHN1cHBvcnQgb3Igbm90IGFmdGVyIHJlY2VpdmluZyB3cml0ZSByZXF1ZXN0CisJCSAqIGNvbXBs ZXRlbHkuCisJCSAqLworCQlpZiAoc3NpZl9ibWMtPmxhc3RfZXZlbnQgPT0gSTJDX1NMQVZFX1dS SVRFX1JFQ0VJVkVEKQorCQkJY29tcGxldGVfd3JpdGVfcmVjZWl2ZWQoc3NpZl9ibWMpOworCQkv KiBSZXNldCBtZXNzYWdlIGluZGV4ICovCisJCXNzaWZfYm1jLT5tc2dfaWR4ID0gMDsKKwkJYnJl YWs7CisKKwlkZWZhdWx0OgorCQlicmVhazsKKwl9CisJc3NpZl9ibWMtPmxhc3RfZXZlbnQgPSBl dmVudDsKKwlzcGluX3VubG9jaygmc3NpZl9ibWMtPmxvY2spOworCisJcmV0dXJuIDA7Cit9CisK K3N0cnVjdCBzc2lmX2JtY19jdHggKnNzaWZfYm1jX2FsbG9jKHN0cnVjdCBpMmNfY2xpZW50ICpj bGllbnQsIGludCBzaXplb2ZfcHJpdikKK3sKKwlzdHJ1Y3Qgc3NpZl9ibWNfY3R4ICpzc2lmX2Jt YzsKKwlpbnQgcmV0OworCisJc3NpZl9ibWMgPSBkZXZtX2t6YWxsb2MoJmNsaWVudC0+ZGV2LCBz aXplb2YoKnNzaWZfYm1jKSArIHNpemVvZl9wcml2LCBHRlBfS0VSTkVMKTsKKwlpZiAoIXNzaWZf Ym1jKQorCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKKworCXNwaW5fbG9ja19pbml0KCZzc2lm X2JtYy0+bG9jayk7CisKKwlpbml0X3dhaXRxdWV1ZV9oZWFkKCZzc2lmX2JtYy0+d2FpdF9xdWV1 ZSk7CisJc3NpZl9ibWMtPnJlcXVlc3RfYXZhaWxhYmxlID0gZmFsc2U7CisJc3NpZl9ibWMtPnJl c3BvbnNlX2luX3Byb2dyZXNzID0gZmFsc2U7CisKKwltdXRleF9pbml0KCZzc2lmX2JtYy0+Zmls ZV9tdXRleCk7CisKKwkvKiBSZWdpc3RlciBtaXNjIGRldmljZSBpbnRlcmZhY2UgKi8KKwlzc2lm X2JtYy0+bWlzY2Rldi5taW5vciA9IE1JU0NfRFlOQU1JQ19NSU5PUjsKKwlzc2lmX2JtYy0+bWlz Y2Rldi5uYW1lID0gREVWSUNFX05BTUU7CisJc3NpZl9ibWMtPm1pc2NkZXYuZm9wcyA9ICZzc2lm X2JtY19mb3BzOworCXNzaWZfYm1jLT5taXNjZGV2LnBhcmVudCA9ICZjbGllbnQtPmRldjsKKwly ZXQgPSBtaXNjX3JlZ2lzdGVyKCZzc2lmX2JtYy0+bWlzY2Rldik7CisJaWYgKHJldCkKKwkJZ290 byBvdXQ7CisKKwlzc2lmX2JtYy0+Y2xpZW50ID0gY2xpZW50OworCXNzaWZfYm1jLT5jbGllbnQt PmZsYWdzIHw9IEkyQ19DTElFTlRfU0xBVkU7CisKKwkvKiBSZWdpc3RlciBJMkMgc2xhdmUgKi8K KwlpMmNfc2V0X2NsaWVudGRhdGEoY2xpZW50LCBzc2lmX2JtYyk7CisJcmV0ID0gaTJjX3NsYXZl X3JlZ2lzdGVyKGNsaWVudCwgc3NpZl9ibWNfY2IpOworCWlmIChyZXQpIHsKKwkJbWlzY19kZXJl Z2lzdGVyKCZzc2lmX2JtYy0+bWlzY2Rldik7CisJCWdvdG8gb3V0OworCX0KKworCXJldHVybiBz c2lmX2JtYzsKKworb3V0OgorCWRldm1fa2ZyZWUoJmNsaWVudC0+ZGV2LCBzc2lmX2JtYyk7CisJ cmV0dXJuIEVSUl9QVFIocmV0KTsKK30KK0VYUE9SVF9TWU1CT0woc3NpZl9ibWNfYWxsb2MpOwor CitNT0RVTEVfQVVUSE9SKCJDaHVvbmcgVHJhbiA8Y2h1b25nQG9zLmFtcGVyZWNvbXB1dGluZy5j b20+Iik7CitNT0RVTEVfQVVUSE9SKCJRdWFuIE5ndXllbiA8cXVhbkBvcy5hbXBlcmVjb21wdXRp bmcuY29tPiIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJMaW51eCBkZXZpY2UgZHJpdmVyIG9mIHRo ZSBCTUMgSVBNSSBTU0lGIGludGVyZmFjZS4iKTsKK01PRFVMRV9MSUNFTlNFKCJHUEwgdjIiKTsK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9pcG1pL3NzaWZfYm1jLmggYi9kcml2ZXJzL2NoYXIv aXBtaS9zc2lmX2JtYy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4u YTJlZTA5MDU3MmRiCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9jaGFyL2lwbWkvc3NpZl9i bWMuaApAQCAtMCwwICsxLDkyIEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIu MCsgKi8KKy8qCisgKiBUaGUgZHJpdmVyIGZvciBCTUMgc2lkZSBvZiBTU0lGIGludGVyZmFjZQor ICoKKyAqIENvcHlyaWdodCAoYykgMjAyMSwgQW1wZXJlIENvbXB1dGluZyBMTEMKKyAqCisgKiBU aGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5k L29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJs aWMgTGljZW5zZSBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b247IGVpdGhlciB2ZXJzaW9uIDIgb2YKKyAqIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRp b24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRl ZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5Z IFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNI QU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUK KyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICog WW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGlj IExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBzZWUgPGh0dHBz Oi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi4KKyAqLworI2lmbmRlZiBfX1NTSUZfQk1DX0hfXwor I2RlZmluZSBfX1NTSUZfQk1DX0hfXworCisjZGVmaW5lIERFVklDRV9OQU1FCQkJCSJpcG1pLXNz aWYtaG9zdCIKKworI2RlZmluZSBHRVRfOEJJVF9BRERSKGFkZHJfN2JpdCkJCSgoKGFkZHJfN2Jp dCkgPDwgMSkgJiAweGZmKQorCisjZGVmaW5lIE1TR19QQVlMT0FEX0xFTl9NQVgJCQkyNTIKKwor LyogQSBzdGFuZGFyZCBTTUJ1cyBUcmFuc2FjdGlvbiBpcyBsaW1pdGVkIHRvIDMyIGRhdGEgYnl0 ZXMgKi8KKyNkZWZpbmUgTUFYX1BBWUxPQURfUEVSX1RSQU5TQUNUSU9OCQkzMgorCisjZGVmaW5l IE1BWF9JUE1JX0RBVEFfUEVSX1NUQVJUX1RSQU5TQUNUSU9OCTMwCisjZGVmaW5lIE1BWF9JUE1J X0RBVEFfUEVSX01JRERMRV9UUkFOU0FDVElPTgkzMQorCisjZGVmaW5lIFNTSUZfSVBNSV9TSU5H TEVQQVJUX1dSSVRFCQkweDIKKyNkZWZpbmUgU1NJRl9JUE1JX1NJTkdMRVBBUlRfUkVBRAkJMHgz CisjZGVmaW5lIFNTSUZfSVBNSV9NVUxUSVBBUlRfV1JJVEVfU1RBUlQJCTB4NgorI2RlZmluZSBT U0lGX0lQTUlfTVVMVElQQVJUX1dSSVRFX01JRERMRQkweDcKKyNkZWZpbmUgU1NJRl9JUE1JX01V TFRJUEFSVF9XUklURV9FTkQJCTB4OAorI2RlZmluZSBTU0lGX0lQTUlfTVVMVElQQVJUX1JFQURf U1RBUlQJCTB4MworI2RlZmluZSBTU0lGX0lQTUlfTVVMVElQQVJUX1JFQURfTUlERExFCQkweDkK Kworc3RydWN0IHNzaWZfbXNnIHsKKwl1OCBsZW47CisJdTggbmV0Zm5fbHVuOworCXU4IGNtZDsK Kwl1OCBwYXlsb2FkW01TR19QQVlMT0FEX0xFTl9NQVhdOworfSBfX3BhY2tlZDsKKworc3RhdGlj IGlubGluZSB1MzIgc3NpZl9tc2dfbGVuKHN0cnVjdCBzc2lmX21zZyAqc3NpZl9tc2cpCit7CisJ cmV0dXJuIHNzaWZfbXNnLT5sZW4gKyAxOworfQorCisjZGVmaW5lIFNTSUZfQk1DX0JVU1kgICAw eDAxCisjZGVmaW5lIFNTSUZfQk1DX1JFQURZICAweDAyCisKK3N0cnVjdCBzc2lmX2JtY19jdHgg eworCXN0cnVjdCBpMmNfY2xpZW50CSpjbGllbnQ7CisJc3RydWN0IG1pc2NkZXZpY2UJbWlzY2Rl djsKKwl1OAkJCXNtYnVzX2NtZDsKKwlzdHJ1Y3Qgc3NpZl9tc2cJCXJlcXVlc3Q7CisJYm9vbAkJ CXJlcXVlc3RfYXZhaWxhYmxlOworCXN0cnVjdCBzc2lmX21zZwkJcmVzcG9uc2U7CisJYm9vbAkJ CXJlc3BvbnNlX2luX3Byb2dyZXNzOworCS8qIFJlc3BvbnNlIGJ1ZmZlciBmb3IgTXVsdGktcGFy dCBSZWFkIFRyYW5zYWN0aW9uICovCisJdTgJCQlyZXNwb25zZV9idWZbTUFYX1BBWUxPQURfUEVS X1RSQU5TQUNUSU9OXTsKKwkvKiBGbGFnIHRvIGlkZW50aWZ5IGEgTXVsdGktcGFydCBSZWFkIFRy YW5zYWN0aW9uICovCisJYm9vbAkJCWlzX3NpbmdsZXBhcnRfcmVhZDsKKwl1OAkJCW5ieXRlc19w cm9jZXNzZWQ7CisJdTgJCQlyZW1haW5fbGVuOworCXU4CQkJcmVjdl9sZW47CisJLyogQmxvY2sg TnVtYmVyIG9mIGEgTXVsdGktcGFydCBSZWFkIFRyYW5zYWN0aW9uICovCisJdTgJCQlibG9ja19u dW07CisJc2l6ZV90CQkJbXNnX2lkeDsKKwllbnVtIGkyY19zbGF2ZV9ldmVudAlsYXN0X2V2ZW50 OworCWJvb2wJCQlwZWNfc3VwcG9ydDsKKwlzcGlubG9ja190CQlsb2NrOworCXdhaXRfcXVldWVf aGVhZF90CXdhaXRfcXVldWU7CisJc3RydWN0IG11dGV4CQlmaWxlX211dGV4OworCXZvaWQgKCpz ZXRfc3NpZl9ibWNfc3RhdHVzKShzdHJ1Y3Qgc3NpZl9ibWNfY3R4ICpzc2lmX2JtYywgdW5zaWdu ZWQgaW50IGZsYWdzKTsKKwl2b2lkCQkJKnByaXY7Cit9OworCitzdGF0aWMgaW5saW5lIHN0cnVj dCBzc2lmX2JtY19jdHggKnRvX3NzaWZfYm1jKHN0cnVjdCBmaWxlICpmaWxlKQoreworCXJldHVy biBjb250YWluZXJfb2YoZmlsZS0+cHJpdmF0ZV9kYXRhLCBzdHJ1Y3Qgc3NpZl9ibWNfY3R4LCBt aXNjZGV2KTsKK30KKworc3RydWN0IHNzaWZfYm1jX2N0eCAqc3NpZl9ibWNfYWxsb2Moc3RydWN0 IGkyY19jbGllbnQgKmNsaWVudCwgaW50IHNpemVvZl9wcml2KTsKKworI2VuZGlmIC8qIF9fU1NJ Rl9CTUNfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvaXBtaS9zc2lmX2JtY19hc3Bl ZWQuYyBiL2RyaXZlcnMvY2hhci9pcG1pL3NzaWZfYm1jX2FzcGVlZC5jCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uYTU2M2ZjZmY1YWNjCi0tLSAvZGV2L251bGwKKysr IGIvZHJpdmVycy9jaGFyL2lwbWkvc3NpZl9ibWNfYXNwZWVkLmMKQEAgLTAsMCArMSwxMzIgQEAK Ky8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wKworLyoKKyAqIFRoZSBkcml2ZXIg Zm9yIEJNQyBzaWRlIG9mIEFzcGVlZCBTU0lGIGludGVyZmFjZQorICoKKyAqIENvcHlyaWdodCAo YykgMjAyMSwgQW1wZXJlIENvbXB1dGluZyBMTEMKKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJl ZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQg dW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcworICog cHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9u IDIgb2YKKyAqIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJz aW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0 IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0 IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJl Y2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25n IHdpdGggdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBzZWUgPGh0dHBzOi8vd3d3LmdudS5vcmcvbGlj ZW5zZXMvPi4KKyAqLworCisjaW5jbHVkZSA8bGludXgvaTJjLmg+CisjaW5jbHVkZSA8bGludXgv bWlzY2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4 L3BvbGwuaD4KKyNpbmNsdWRlIDxsaW51eC9pb3BvbGwuaD4KKworI2luY2x1ZGUgInNzaWZfYm1j LmgiCisKK3N0cnVjdCBhc3BlZWRfaTJjX2J1cyB7CisJc3RydWN0IGkyY19hZGFwdGVyICAgICAg ICAgICAgICBhZGFwOworCXN0cnVjdCBkZXZpY2UgICAgICAgICAgICAgICAgICAgKmRldjsKKwl2 b2lkIF9faW9tZW0gICAgICAgICAgICAgICAgICAgICpiYXNlOworCXN0cnVjdCByZXNldF9jb250 cm9sICAgICAgICAgICAgKnJzdDsKKwkvKiBTeW5jaHJvbml6ZXMgSS9PIG1lbSBhY2Nlc3MgdG8g YmFzZS4gKi8KKwlzcGlubG9ja190ICAgICAgICAgICAgICAgICAgICAgIGxvY2s7Cit9OworCisj ZGVmaW5lIEFTUEVFRF9JMkNfSU5UUl9DVFJMX1JFRwkweDBjCisjZGVmaW5lIEFTUEVFRF9JMkNE X0lOVFJfU0xBVkVfTUFUQ0gJQklUKDcpCisjZGVmaW5lIEFTUEVFRF9JMkNEX0lOVFJfUlhfRE9O RQlCSVQoMikKK3N0YXRpYyB2b2lkIGFzcGVlZF9pMmNfZW5hYmxlX2ludGVycnVwdChzdHJ1Y3Qg YXNwZWVkX2kyY19idXMgKmJ1cywgdW5zaWduZWQgbG9uZyBtYXNrKQoreworCXVuc2lnbmVkIGxv bmcgY3VycmVudF9tYXNrOworCisJY3VycmVudF9tYXNrID0gcmVhZGwoYnVzLT5iYXNlICsgQVNQ RUVEX0kyQ19JTlRSX0NUUkxfUkVHKTsKKwl3cml0ZWwoY3VycmVudF9tYXNrIHwgbWFzaywgYnVz LT5iYXNlICsgQVNQRUVEX0kyQ19JTlRSX0NUUkxfUkVHKTsKK30KKworc3RhdGljIHZvaWQgYXNw ZWVkX2kyY19kaXNhYmxlX2ludGVycnVwdChzdHJ1Y3QgYXNwZWVkX2kyY19idXMgKmJ1cywgdW5z aWduZWQgbG9uZyBtYXNrKQoreworCXVuc2lnbmVkIGxvbmcgY3VycmVudF9tYXNrOworCisJY3Vy cmVudF9tYXNrID0gcmVhZGwoYnVzLT5iYXNlICsgQVNQRUVEX0kyQ19JTlRSX0NUUkxfUkVHKTsK Kwl3cml0ZWwoY3VycmVudF9tYXNrICYgfm1hc2ssIGJ1cy0+YmFzZSArIEFTUEVFRF9JMkNfSU5U Ul9DVFJMX1JFRyk7Cit9CisKK3N0YXRpYyB2b2lkIGFzcGVlZF9zZXRfc3NpZl9ibWNfc3RhdHVz KHN0cnVjdCBzc2lmX2JtY19jdHggKnNzaWZfYm1jLCB1bnNpZ25lZCBpbnQgc3RhdHVzKQorewor CXN0cnVjdCBhc3BlZWRfaTJjX2J1cyAqYnVzOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwli dXMgPSAoc3RydWN0IGFzcGVlZF9pMmNfYnVzICopc3NpZl9ibWMtPnByaXY7CisJaWYgKCFidXMp CisJCXJldHVybjsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZidXMtPmxvY2ssIGZsYWdzKTsKKwor CWlmIChzdGF0dXMgJiBTU0lGX0JNQ19CVVNZKSB7CisJCS8qIElnbm9yZSBSWF9ET05FIGFuZCBT TEFWRV9NQVRDSCB3aGVuIHNsYXZlIGJ1c3kgcHJvY2Vzc2luZyAqLworCQlhc3BlZWRfaTJjX2Rp c2FibGVfaW50ZXJydXB0KGJ1cywgQVNQRUVEX0kyQ0RfSU5UUl9SWF9ET05FKTsKKwkJYXNwZWVk X2kyY19kaXNhYmxlX2ludGVycnVwdChidXMsIEFTUEVFRF9JMkNEX0lOVFJfU0xBVkVfTUFUQ0gp OworCX0gZWxzZSBpZiAoc3RhdHVzICYgU1NJRl9CTUNfUkVBRFkpIHsKKwkJLyogRW5hYmxlIFJY X0RPTkUgYW5kIFNMQVZFX01BVENIIHdoZW4gc2xhdmUgcmVhZHkgKi8KKwkJYXNwZWVkX2kyY19l bmFibGVfaW50ZXJydXB0KGJ1cywgQVNQRUVEX0kyQ0RfSU5UUl9SWF9ET05FKTsKKwkJYXNwZWVk X2kyY19lbmFibGVfaW50ZXJydXB0KGJ1cywgQVNQRUVEX0kyQ0RfSU5UUl9TTEFWRV9NQVRDSCk7 CisJfQorCisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYnVzLT5sb2NrLCBmbGFncyk7Cit9CisK K3N0YXRpYyBpbnQgc3NpZl9ibWNfcHJvYmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwgY29u c3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgKmlkKQoreworCXN0cnVjdCBzc2lmX2JtY19jdHggKnNz aWZfYm1jOworCisJc3NpZl9ibWMgPSBzc2lmX2JtY19hbGxvYyhjbGllbnQsIHNpemVvZihzdHJ1 Y3QgYXNwZWVkX2kyY19idXMpKTsKKwlpZiAoSVNfRVJSKHNzaWZfYm1jKSkKKwkJcmV0dXJuIFBU Ul9FUlIoc3NpZl9ibWMpOworCisJc3NpZl9ibWMtPnByaXYgPSBpMmNfZ2V0X2FkYXBkYXRhKGNs aWVudC0+YWRhcHRlcik7CisJc3NpZl9ibWMtPnNldF9zc2lmX2JtY19zdGF0dXMgPSBhc3BlZWRf c2V0X3NzaWZfYm1jX3N0YXR1czsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHNzaWZf Ym1jX3JlbW92ZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50KQoreworCXN0cnVjdCBzc2lmX2Jt Y19jdHggKnNzaWZfYm1jID0gaTJjX2dldF9jbGllbnRkYXRhKGNsaWVudCk7CisKKwlpMmNfc2xh dmVfdW5yZWdpc3RlcihjbGllbnQpOworCW1pc2NfZGVyZWdpc3Rlcigmc3NpZl9ibWMtPm1pc2Nk ZXYpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lk IHNzaWZfYm1jX21hdGNoW10gPSB7CisJeyAuY29tcGF0aWJsZSA9ICJhc3BlZWQsYXN0MjUwMC1z c2lmLWJtYyIgfSwKKwl7IH0sCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGkyY19kZXZpY2Vf aWQgc3NpZl9ibWNfaWRbXSA9IHsKKwl7IERFVklDRV9OQU1FLCAwIH0sCisJeyB9LAorfTsKKwor TU9EVUxFX0RFVklDRV9UQUJMRShpMmMsIHNzaWZfYm1jX2lkKTsKKworc3RhdGljIHN0cnVjdCBp MmNfZHJpdmVyIHNzaWZfYm1jX2RyaXZlciA9IHsKKwkuZHJpdmVyCQk9IHsKKwkJLm5hbWUJCT0g REVWSUNFX05BTUUsCisJCS5vZl9tYXRjaF90YWJsZSA9IHNzaWZfYm1jX21hdGNoLAorCX0sCisJ LnByb2JlCQk9IHNzaWZfYm1jX3Byb2JlLAorCS5yZW1vdmUJCT0gc3NpZl9ibWNfcmVtb3ZlLAor CS5pZF90YWJsZQk9IHNzaWZfYm1jX2lkLAorfTsKKworbW9kdWxlX2kyY19kcml2ZXIoc3NpZl9i bWNfZHJpdmVyKTsKKworTU9EVUxFX0FVVEhPUigiQ2h1b25nIFRyYW4gPGNodW9uZ0Bvcy5hbXBl cmVjb21wdXRpbmcuY29tPiIpOworTU9EVUxFX0FVVEhPUigiUXVhbiBOZ3V5ZW4gPHF1YW5Ab3Mu YW1wZXJlY29tcHV0aW5nLmNvbT4iKTsKK01PRFVMRV9ERVNDUklQVElPTigiTGludXggZGV2aWNl IGRyaXZlciBvZiBBc3BlZWQgQk1DIElQTUkgU1NJRiBpbnRlcmZhY2UuIik7CitNT0RVTEVfTElD RU5TRSgiR1BMIHYyIik7Ci0tIAoyLjI4LjAKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1h cm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcv bWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==