From patchwork Tue Oct 10 12:23:19 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Konstantin Aladyshev X-Patchwork-Id: 1845869 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20230601 header.b=BFnBHGk9; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=lists.ozlabs.org (client-ip=2404:9400:2:0:216:3eff:fee1:b9f1; helo=lists.ozlabs.org; envelope-from=linux-aspeed-bounces+incoming=patchwork.ozlabs.org@lists.ozlabs.org; receiver=patchwork.ozlabs.org) Received: from lists.ozlabs.org (lists.ozlabs.org [IPv6:2404:9400:2:0:216:3eff:fee1:b9f1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (secp384r1)) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4S4ZpQ201bz1ypX for ; Tue, 10 Oct 2023 23:24:30 +1100 (AEDT) Authentication-Results: lists.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20230601 header.b=BFnBHGk9; dkim-atps=neutral Received: from boromir.ozlabs.org (localhost [IPv6:::1]) by lists.ozlabs.org (Postfix) with ESMTP id 4S4ZpQ0tzFz3vYm for ; Tue, 10 Oct 2023 23:24:30 +1100 (AEDT) X-Original-To: linux-aspeed@lists.ozlabs.org Delivered-To: linux-aspeed@lists.ozlabs.org Authentication-Results: lists.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20230601 header.b=BFnBHGk9; dkim-atps=neutral Authentication-Results: lists.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gmail.com (client-ip=2a00:1450:4864:20::229; helo=mail-lj1-x229.google.com; envelope-from=aladyshev22@gmail.com; receiver=lists.ozlabs.org) Received: from mail-lj1-x229.google.com (mail-lj1-x229.google.com [IPv6:2a00:1450:4864:20::229]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by lists.ozlabs.org (Postfix) with ESMTPS id 4S4ZnH61T4z3bZr; Tue, 10 Oct 2023 23:23:31 +1100 (AEDT) Received: by mail-lj1-x229.google.com with SMTP id 38308e7fff4ca-2bfed7c4e6dso63796891fa.1; Tue, 10 Oct 2023 05:23:31 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1696940608; x=1697545408; darn=lists.ozlabs.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=YUX/UAbHIqbeqOjhPaMPY2ZesCBPS6XxII45ueUUUxU=; b=BFnBHGk9S6HpbS9sD2CZsvi6m9qyChcmt0Kcnm6sIPKuGEeDup+28SIRCwRV2maT2h 3p8dJx2j74Eh7w1E164WJTPJAbNJNveM69CxhKWnMvyiyD3Oue5o8imEKW4NMxVjSOc9 OSXqJQYDKcPFmavp5wsU9qXVnXiGP0H5Xi8QeoIf739QYNLAfE+7eWye5qVc1dEbqopt Bp33YZJGgRsXshDpgXCGRhYkDezlszjTCr0Zzp1w9QVjCOOM7VphGJN74fTalw9S0kLR g9Bi6NGI6PSBvFn4ahCz4e3R2Jn+hAtwRFNEDROo3nTbc/thG03+kqT51npsw8kccgTk j+ag== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1696940608; x=1697545408; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=YUX/UAbHIqbeqOjhPaMPY2ZesCBPS6XxII45ueUUUxU=; b=N4V0z8JZm7feaMjXBUowNF6KTfxDNsSStpDdpyGSkTIBIWvpD+GWc+53t8c3sv5FEc bl7xq4HvpS8mX+scmRVY4WG4kWtbEfrHwMEtHN6frR7+FoYJJbLwWLrE1Mv/o30MRXJz g1fTFUCUak3Yef2MaEq/xH4i3V1iLefzQyJ2+x5/Ac5AXEFgpVpaXq/u1yTu1jmGADX8 bilwiGv/y0ICMLGCXxPac7j9xJMMC7g3M7xQAQBgsHxJgL72wF9MMmhKaSLi6cFsCYX5 vo4wf33QPBpOypO0gtvfeDLR1UsxG1KICYPE9TV/1iX95T/G4fM4RUXc5vr7LQg10h72 lGBQ== X-Gm-Message-State: AOJu0YxvX2BbbPvBPfOHiJy4DzIkS3Ab0yovZ0vljW88Omfo8QJGUN2Y +oEvY9Rejuq0W6okJCfDH0g= X-Google-Smtp-Source: AGHT+IF7glpbN6KRt0jokK8LtPnQbJM71FgXY7LuwB8vQJxVxZY747eKG1EeB3p5SSxJTCZ9iuU/GQ== X-Received: by 2002:a2e:994e:0:b0:2bc:c38a:bd7c with SMTP id r14-20020a2e994e000000b002bcc38abd7cmr16309656ljj.33.1696940607548; Tue, 10 Oct 2023 05:23:27 -0700 (PDT) Received: from PC10319.67 ([82.97.198.254]) by smtp.googlemail.com with ESMTPSA id g9-20020a2e9cc9000000b002b9e346a152sm2425638ljj.96.2023.10.10.05.23.26 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 10 Oct 2023 05:23:27 -0700 (PDT) From: Konstantin Aladyshev To: Subject: [PATCH v5 1/3] ipmi: Move KCS headers to common include folder Date: Tue, 10 Oct 2023 15:23:19 +0300 Message-Id: <20231010122321.823-2-aladyshev22@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20231010122321.823-1-aladyshev22@gmail.com> References: <20231010122321.823-1-aladyshev22@gmail.com> MIME-Version: 1.0 X-BeenThere: linux-aspeed@lists.ozlabs.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Linux ASPEED SoC development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: tmaimon77@gmail.com, linux-aspeed@lists.ozlabs.org, tali.perry1@gmail.com, edumazet@google.com, jk@codeconstruct.com.au, matt@codeconstruct.com.au, openbmc@lists.ozlabs.org, yuenn@google.com, kuba@kernel.org, pabeni@redhat.com, minyard@acm.org, aladyshev22@gmail.com, openipmi-developer@lists.sourceforge.net, linux-arm-kernel@lists.infradead.org, venture@google.com, linux-kernel@vger.kernel.org, avifishman70@gmail.com, netdev@vger.kernel.org, davem@davemloft.net Errors-To: linux-aspeed-bounces+incoming=patchwork.ozlabs.org@lists.ozlabs.org Sender: "Linux-aspeed" The current KCS header files can be utilized by both IPMI drivers (drivers/char/ipmi) and MCTP driver (drivers/net/mctp). To be able to use them in both cases move the headers to 'include/linux' folder. Signed-off-by: Konstantin Aladyshev --- drivers/char/ipmi/kcs_bmc.c | 8 +++----- drivers/char/ipmi/kcs_bmc_aspeed.c | 3 +-- drivers/char/ipmi/kcs_bmc_cdev_ipmi.c | 2 +- drivers/char/ipmi/kcs_bmc_npcm7xx.c | 2 +- drivers/char/ipmi/kcs_bmc_serio.c | 2 +- {drivers/char/ipmi => include/linux}/kcs_bmc.h | 0 {drivers/char/ipmi => include/linux}/kcs_bmc_client.h | 3 +-- {drivers/char/ipmi => include/linux}/kcs_bmc_device.h | 3 +-- 8 files changed, 9 insertions(+), 14 deletions(-) rename {drivers/char/ipmi => include/linux}/kcs_bmc.h (100%) rename {drivers/char/ipmi => include/linux}/kcs_bmc_client.h (97%) rename {drivers/char/ipmi => include/linux}/kcs_bmc_device.h (96%) diff --git a/drivers/char/ipmi/kcs_bmc.c b/drivers/char/ipmi/kcs_bmc.c index 8b1161d5194a..d29a8505d6ed 100644 --- a/drivers/char/ipmi/kcs_bmc.c +++ b/drivers/char/ipmi/kcs_bmc.c @@ -5,15 +5,13 @@ */ #include +#include +#include +#include #include #include #include -#include "kcs_bmc.h" - -/* Implement both the device and client interfaces here */ -#include "kcs_bmc_device.h" -#include "kcs_bmc_client.h" /* Record registered devices and drivers */ static DEFINE_MUTEX(kcs_bmc_lock); diff --git a/drivers/char/ipmi/kcs_bmc_aspeed.c b/drivers/char/ipmi/kcs_bmc_aspeed.c index 72640da55380..3dc0dfb448f5 100644 --- a/drivers/char/ipmi/kcs_bmc_aspeed.c +++ b/drivers/char/ipmi/kcs_bmc_aspeed.c @@ -10,6 +10,7 @@ #include #include #include +#include #include #include #include @@ -21,8 +22,6 @@ #include #include -#include "kcs_bmc_device.h" - #define DEVICE_NAME "ast-kcs-bmc" diff --git a/drivers/char/ipmi/kcs_bmc_cdev_ipmi.c b/drivers/char/ipmi/kcs_bmc_cdev_ipmi.c index cf670e891966..bf1001130a6c 100644 --- a/drivers/char/ipmi/kcs_bmc_cdev_ipmi.c +++ b/drivers/char/ipmi/kcs_bmc_cdev_ipmi.c @@ -8,6 +8,7 @@ #include #include #include +#include #include #include #include @@ -17,7 +18,6 @@ #include #include -#include "kcs_bmc_client.h" /* Different phases of the KCS BMC module. * KCS_PHASE_IDLE: diff --git a/drivers/char/ipmi/kcs_bmc_npcm7xx.c b/drivers/char/ipmi/kcs_bmc_npcm7xx.c index 7961fec56476..160553248a93 100644 --- a/drivers/char/ipmi/kcs_bmc_npcm7xx.c +++ b/drivers/char/ipmi/kcs_bmc_npcm7xx.c @@ -10,6 +10,7 @@ #include #include #include +#include #include #include #include @@ -17,7 +18,6 @@ #include #include -#include "kcs_bmc_device.h" #define DEVICE_NAME "npcm-kcs-bmc" #define KCS_CHANNEL_MAX 3 diff --git a/drivers/char/ipmi/kcs_bmc_serio.c b/drivers/char/ipmi/kcs_bmc_serio.c index 1793358be782..24df7144a189 100644 --- a/drivers/char/ipmi/kcs_bmc_serio.c +++ b/drivers/char/ipmi/kcs_bmc_serio.c @@ -5,12 +5,12 @@ #include #include #include +#include #include #include #include #include -#include "kcs_bmc_client.h" struct kcs_bmc_serio { struct list_head entry; diff --git a/drivers/char/ipmi/kcs_bmc.h b/include/linux/kcs_bmc.h similarity index 100% rename from drivers/char/ipmi/kcs_bmc.h rename to include/linux/kcs_bmc.h diff --git a/drivers/char/ipmi/kcs_bmc_client.h b/include/linux/kcs_bmc_client.h similarity index 97% rename from drivers/char/ipmi/kcs_bmc_client.h rename to include/linux/kcs_bmc_client.h index 6fdcde0a7169..f6350c9366dd 100644 --- a/drivers/char/ipmi/kcs_bmc_client.h +++ b/include/linux/kcs_bmc_client.h @@ -5,8 +5,7 @@ #define __KCS_BMC_CONSUMER_H__ #include - -#include "kcs_bmc.h" +#include struct kcs_bmc_driver_ops { int (*add_device)(struct kcs_bmc_device *kcs_bmc); diff --git a/drivers/char/ipmi/kcs_bmc_device.h b/include/linux/kcs_bmc_device.h similarity index 96% rename from drivers/char/ipmi/kcs_bmc_device.h rename to include/linux/kcs_bmc_device.h index 17c572f25c54..65333b68c0af 100644 --- a/drivers/char/ipmi/kcs_bmc_device.h +++ b/include/linux/kcs_bmc_device.h @@ -5,8 +5,7 @@ #define __KCS_BMC_DEVICE_H__ #include - -#include "kcs_bmc.h" +#include struct kcs_bmc_device_ops { void (*irq_mask_update)(struct kcs_bmc_device *kcs_bmc, u8 mask, u8 enable); From patchwork Tue Oct 10 12:23:20 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Konstantin Aladyshev X-Patchwork-Id: 1845875 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20230601 header.b=kQLKP+JS; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=lists.ozlabs.org (client-ip=112.213.38.117; helo=lists.ozlabs.org; envelope-from=linux-aspeed-bounces+incoming=patchwork.ozlabs.org@lists.ozlabs.org; receiver=patchwork.ozlabs.org) Received: from lists.ozlabs.org (lists.ozlabs.org [112.213.38.117]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (secp384r1)) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4S4Zrg1Jszz20Xn for ; Tue, 10 Oct 2023 23:26:26 +1100 (AEDT) Authentication-Results: lists.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20230601 header.b=kQLKP+JS; dkim-atps=neutral Received: from boromir.ozlabs.org (localhost [IPv6:::1]) by lists.ozlabs.org (Postfix) with ESMTP id 4S4Zrf4h4rz3vc8 for ; Tue, 10 Oct 2023 23:26:26 +1100 (AEDT) X-Original-To: linux-aspeed@lists.ozlabs.org Delivered-To: linux-aspeed@lists.ozlabs.org Authentication-Results: lists.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20230601 header.b=kQLKP+JS; dkim-atps=neutral Authentication-Results: lists.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gmail.com (client-ip=2a00:1450:4864:20::233; helo=mail-lj1-x233.google.com; envelope-from=aladyshev22@gmail.com; receiver=lists.ozlabs.org) Received: from mail-lj1-x233.google.com (mail-lj1-x233.google.com [IPv6:2a00:1450:4864:20::233]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by lists.ozlabs.org (Postfix) with ESMTPS id 4S4ZnJ5SD4z3bx0; Tue, 10 Oct 2023 23:23:32 +1100 (AEDT) Received: by mail-lj1-x233.google.com with SMTP id 38308e7fff4ca-2b95d5ee18dso68122541fa.1; Tue, 10 Oct 2023 05:23:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1696940609; x=1697545409; darn=lists.ozlabs.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=Yp1yNMJhm0Xmlti2S7KpcZZ4ydY0GaIDDg/yGsmahK4=; b=kQLKP+JSdCfLPczoGPTdk2bEgNnKfQI/jo6L+HmZ22LVPtl+LmDR9eNKEKzqvy4YZf i3F/Vjuin91ps40iylqV/t80SkfaFEIAFo3phKESq25gQ9qfaWqp0re1He6PNYDFBSth vcrPCtBak31s7LahIYUjZRkxYPcrWzJ86du0efoIv7Ol8jRbO+CbUSVlXrFjGwI9l0jt wj9+K7LznuViYN4ve/RWnEMXT13a6JURvmWuY+iWyLfvBZv0hyTs72y5YDnizjA6wLSG vSLcjo9Dijx2s47eLGlQaVf+VsgGNIsF/TrkdE+gk0fKkGQX14iv05VrHhXMA2jeGgZE kVyA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1696940609; x=1697545409; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=Yp1yNMJhm0Xmlti2S7KpcZZ4ydY0GaIDDg/yGsmahK4=; b=B46liLyZ32HBTfYX3YS7uZNJbhF7y3MxUSuPXUHZH8yrW7DpWcWrk9OkyE95njIoR8 szmSHMcLy/N6ZMpEYMajZD9QfWKZZoUwarsnjIvWLfCHgrDMN6orb8+65KrJrDg90xtk K9sG76gUkeDgq5a96u4TKF/OIOwohB6pxBqLAjK8yTKEEZYHSDY97QSjotYoS0yk9uuc 5Pvcdr50n+Mi1bWt1G6TJPs9BKwW7Hc7nIii2unMSc8fK5nu2Ph8qGQMMgbG97IiZxoo Sm1zTHwC1RgJBms7UhFyK832wA9RRNMGY2GS05slacEGzgOzwoDcvFD63/zNAFn8vn8I 62UA== X-Gm-Message-State: AOJu0Ywz/wjDDQqMoVNy7P9f3L68wFngtoZoGSo5Pf10xybAneDwm0F/ g8SeNmzOHRw8e2eDHf16VVc= X-Google-Smtp-Source: AGHT+IE6Sf9WBnW7fB/PVNBWIP5TwKbcCvhx6WXGgnBaKiv0H1Z3E/dt1Hv3RyBRA5YTXQpg1DjOzQ== X-Received: by 2002:a2e:9b07:0:b0:2bd:a85:899e with SMTP id u7-20020a2e9b07000000b002bd0a85899emr16820416lji.3.1696940608544; Tue, 10 Oct 2023 05:23:28 -0700 (PDT) Received: from PC10319.67 ([82.97.198.254]) by smtp.googlemail.com with ESMTPSA id g9-20020a2e9cc9000000b002b9e346a152sm2425638ljj.96.2023.10.10.05.23.27 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 10 Oct 2023 05:23:28 -0700 (PDT) From: Konstantin Aladyshev To: Subject: [PATCH v5 2/3] ipmi: Create header with KCS interface defines Date: Tue, 10 Oct 2023 15:23:20 +0300 Message-Id: <20231010122321.823-3-aladyshev22@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20231010122321.823-1-aladyshev22@gmail.com> References: <20231010122321.823-1-aladyshev22@gmail.com> MIME-Version: 1.0 X-BeenThere: linux-aspeed@lists.ozlabs.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Linux ASPEED SoC development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: tmaimon77@gmail.com, linux-aspeed@lists.ozlabs.org, tali.perry1@gmail.com, edumazet@google.com, jk@codeconstruct.com.au, matt@codeconstruct.com.au, openbmc@lists.ozlabs.org, yuenn@google.com, kuba@kernel.org, pabeni@redhat.com, minyard@acm.org, aladyshev22@gmail.com, openipmi-developer@lists.sourceforge.net, linux-arm-kernel@lists.infradead.org, venture@google.com, linux-kernel@vger.kernel.org, avifishman70@gmail.com, netdev@vger.kernel.org, davem@davemloft.net Errors-To: linux-aspeed-bounces+incoming=patchwork.ozlabs.org@lists.ozlabs.org Sender: "Linux-aspeed" Some definitions from the current kcs_bmc_cdev_ipmi driver can be also utilized by the MTCP KCS binding driver. Move such definitions to the common header file. Signed-off-by: Konstantin Aladyshev --- drivers/char/ipmi/kcs_bmc_cdev_ipmi.c | 71 +----------------------- include/linux/ipmi_kcs.h | 80 +++++++++++++++++++++++++++ 2 files changed, 81 insertions(+), 70 deletions(-) create mode 100644 include/linux/ipmi_kcs.h diff --git a/drivers/char/ipmi/kcs_bmc_cdev_ipmi.c b/drivers/char/ipmi/kcs_bmc_cdev_ipmi.c index bf1001130a6c..f158f676114c 100644 --- a/drivers/char/ipmi/kcs_bmc_cdev_ipmi.c +++ b/drivers/char/ipmi/kcs_bmc_cdev_ipmi.c @@ -8,6 +8,7 @@ #include #include #include +#include #include #include #include @@ -19,53 +20,6 @@ #include -/* Different phases of the KCS BMC module. - * KCS_PHASE_IDLE: - * BMC should not be expecting nor sending any data. - * KCS_PHASE_WRITE_START: - * BMC is receiving a WRITE_START command from system software. - * KCS_PHASE_WRITE_DATA: - * BMC is receiving a data byte from system software. - * KCS_PHASE_WRITE_END_CMD: - * BMC is waiting a last data byte from system software. - * KCS_PHASE_WRITE_DONE: - * BMC has received the whole request from system software. - * KCS_PHASE_WAIT_READ: - * BMC is waiting the response from the upper IPMI service. - * KCS_PHASE_READ: - * BMC is transferring the response to system software. - * KCS_PHASE_ABORT_ERROR1: - * BMC is waiting error status request from system software. - * KCS_PHASE_ABORT_ERROR2: - * BMC is waiting for idle status afer error from system software. - * KCS_PHASE_ERROR: - * BMC has detected a protocol violation at the interface level. - */ -enum kcs_ipmi_phases { - KCS_PHASE_IDLE, - - KCS_PHASE_WRITE_START, - KCS_PHASE_WRITE_DATA, - KCS_PHASE_WRITE_END_CMD, - KCS_PHASE_WRITE_DONE, - - KCS_PHASE_WAIT_READ, - KCS_PHASE_READ, - - KCS_PHASE_ABORT_ERROR1, - KCS_PHASE_ABORT_ERROR2, - KCS_PHASE_ERROR -}; - -/* IPMI 2.0 - Table 9-4, KCS Interface Status Codes */ -enum kcs_ipmi_errors { - KCS_NO_ERROR = 0x00, - KCS_ABORTED_BY_COMMAND = 0x01, - KCS_ILLEGAL_CONTROL_CODE = 0x02, - KCS_LENGTH_ERROR = 0x06, - KCS_UNSPECIFIED_ERROR = 0xFF -}; - struct kcs_bmc_ipmi { struct list_head entry; @@ -95,29 +49,6 @@ struct kcs_bmc_ipmi { #define KCS_MSG_BUFSIZ 1000 -#define KCS_ZERO_DATA 0 - -/* IPMI 2.0 - Table 9-1, KCS Interface Status Register Bits */ -#define KCS_STATUS_STATE(state) (state << 6) -#define KCS_STATUS_STATE_MASK GENMASK(7, 6) -#define KCS_STATUS_CMD_DAT BIT(3) -#define KCS_STATUS_SMS_ATN BIT(2) -#define KCS_STATUS_IBF BIT(1) -#define KCS_STATUS_OBF BIT(0) - -/* IPMI 2.0 - Table 9-2, KCS Interface State Bits */ -enum kcs_states { - IDLE_STATE = 0, - READ_STATE = 1, - WRITE_STATE = 2, - ERROR_STATE = 3, -}; - -/* IPMI 2.0 - Table 9-3, KCS Interface Control Codes */ -#define KCS_CMD_GET_STATUS_ABORT 0x60 -#define KCS_CMD_WRITE_START 0x61 -#define KCS_CMD_WRITE_END 0x62 -#define KCS_CMD_READ_BYTE 0x68 static inline void set_state(struct kcs_bmc_ipmi *priv, u8 state) { diff --git a/include/linux/ipmi_kcs.h b/include/linux/ipmi_kcs.h new file mode 100644 index 000000000000..30c4b6e4d689 --- /dev/null +++ b/include/linux/ipmi_kcs.h @@ -0,0 +1,80 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (c) 2015-2018, Intel Corporation. + */ + +#ifndef __IPMI_KCS_H__ +#define __IPMI_KCS_H__ + +/* Different phases of the KCS BMC module. + * KCS_PHASE_IDLE: + * BMC should not be expecting nor sending any data. + * KCS_PHASE_WRITE_START: + * BMC is receiving a WRITE_START command from system software. + * KCS_PHASE_WRITE_DATA: + * BMC is receiving a data byte from system software. + * KCS_PHASE_WRITE_END_CMD: + * BMC is waiting a last data byte from system software. + * KCS_PHASE_WRITE_DONE: + * BMC has received the whole request from system software. + * KCS_PHASE_WAIT_READ: + * BMC is waiting the response from the upper IPMI service. + * KCS_PHASE_READ: + * BMC is transferring the response to system software. + * KCS_PHASE_ABORT_ERROR1: + * BMC is waiting error status request from system software. + * KCS_PHASE_ABORT_ERROR2: + * BMC is waiting for idle status afer error from system software. + * KCS_PHASE_ERROR: + * BMC has detected a protocol violation at the interface level. + */ +enum kcs_ipmi_phases { + KCS_PHASE_IDLE, + + KCS_PHASE_WRITE_START, + KCS_PHASE_WRITE_DATA, + KCS_PHASE_WRITE_END_CMD, + KCS_PHASE_WRITE_DONE, + + KCS_PHASE_WAIT_READ, + KCS_PHASE_READ, + + KCS_PHASE_ABORT_ERROR1, + KCS_PHASE_ABORT_ERROR2, + KCS_PHASE_ERROR +}; + +/* IPMI 2.0 - Table 9-4, KCS Interface Status Codes */ +enum kcs_ipmi_errors { + KCS_NO_ERROR = 0x00, + KCS_ABORTED_BY_COMMAND = 0x01, + KCS_ILLEGAL_CONTROL_CODE = 0x02, + KCS_LENGTH_ERROR = 0x06, + KCS_UNSPECIFIED_ERROR = 0xFF +}; + +#define KCS_ZERO_DATA 0 + +/* IPMI 2.0 - Table 9-1, KCS Interface Status Register Bits */ +#define KCS_STATUS_STATE(state) (state << 6) +#define KCS_STATUS_STATE_MASK GENMASK(7, 6) +#define KCS_STATUS_CMD_DAT BIT(3) +#define KCS_STATUS_SMS_ATN BIT(2) +#define KCS_STATUS_IBF BIT(1) +#define KCS_STATUS_OBF BIT(0) + +/* IPMI 2.0 - Table 9-2, KCS Interface State Bits */ +enum kcs_states { + IDLE_STATE = 0, + READ_STATE = 1, + WRITE_STATE = 2, + ERROR_STATE = 3, +}; + +/* IPMI 2.0 - Table 9-3, KCS Interface Control Codes */ +#define KCS_CMD_GET_STATUS_ABORT 0x60 +#define KCS_CMD_WRITE_START 0x61 +#define KCS_CMD_WRITE_END 0x62 +#define KCS_CMD_READ_BYTE 0x68 + +#endif /* __IPMI_KCS_H__ */ From patchwork Tue Oct 10 12:23:21 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Konstantin Aladyshev X-Patchwork-Id: 1845877 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20230601 header.b=BstzMy6M; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=lists.ozlabs.org (client-ip=2404:9400:2:0:216:3eff:fee1:b9f1; helo=lists.ozlabs.org; envelope-from=linux-aspeed-bounces+incoming=patchwork.ozlabs.org@lists.ozlabs.org; receiver=patchwork.ozlabs.org) Received: from lists.ozlabs.org (lists.ozlabs.org [IPv6:2404:9400:2:0:216:3eff:fee1:b9f1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (secp384r1)) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4S4Zsm5blfz20Xn for ; Tue, 10 Oct 2023 23:27:24 +1100 (AEDT) Authentication-Results: lists.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20230601 header.b=BstzMy6M; dkim-atps=neutral Received: from boromir.ozlabs.org (localhost [IPv6:::1]) by lists.ozlabs.org (Postfix) with ESMTP id 4S4Zsm4STKz3vc5 for ; Tue, 10 Oct 2023 23:27:24 +1100 (AEDT) X-Original-To: linux-aspeed@lists.ozlabs.org Delivered-To: linux-aspeed@lists.ozlabs.org Authentication-Results: lists.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20230601 header.b=BstzMy6M; dkim-atps=neutral Authentication-Results: lists.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gmail.com (client-ip=2a00:1450:4864:20::22f; helo=mail-lj1-x22f.google.com; envelope-from=aladyshev22@gmail.com; receiver=lists.ozlabs.org) Received: from mail-lj1-x22f.google.com (mail-lj1-x22f.google.com [IPv6:2a00:1450:4864:20::22f]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by lists.ozlabs.org (Postfix) with ESMTPS id 4S4ZnL3Rnjz2yhR; Tue, 10 Oct 2023 23:23:34 +1100 (AEDT) Received: by mail-lj1-x22f.google.com with SMTP id 38308e7fff4ca-2c1854bebf5so70359991fa.1; Tue, 10 Oct 2023 05:23:34 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1696940610; x=1697545410; darn=lists.ozlabs.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=jD0baK3eKnOZZy7TDZ7McQqiNB/eWAMD87f8uiL0/IE=; b=BstzMy6M+B6GRlxlV/FNeTimtwdGyM11ya3UP9e9ySZQIzwJSEeWu/AL9T+5se4vlR pYxWg7R/wqf1O+qSt3qBIaLU6nCGi4fGIwYlLB1Wco+q0TG3Ee1+2mpeCyHJx7fX6+yy 8QAT2QlbyVQjFUR2hhqWcFFdyH9MmmZfIWEgPo3R4fmwdSft38J4LrU8ecKQi20eQ5KU OUan0YZfFnjsJb2KJf8HLTjuWODVhchIM6fpoyOFrSrc+xOtqtTIbg0bYdHFKH9rBJRH +8nEuqBunq6yMDIKV8ODdaNrmvMMIkIACrifzF3rV6xpP/KB0nfeNIQFR4Vd1FDAzA7n W8pA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1696940610; x=1697545410; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=jD0baK3eKnOZZy7TDZ7McQqiNB/eWAMD87f8uiL0/IE=; b=Xua2GqlFLcAjXgd45DeRFTN40fQ/HTLEAyO5YqPoURKXqM0iZ6TJ79wsoXLJdZafTO PeoXTgwh83jRt4TBNKuv7SQjE/c5J05lBxAASdmx0vK2ifnEmLCSEBcLWWHZ0eN/vRYe +ZBua/0+L2QDCSuh2vC1HIBvfauagQwtEAlQAE2oBAdK42twbK0FCQLZIBvnl5fTivyC FGAHYgBPdbr/AxEFA3+LG12Scize80Xx/x9aPRMQ7uXMPixfJ+yvx+HpkQXmdz3maFW9 U93Tl2CNV0a1eUBZeekfzzUeb8vyGgYAlJ7l3cozjMZ/vLcp08u3AEdQ657B+AGoGiHz Ug1g== X-Gm-Message-State: AOJu0YwLuRfvs1Bap+1yfcX3B3MshCHfUL6vpGwZg3Z+RKv8RlwU39Vv PbAhCEyr6/9+UwH1hAk7wk0= X-Google-Smtp-Source: AGHT+IGju9FUG0OHttJMvC4ezFn8eQVcrFplTtSE+0mlMCi5ydrxq6b1HtLtaQgMbTCkkbo/iwWgHA== X-Received: by 2002:a2e:9cc4:0:b0:2c2:97b9:4a95 with SMTP id g4-20020a2e9cc4000000b002c297b94a95mr16010436ljj.15.1696940609563; Tue, 10 Oct 2023 05:23:29 -0700 (PDT) Received: from PC10319.67 ([82.97.198.254]) by smtp.googlemail.com with ESMTPSA id g9-20020a2e9cc9000000b002b9e346a152sm2425638ljj.96.2023.10.10.05.23.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 10 Oct 2023 05:23:29 -0700 (PDT) From: Konstantin Aladyshev To: Subject: [PATCH v5 3/3] mctp: Add MCTP-over-KCS transport binding Date: Tue, 10 Oct 2023 15:23:21 +0300 Message-Id: <20231010122321.823-4-aladyshev22@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20231010122321.823-1-aladyshev22@gmail.com> References: <20231010122321.823-1-aladyshev22@gmail.com> MIME-Version: 1.0 X-BeenThere: linux-aspeed@lists.ozlabs.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Linux ASPEED SoC development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: tmaimon77@gmail.com, linux-aspeed@lists.ozlabs.org, tali.perry1@gmail.com, edumazet@google.com, jk@codeconstruct.com.au, matt@codeconstruct.com.au, openbmc@lists.ozlabs.org, yuenn@google.com, kuba@kernel.org, pabeni@redhat.com, minyard@acm.org, aladyshev22@gmail.com, openipmi-developer@lists.sourceforge.net, linux-arm-kernel@lists.infradead.org, venture@google.com, linux-kernel@vger.kernel.org, avifishman70@gmail.com, netdev@vger.kernel.org, davem@davemloft.net Errors-To: linux-aspeed-bounces+incoming=patchwork.ozlabs.org@lists.ozlabs.org Sender: "Linux-aspeed" This change adds a MCTP KCS transport binding, as defined by the DMTF specification DSP0254 - "MCTP KCS Transport Binding". A MCTP protocol network device is created for each KCS channel found in the system. The interrupt code for the KCS state machine is based on the current IPMI KCS driver. Signed-off-by: Konstantin Aladyshev --- drivers/net/mctp/Kconfig | 8 + drivers/net/mctp/Makefile | 1 + drivers/net/mctp/mctp-kcs.c | 600 ++++++++++++++++++++++++++++++++++++ 3 files changed, 609 insertions(+) create mode 100644 drivers/net/mctp/mctp-kcs.c diff --git a/drivers/net/mctp/Kconfig b/drivers/net/mctp/Kconfig index dc71657d9184..a37f7ba947c0 100644 --- a/drivers/net/mctp/Kconfig +++ b/drivers/net/mctp/Kconfig @@ -33,6 +33,14 @@ config MCTP_TRANSPORT_I2C from DMTF specification DSP0237. A MCTP protocol network device is created for each I2C bus that has been assigned a mctp-i2c device. +config MCTP_TRANSPORT_KCS + tristate "MCTP KCS transport" + depends on IPMI_KCS_BMC + help + Provides a driver to access MCTP devices over KCS transport, from + DMTF specification DSP0254. A MCTP protocol network device is + created for each KCS channel found in the system. + endmenu endif diff --git a/drivers/net/mctp/Makefile b/drivers/net/mctp/Makefile index 1ca3e6028f77..885339a40f22 100644 --- a/drivers/net/mctp/Makefile +++ b/drivers/net/mctp/Makefile @@ -1,2 +1,3 @@ obj-$(CONFIG_MCTP_SERIAL) += mctp-serial.o obj-$(CONFIG_MCTP_TRANSPORT_I2C) += mctp-i2c.o +obj-$(CONFIG_MCTP_TRANSPORT_KCS) += mctp-kcs.o diff --git a/drivers/net/mctp/mctp-kcs.c b/drivers/net/mctp/mctp-kcs.c new file mode 100644 index 000000000000..b0d903609c64 --- /dev/null +++ b/drivers/net/mctp/mctp-kcs.c @@ -0,0 +1,600 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Management Component Transport Protocol (MCTP) KCS transport binding. + * This driver is an implementation of the DMTF specification + * "DSP0254 - Management Component Transport Protocol (MCTP) KCS Transport + * Binding", available at: + * + * https://www.dmtf.org/sites/default/files/standards/documents/DSP0254_1.0.0.pdf + * + * This driver provides DSP0254-type MCTP-over-KCS transport using a Linux + * KCS client subsystem. + * + * Copyright (c) 2023 Konstantin Aladyshev + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define MCTP_KCS_MTU 64 +#define KCS_MSG_BUFSIZ 1000 + +struct mctp_kcs { + struct list_head entry; + + /* protects rx & tx state machines */ + spinlock_t lock; + + struct kcs_bmc_client client; + struct net_device *netdev; + + enum kcs_ipmi_phases phase; + enum kcs_ipmi_errors error; + + unsigned int data_in_idx; + u8 *data_in; + + unsigned int data_out_idx; + unsigned int data_out_len; + u8 *data_out; + + struct work_struct rx_work; +}; + +struct mctp_kcs_header { + u8 netfn_lun; + u8 defining_body; + u8 len; +} __packed; + +struct mctp_kcs_trailer { + u8 pec; +} __packed; + +#define MCTP_KCS_NETFN_LUN 0xb0 +#define DEFINING_BODY_DMTF_PRE_OS_WORKING_GROUP 0x01 + +static int mctp_kcs_validate_data(struct mctp_kcs *mkcs, u8 *data, + unsigned int len) +{ + struct mctp_kcs_header *hdr = (struct mctp_kcs_header *)data; + struct net_device *ndev = mkcs->netdev; + struct mctp_kcs_trailer *tlr; + u8 pec; + + if (len < (sizeof(struct mctp_kcs_header) + + sizeof(struct mctp_kcs_trailer))) { + dev_err(mkcs->client.dev->dev, + "%s: error! Received data size (%d) is less than binding structs size (%d)", + __func__, len, + sizeof(struct mctp_kcs_header) + + sizeof(struct mctp_kcs_trailer)); + ndev->stats.rx_length_errors++; + return -EINVAL; + } + if (hdr->netfn_lun != MCTP_KCS_NETFN_LUN) { + dev_err(mkcs->client.dev->dev, + "%s: KCS binding header error! netfn_lun = 0x%02x, but should be 0x%02x", + __func__, hdr->netfn_lun, MCTP_KCS_NETFN_LUN); + ndev->stats.rx_dropped++; + return -EINVAL; + } + if (hdr->defining_body != DEFINING_BODY_DMTF_PRE_OS_WORKING_GROUP) { + dev_err(mkcs->client.dev->dev, + "%s: KCS binding header error! defining_body = 0x%02x, but should be 0x%02x", + __func__, hdr->defining_body, + DEFINING_BODY_DMTF_PRE_OS_WORKING_GROUP); + ndev->stats.rx_dropped++; + return -EINVAL; + } + if (hdr->len != (u8)(len - sizeof(struct mctp_kcs_header) - + sizeof(struct mctp_kcs_trailer))) { + dev_err(mkcs->client.dev->dev, + "%s: KCS binding header error! len = 0x%02x, but should be 0x%02x", + __func__, hdr->len, + (u8)(len - sizeof(struct mctp_kcs_header) - + sizeof(struct mctp_kcs_trailer))); + ndev->stats.rx_length_errors++; + return -EINVAL; + } + + pec = i2c_smbus_pec(0, (u8 *)(hdr + 1), hdr->len); + tlr = (struct mctp_kcs_trailer *)((u8 *)(hdr + 1) + hdr->len); + if (pec != tlr->pec) { + dev_err(mkcs->client.dev->dev, + "%s: PEC error! Packet value=0x%02x, calculated value=0x%02x", + __func__, tlr->pec, pec); + ndev->stats.rx_crc_errors++; + return -EINVAL; + } + return 0; +} + +static void mctp_kcs_rx_work(struct work_struct *work) +{ + struct mctp_kcs *mkcs = container_of(work, struct mctp_kcs, rx_work); + struct mctp_skb_cb *cb; + unsigned int data_len; + struct sk_buff *skb; + unsigned long flags; + unsigned int i; + int rc; + + spin_lock_irqsave(&mkcs->lock, flags); + for (i = 0; i < (mkcs->data_in_idx); i++) + dev_dbg(mkcs->client.dev->dev, "%s: data_in[%d]=0x%02x", + __func__, i, mkcs->data_in[i]); + + if (mkcs->phase != KCS_PHASE_WRITE_DONE) { + dev_err(mkcs->client.dev->dev, + "%s: error! Wrong KCS stage at the end of data read (phase=%d)", + __func__, mkcs->phase); + mkcs->netdev->stats.rx_dropped++; + goto unlock_irq; + } + + rc = mctp_kcs_validate_data(mkcs, mkcs->data_in, mkcs->data_in_idx); + if (rc) { + dev_err(mkcs->client.dev->dev, + "%s: error! Binding validation failed", __func__); + goto unlock_irq; + } + + data_len = mkcs->data_in_idx - sizeof(struct mctp_kcs_header) - + sizeof(struct mctp_kcs_trailer); + + skb = netdev_alloc_skb(mkcs->netdev, data_len); + if (!skb) { + mkcs->netdev->stats.rx_dropped++; + goto unlock_irq; + } + + skb->protocol = htons(ETH_P_MCTP); + skb_put_data(skb, mkcs->data_in + sizeof(struct mctp_kcs_header), + data_len); + skb_reset_network_header(skb); + + cb = __mctp_cb(skb); + cb->halen = 0; + + netif_rx(skb); + mkcs->netdev->stats.rx_packets++; + mkcs->netdev->stats.rx_bytes += data_len; + +unlock_irq: + mkcs->phase = KCS_PHASE_WAIT_READ; + mkcs->data_in_idx = 0; + spin_unlock_irqrestore(&mkcs->lock, flags); +} + +static netdev_tx_t mctp_kcs_start_xmit(struct sk_buff *skb, + struct net_device *ndev) +{ + struct mctp_kcs *mkcs = netdev_priv(ndev); + struct mctp_kcs_header *kcs_header; + unsigned long flags; + int i; + + if (skb->len > MCTP_KCS_MTU) { + dev_err(&ndev->dev, "%s: error! skb len is bigger than MTU", + __func__); + ndev->stats.tx_dropped++; + goto out; + } + + spin_lock_irqsave(&mkcs->lock, flags); + if (mkcs->phase != KCS_PHASE_WAIT_READ) { + dev_err(&ndev->dev, + "%s: error! Wrong KCS stage at the start of data write (phase=%d)", + __func__, mkcs->phase); + dev_kfree_skb(skb); + spin_unlock_irqrestore(&mkcs->lock, flags); + return NETDEV_TX_BUSY; + } + + netif_stop_queue(ndev); + mkcs->phase = KCS_PHASE_READ; + kcs_header = (struct mctp_kcs_header *)mkcs->data_out; + kcs_header->netfn_lun = MCTP_KCS_NETFN_LUN; + kcs_header->defining_body = DEFINING_BODY_DMTF_PRE_OS_WORKING_GROUP; + kcs_header->len = skb->len; + skb_copy_bits(skb, 0, kcs_header + 1, skb->len); + mkcs->data_out[sizeof(struct mctp_kcs_header) + skb->len] = + i2c_smbus_pec(0, (u8 *)(kcs_header + 1), skb->len); + mkcs->data_out_idx = 1; + mkcs->data_out_len = skb->len + sizeof(struct mctp_kcs_header) + + sizeof(struct mctp_kcs_trailer); + + for (i = 0; i < (mkcs->data_out_len); i++) + dev_dbg(&ndev->dev, "%s: data_out[%d]=0x%02x", __func__, i, + mkcs->data_out[i]); + + // Write first data byte to initialize transmission + kcs_bmc_write_data(mkcs->client.dev, mkcs->data_out[0]); + + spin_unlock_irqrestore(&mkcs->lock, flags); +out: + dev_kfree_skb(skb); + return NETDEV_TX_OK; +} + +static void set_state(struct mctp_kcs *mkcs, u8 state) +{ + dev_dbg(mkcs->client.dev->dev, "%s: state=0x%02x", __func__, state); + kcs_bmc_update_status(mkcs->client.dev, KCS_STATUS_STATE_MASK, + KCS_STATUS_STATE(state)); +} + +static int mctp_kcs_ndo_open(struct net_device *ndev) +{ + struct mctp_kcs *mkcs; + + mkcs = netdev_priv(ndev); + dev_info(&ndev->dev, "Open MCTP over KCS channel %d", + mkcs->client.dev->channel); + return kcs_bmc_enable_device(mkcs->client.dev, &mkcs->client); +} + +static int mctp_kcs_ndo_stop(struct net_device *ndev) +{ + struct mctp_kcs *mkcs; + + mkcs = netdev_priv(ndev); + dev_info(&ndev->dev, "Stop MCTP over KCS channel %d", + mkcs->client.dev->channel); + mkcs->data_in_idx = 0; + mkcs->data_out_idx = 0; + mkcs->data_out_len = 0; + mkcs->phase = KCS_PHASE_IDLE; + set_state(mkcs, IDLE_STATE); + kcs_bmc_disable_device(mkcs->client.dev, &mkcs->client); + return 0; +} + +static const struct net_device_ops mctp_kcs_netdev_ops = { + .ndo_start_xmit = mctp_kcs_start_xmit, + .ndo_open = mctp_kcs_ndo_open, + .ndo_stop = mctp_kcs_ndo_stop, +}; + +static void mctp_kcs_setup(struct net_device *ndev) +{ + ndev->type = ARPHRD_MCTP; + + /* we limit at the fixed MTU, which is also the MCTP-standard + * baseline MTU, so is also our minimum + */ + ndev->mtu = MCTP_KCS_MTU; + ndev->max_mtu = MCTP_KCS_MTU; + ndev->min_mtu = MCTP_KCS_MTU; + + ndev->hard_header_len = 0; + ndev->addr_len = 0; + ndev->tx_queue_len = DEFAULT_TX_QUEUE_LEN; + ndev->flags = IFF_NOARP; + ndev->netdev_ops = &mctp_kcs_netdev_ops; + ndev->needs_free_netdev = true; +} + +static void kcs_bmc_ipmi_force_abort(struct mctp_kcs *mkcs) +{ + dev_err(mkcs->client.dev->dev, + "Error! Force abort on KCS communication"); + set_state(mkcs, ERROR_STATE); + kcs_bmc_read_data(mkcs->client.dev); + kcs_bmc_write_data(mkcs->client.dev, KCS_ZERO_DATA); + mkcs->phase = KCS_PHASE_ERROR; + mkcs->data_in_idx = 0; +} + +static void kcs_bmc_ipmi_handle_data(struct mctp_kcs *mkcs) +{ + struct kcs_bmc_device *kcs_bmc = mkcs->client.dev; + u8 data; + + switch (mkcs->phase) { + case KCS_PHASE_WRITE_START: + dev_dbg(kcs_bmc->dev, "%s: KCS_PHASE_WRITE_START", __func__); + mkcs->phase = KCS_PHASE_WRITE_DATA; + fallthrough; + + case KCS_PHASE_WRITE_DATA: + dev_dbg(kcs_bmc->dev, "%s: KCS_PHASE_WRITE_DATA", __func__); + if (mkcs->data_in_idx < KCS_MSG_BUFSIZ) { + set_state(mkcs, WRITE_STATE); + kcs_bmc_write_data(kcs_bmc, KCS_ZERO_DATA); + mkcs->data_in[mkcs->data_in_idx++] = + kcs_bmc_read_data(kcs_bmc); + dev_dbg(kcs_bmc->dev, + "%s: KCS_PHASE_WRITE_DATA: data_in[%d]=0x%02x", + __func__, mkcs->data_in_idx - 1, + mkcs->data_in[mkcs->data_in_idx - 1]); + } else { + kcs_bmc_ipmi_force_abort(mkcs); + mkcs->error = KCS_LENGTH_ERROR; + } + break; + + case KCS_PHASE_WRITE_END_CMD: + dev_dbg(kcs_bmc->dev, "%s: KCS_PHASE_WRITE_END_CMD", __func__); + if (mkcs->data_in_idx < KCS_MSG_BUFSIZ) { + set_state(mkcs, READ_STATE); + mkcs->data_in[mkcs->data_in_idx++] = + kcs_bmc_read_data(kcs_bmc); + dev_dbg(kcs_bmc->dev, + "%s: KCS_PHASE_WRITE_END_CMD: data_in[%d]=0x%02x", + __func__, mkcs->data_in_idx - 1, + mkcs->data_in[mkcs->data_in_idx - 1]); + mkcs->phase = KCS_PHASE_WRITE_DONE; + schedule_work(&mkcs->rx_work); + } else { + kcs_bmc_ipmi_force_abort(mkcs); + mkcs->error = KCS_LENGTH_ERROR; + } + break; + + case KCS_PHASE_READ: + dev_dbg(kcs_bmc->dev, + "%s: KCS_PHASE_READ, data_out_idx=%d, data_out_len=%d", + __func__, mkcs->data_out_idx, mkcs->data_out_len); + if (mkcs->data_out_idx == mkcs->data_out_len) + set_state(mkcs, IDLE_STATE); + + data = kcs_bmc_read_data(kcs_bmc); + if (data != KCS_CMD_READ_BYTE) { + dev_dbg(kcs_bmc->dev, + "%s: error! data is not equal to KCS_CMD_READ_BYTE", + __func__); + set_state(mkcs, ERROR_STATE); + kcs_bmc_write_data(kcs_bmc, KCS_ZERO_DATA); + break; + } + + if (mkcs->data_out_idx == mkcs->data_out_len) { + kcs_bmc_write_data(kcs_bmc, KCS_ZERO_DATA); + mkcs->netdev->stats.tx_bytes += mkcs->data_out_len; + mkcs->netdev->stats.tx_packets++; + mkcs->phase = KCS_PHASE_IDLE; + if (netif_queue_stopped(mkcs->netdev)) + netif_start_queue(mkcs->netdev); + break; + } + + dev_dbg(kcs_bmc->dev, "%s: KCS_PHASE_READ: data_out[%d]=0x%02x", + __func__, mkcs->data_out_idx, + mkcs->data_out[mkcs->data_out_idx]); + kcs_bmc_write_data(kcs_bmc, + mkcs->data_out[mkcs->data_out_idx++]); + break; + + case KCS_PHASE_ABORT_ERROR1: + dev_dbg(kcs_bmc->dev, "%s: KCS_PHASE_ABORT_ERROR1", __func__); + set_state(mkcs, READ_STATE); + kcs_bmc_read_data(kcs_bmc); + kcs_bmc_write_data(kcs_bmc, mkcs->error); + mkcs->phase = KCS_PHASE_ABORT_ERROR2; + break; + + case KCS_PHASE_ABORT_ERROR2: + dev_dbg(kcs_bmc->dev, "%s: KCS_PHASE_ABORT_ERROR2", __func__); + set_state(mkcs, IDLE_STATE); + kcs_bmc_read_data(kcs_bmc); + kcs_bmc_write_data(kcs_bmc, KCS_ZERO_DATA); + mkcs->phase = KCS_PHASE_IDLE; + break; + + default: + dev_dbg(kcs_bmc->dev, "%s: unknown KCS phase", __func__); + kcs_bmc_ipmi_force_abort(mkcs); + break; + } +} + +static void kcs_bmc_ipmi_handle_cmd(struct mctp_kcs *mkcs) +{ + struct kcs_bmc_device *kcs_bmc = mkcs->client.dev; + + set_state(mkcs, WRITE_STATE); + kcs_bmc_write_data(kcs_bmc, KCS_ZERO_DATA); + + switch (kcs_bmc_read_data(kcs_bmc)) { + case KCS_CMD_WRITE_START: + dev_dbg(kcs_bmc->dev, "%s: KCS_CMD_WRITE_START", __func__); + mkcs->phase = KCS_PHASE_WRITE_START; + mkcs->error = KCS_NO_ERROR; + mkcs->data_in_idx = 0; + break; + + case KCS_CMD_WRITE_END: + dev_dbg(kcs_bmc->dev, "%s: KCS_CMD_WRITE_END", __func__); + if (mkcs->phase != KCS_PHASE_WRITE_DATA) { + kcs_bmc_ipmi_force_abort(mkcs); + break; + } + mkcs->phase = KCS_PHASE_WRITE_END_CMD; + break; + + case KCS_CMD_GET_STATUS_ABORT: + dev_dbg(kcs_bmc->dev, "%s: KCS_CMD_GET_STATUS_ABORT", __func__); + if (mkcs->error == KCS_NO_ERROR) + mkcs->error = KCS_ABORTED_BY_COMMAND; + + mkcs->phase = KCS_PHASE_ABORT_ERROR1; + mkcs->data_in_idx = 0; + break; + + default: + dev_dbg(kcs_bmc->dev, "%s: unknown KCS command", __func__); + kcs_bmc_ipmi_force_abort(mkcs); + mkcs->error = KCS_ILLEGAL_CONTROL_CODE; + break; + } +} + +static struct mctp_kcs *client_to_mctp_kcs(struct kcs_bmc_client *client) +{ + return container_of(client, struct mctp_kcs, client); +} + +static irqreturn_t kcs_bmc_mctp_event(struct kcs_bmc_client *client) +{ + struct mctp_kcs *mkcs; + u8 status; + int ret; + + mkcs = client_to_mctp_kcs(client); + if (!mkcs) { + dev_err(client->dev->dev, + "%s: error! can't find mctp_kcs from KCS client", + __func__); + return IRQ_NONE; + } + + spin_lock(&mkcs->lock); + + status = kcs_bmc_read_status(client->dev); + if (status & KCS_STATUS_IBF) { + if (status & KCS_STATUS_CMD_DAT) + kcs_bmc_ipmi_handle_cmd(mkcs); + else + kcs_bmc_ipmi_handle_data(mkcs); + + ret = IRQ_HANDLED; + } else { + ret = IRQ_NONE; + } + + spin_unlock(&mkcs->lock); + + return ret; +} + +static const struct kcs_bmc_client_ops kcs_bmc_mctp_client_ops = { + .event = kcs_bmc_mctp_event, +}; + +static DEFINE_SPINLOCK(kcs_bmc_mctp_instances_lock); +static LIST_HEAD(kcs_bmc_mctp_instances); + +static int kcs_bmc_mctp_add_device(struct kcs_bmc_device *kcs_bmc) +{ + struct net_device *ndev; + struct mctp_kcs *mkcs; + char name[32]; + int rc; + + snprintf(name, sizeof(name), "mctpkcs%d", kcs_bmc->channel); + + ndev = alloc_netdev(sizeof(*mkcs), name, NET_NAME_ENUM, mctp_kcs_setup); + if (!ndev) { + dev_err_probe(kcs_bmc->dev, -ENOMEM, + "alloc_netdev failed for KCS channel %d\n", + kcs_bmc->channel); + return -ENOMEM; + } + + mkcs = netdev_priv(ndev); + mkcs->netdev = ndev; + mkcs->client.dev = kcs_bmc; + mkcs->client.ops = &kcs_bmc_mctp_client_ops; + mkcs->data_in = devm_kmalloc(kcs_bmc->dev, KCS_MSG_BUFSIZ, GFP_KERNEL); + if (!mkcs->data_in) { + dev_err_probe( + kcs_bmc->dev, -ENOMEM, + "failed to allocate data_in buffer for KCS channel %d\n", + kcs_bmc->channel); + rc = -ENOMEM; + goto free_netdev; + } + mkcs->data_out = devm_kmalloc(kcs_bmc->dev, KCS_MSG_BUFSIZ, GFP_KERNEL); + if (!mkcs->data_out) { + dev_err_probe( + kcs_bmc->dev, -ENOMEM, + "failed to allocate data_out buffer for KCS channel %d\n", + kcs_bmc->channel); + rc = -ENOMEM; + goto free_netdev; + } + + INIT_WORK(&mkcs->rx_work, mctp_kcs_rx_work); + + rc = register_netdev(ndev); + if (rc) + goto free_netdev; + + spin_lock_irq(&kcs_bmc_mctp_instances_lock); + list_add(&mkcs->entry, &kcs_bmc_mctp_instances); + spin_unlock_irq(&kcs_bmc_mctp_instances_lock); + + dev_info(kcs_bmc->dev, "Add MCTP client for the KCS channel %d", + kcs_bmc->channel); + return 0; + +free_netdev: + free_netdev(ndev); + + return rc; +} + +static int kcs_bmc_mctp_remove_device(struct kcs_bmc_device *kcs_bmc) +{ + struct mctp_kcs *mkcs = NULL, *pos; + + dev_info(kcs_bmc->dev, "Remove MCTP client for the KCS channel %d", + kcs_bmc->channel); + spin_lock_irq(&kcs_bmc_mctp_instances_lock); + list_for_each_entry(pos, &kcs_bmc_mctp_instances, entry) { + if (pos->client.dev == kcs_bmc) { + mkcs = pos; + list_del(&pos->entry); + break; + } + } + spin_unlock_irq(&kcs_bmc_mctp_instances_lock); + + if (!mkcs) + return -ENODEV; + + unregister_netdev(mkcs->netdev); + free_netdev(mkcs->netdev); + kcs_bmc_disable_device(kcs_bmc, &mkcs->client); + devm_kfree(kcs_bmc->dev, mkcs->data_out); + devm_kfree(kcs_bmc->dev, mkcs->data_in); + return 0; +} + +static const struct kcs_bmc_driver_ops kcs_bmc_mctp_driver_ops = { + .add_device = kcs_bmc_mctp_add_device, + .remove_device = kcs_bmc_mctp_remove_device, +}; + +static struct kcs_bmc_driver kcs_bmc_mctp_driver = { + .ops = &kcs_bmc_mctp_driver_ops, +}; + +static int __init mctp_kcs_init(void) +{ + kcs_bmc_register_driver(&kcs_bmc_mctp_driver); + return 0; +} + +static void __exit mctp_kcs_exit(void) +{ + kcs_bmc_unregister_driver(&kcs_bmc_mctp_driver); +} + +module_init(mctp_kcs_init); +module_exit(mctp_kcs_exit); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Konstantin Aladyshev "); +MODULE_DESCRIPTION("MCTP KCS transport");