From nobody Fri May 17 03:39:49 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=nongnu.org ARC-Seal: i=1; a=rsa-sha256; t=1611689988; cv=none; d=zohomail.com; s=zohoarc; b=il2oEsOZQCX7lSNBAzPaCLmdaG+7nsuNryJ16MWQ8Q/I2reoutRNBc2uZ9j3DrtW7QUSMR8EshPN8QKvjB1w32nzFC57HUGciJE9scsptVY8DNTckjYrOPGggZF7a7ZX1NIp0t1laRV8q0JVcNgavBEyf5M8bkwWV1EwYh+R9NQ= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1611689988; h=Content-Type:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Reply-To:References:Sender:Subject:To; bh=MXpYq4rGrYnKEV9MTkJ+FJRm52fVhSZVjQB4Boy0H48=; b=nmRjTqGRkK+1/28znt6i1z3AmQDJ42un8aIpefcpyWUc+zXFS6Q0x5b1AAFQkytyPw+YbCXhEAc7tqy3PTcKe2rEvqHEv1cAGNW8fn1VXWDCAF7BNZgyDAd8QjfhVefTSMVV/zB7WgHsHP26gOpMjBsDWt1eZAagSkeMyabXSdA= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1611689988106708.8037968057823; Tue, 26 Jan 2021 11:39:48 -0800 (PST) Received: from localhost ([::1]:50256 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1l4UBn-0001fY-1M for importer@patchew.org; Tue, 26 Jan 2021 14:39:47 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:37044) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <3ZW4QYAgKCooA8vo276vu22uzs.q204s08-rs9sz121u18.25u@flex--wuhaotsh.bounces.google.com>) id 1l4U5O-0004Y5-69 for qemu-devel@nongnu.org; Tue, 26 Jan 2021 14:33:11 -0500 Received: from mail-qk1-x749.google.com ([2607:f8b0:4864:20::749]:50079) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from <3ZW4QYAgKCooA8vo276vu22uzs.q204s08-rs9sz121u18.25u@flex--wuhaotsh.bounces.google.com>) id 1l4U5C-00046A-CO for qemu-devel@nongnu.org; Tue, 26 Jan 2021 14:33:09 -0500 Received: by mail-qk1-x749.google.com with SMTP id a75so7740957qkg.16 for ; Tue, 26 Jan 2021 11:32:54 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:in-reply-to:message-id:mime-version:references:subject :from:to:cc; bh=MXpYq4rGrYnKEV9MTkJ+FJRm52fVhSZVjQB4Boy0H48=; b=uU0WUUwpdX3IZlYrrj1mvLpU5jPBGleS0tjUfD9ccfsMVIzHNWrQ4+unNqiyKMfFyf wmUrAaQ7tBG328TbAIVVz0lmUZTF8CEmdAPoTp11pt+eV/4LXItPTRo5b0XIVXZRrNIx poD9iliNfKc5VvMOtbn5lXkRkTmHJZrVvNV5XZHgb9mIEr+SF2c+r/UAKAELs1Na8Vw2 WEiuejXlLnA4ftPZDBGvsGq7bdLxzuFI0vpdVWtM0eQCiiFGWzViErbdCVvOVnsbBYXJ iVOLyQgl5xshDtBEH7Oi3wg4CHf237BsLi03eUF/OL0pmQL5qDDjxMRGYPwwk3vk+u5r KVRg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=MXpYq4rGrYnKEV9MTkJ+FJRm52fVhSZVjQB4Boy0H48=; b=IylMwAdf71Xn+ZYvClkRPAg/uCYPHng6+tYm0CQaemQOT/tdsbsub/Vxhi8PMp1D4Y eXvnOOjnNSXUXv3vVodVpAGB24sT0i6ljAu4o8C6y+8V6BhMhcsxJQFxuEb45fDckdIZ WoKIvTWPL2e023AS7i8/i8ycqchrV4G4qMOQ1XOsu6EwKJw/vmrdYz82QRQxk85Wp/2g MS2UYDJZuS3xFjg6uDcs/L/zBT8zygbdyYQU/5+9frqyrbsVqsRQt6GQRMvQTyQkz/Ct Os930ORxTXwA4E0+tUqOVxboo0FCbWsbrtBLJ4Lc6bvNUizfcTqB9Ax73Za9RLTKbL0e NGKg== X-Gm-Message-State: AOAM53299GEG3ncjoYlZmROcSPHnfMa29XuCuRBSMwNKGyzmBWqS3lYb vlNzyv0XGT/jcloTVBWKyUysVLqN52fN+A== X-Google-Smtp-Source: ABdhPJyyqfMJP7CxNqTlls3KR4GAc7WWQ/JFkRdHIt9A5hHPLlBxlVA4AYQrEjaKuBzWLjUmQ5Z06I5yVvVjmg== X-Received: from mimik.c.googlers.com ([fda3:e722:ac3:10:7f:e700:c0a8:4e]) (user=wuhaotsh job=sendgmr) by 2002:a0c:ab1a:: with SMTP id h26mr7122375qvb.26.1611689573821; Tue, 26 Jan 2021 11:32:53 -0800 (PST) Date: Tue, 26 Jan 2021 11:32:32 -0800 In-Reply-To: <20210126193237.1534208-1-wuhaotsh@google.com> Message-Id: <20210126193237.1534208-2-wuhaotsh@google.com> Mime-Version: 1.0 References: <20210126193237.1534208-1-wuhaotsh@google.com> X-Mailer: git-send-email 2.30.0.365.g02bc693789-goog Subject: [PATCH 1/6] hw/arm: Remove GPIO from unimplemented NPCM7XX To: peter.maydell@linaro.org Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::749; envelope-from=3ZW4QYAgKCooA8vo276vu22uzs.q204s08-rs9sz121u18.25u@flex--wuhaotsh.bounces.google.com; helo=mail-qk1-x749.google.com X-Spam_score_int: -95 X-Spam_score: -9.6 X-Spam_bar: --------- X-Spam_report: (-9.6 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_MED=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, USER_IN_DEF_DKIM_WL=-7.5 autolearn=unavailable autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: venture@google.com, hskinnemoen@google.com, qemu-devel@nongnu.org, wuhaotsh@google.com, kfting@nuvoton.com, qemu-arm@nongnu.org, Avi.Fishman@nuvoton.com, dje@google.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" Reply-to: Hao Wu From: wuhaotsh--- via X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" NPCM7XX GPIO devices have been implemented in hw/gpio/npcm7xx-gpio.c. So we removed them from the unimplemented devices list. Reviewed-by: Doug Evans Reviewed-by: Tyrong Ting Signed-off-by: Hao Wu --- hw/arm/npcm7xx.c | 8 -------- 1 file changed, 8 deletions(-) diff --git a/hw/arm/npcm7xx.c b/hw/arm/npcm7xx.c index 72040d4079..d1fe9bd1df 100644 --- a/hw/arm/npcm7xx.c +++ b/hw/arm/npcm7xx.c @@ -576,14 +576,6 @@ static void npcm7xx_realize(DeviceState *dev, Error **= errp) create_unimplemented_device("npcm7xx.pcierc", 0xe1000000, 64 * = KiB); create_unimplemented_device("npcm7xx.kcs", 0xf0007000, 4 * = KiB); create_unimplemented_device("npcm7xx.gfxi", 0xf000e000, 4 * = KiB); - create_unimplemented_device("npcm7xx.gpio[0]", 0xf0010000, 4 * = KiB); - create_unimplemented_device("npcm7xx.gpio[1]", 0xf0011000, 4 * = KiB); - create_unimplemented_device("npcm7xx.gpio[2]", 0xf0012000, 4 * = KiB); - create_unimplemented_device("npcm7xx.gpio[3]", 0xf0013000, 4 * = KiB); - create_unimplemented_device("npcm7xx.gpio[4]", 0xf0014000, 4 * = KiB); - create_unimplemented_device("npcm7xx.gpio[5]", 0xf0015000, 4 * = KiB); - create_unimplemented_device("npcm7xx.gpio[6]", 0xf0016000, 4 * = KiB); - create_unimplemented_device("npcm7xx.gpio[7]", 0xf0017000, 4 * = KiB); create_unimplemented_device("npcm7xx.smbus[0]", 0xf0080000, 4 * = KiB); create_unimplemented_device("npcm7xx.smbus[1]", 0xf0081000, 4 * = KiB); create_unimplemented_device("npcm7xx.smbus[2]", 0xf0082000, 4 * = KiB); --=20 2.30.0.365.g02bc693789-goog From nobody Fri May 17 03:39:49 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=nongnu.org ARC-Seal: i=1; a=rsa-sha256; t=1611689829; cv=none; d=zohomail.com; s=zohoarc; b=XJV1AxxYWSEEF/Lwa278t7nQnHIQ0sUgxb3x571jBykkGoNaw9KaYTufqbF5fIr56shdjABtBABfCjs/Kq7OUUWJOScBA+bLMArFkAVyjfeHxqeoxGU/INhTzfO6GQadjQMuktMvBv3OZQvQeJn+MD4IMWicvQFOWPDNhp4Xjjg= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1611689829; h=Content-Type:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Reply-To:References:Sender:Subject:To; bh=axHcwkjGzd/saxpI1Y+FtPiG7edd9rDOoqo5KaYlM3I=; b=myXSgOwEotBd7Ax8Bb2RNkf/QyTxeKJoxcSqCmHBc09CoEXaTIipAl7jRm58ys6CV1Sb4sT3bzrAYlR1dcgZAf6sum9VDqy4T4BkbIG4yBS8lVLjRiTo5r17uODvVtrbYWjeobA0qpu5kAj5n+7bPHhevcud7idXtdGTL66vBuM= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1611689829826388.8784510929394; Tue, 26 Jan 2021 11:37:09 -0800 (PST) Received: from localhost ([::1]:42636 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1l4U9E-0006vm-Go for importer@patchew.org; Tue, 26 Jan 2021 14:37:08 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:37074) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <3Z24QYAgKCowCAxq498xw44w1u.s426u2A-tuBu1343w3A.47w@flex--wuhaotsh.bounces.google.com>) id 1l4U5Q-0004ZZ-7Q for qemu-devel@nongnu.org; Tue, 26 Jan 2021 14:33:12 -0500 Received: from mail-qv1-xf4a.google.com ([2607:f8b0:4864:20::f4a]:34464) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from <3Z24QYAgKCowCAxq498xw44w1u.s426u2A-tuBu1343w3A.47w@flex--wuhaotsh.bounces.google.com>) id 1l4U5C-00046M-V1 for qemu-devel@nongnu.org; Tue, 26 Jan 2021 14:33:11 -0500 Received: by mail-qv1-xf4a.google.com with SMTP id d8so5507454qvs.1 for ; Tue, 26 Jan 2021 11:32:55 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:in-reply-to:message-id:mime-version:references:subject :from:to:cc; bh=axHcwkjGzd/saxpI1Y+FtPiG7edd9rDOoqo5KaYlM3I=; b=ew2SiyCydRKPtQhwfrAx8zb6+VWA9r0y42sQkUaGfrp7XBHJe9yF4zjfFbclBLghDI nZb9Qhhpm/l/FGAYY1q77g5+/Vc2dLEXgPs7CMA9mO7WXSOoLWRHvX/yavKvKAy+g4zj 0T3HjTUmBEUe648NClLKkqln6EieQf7g7cgoxCrPJ3C3fpQpXTudu2s5T49qD3EeSlWK 9tXhuxJ0nV0X3jde70P0nqPVlqJSe3Z81ulSd4jD/RwzsHsixwLMZ7IsQrR87ON5pI3O kZxr7OjTxdGiE4MXmziwUgqewdhMA/ZbugNBulEJIrX5VZDUiQpdXzNf51DnVmZ4fJ0O t/oQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=axHcwkjGzd/saxpI1Y+FtPiG7edd9rDOoqo5KaYlM3I=; b=cAR7eOiRtaM0FlN1KhAgbK47F16au+4xNX35dn7uKjbmCFvTH8iByHqG3A1j5qdtPI deRLBnOXbdFsKUS8+B/7JnXrXJnPaMIvurcZ1t8cA0liBBNZGjV6oJMrqCRfTMOa7No4 TkZLVPT84xQpzfssIfvTsToJKB0LuBkiJ1Ma6fMSwGBzgMCoihjiutBV/tekB9zN6/bl ATD9EPMeBsP+DU14xQ64S6iKBMTMCtMvcc6NSRv8YBtqKBZ3JV0xBb+LLGBvPS+pmieY VqHdt1RuLN+E8Q991K6oxo+fRr21Y6h5CP8FKgrZS4zcKyBIrkOxfoRkbyQQacXZCWGq N0Sw== X-Gm-Message-State: AOAM533PVqgI3AZAbjKrv8U33SwjQp4o9f3cbNGqV4GqvAI+9LxZzzC7 2To3od+BCcrBgQm/Cgq/jyaFh6sxsOJzOA== X-Google-Smtp-Source: ABdhPJy/ji42mKR77NV1zfcype23Lltufy8qt6rn7JnTDc9mY8n0EmvGkPHMd7IH4z0TV1hxXJ8ovzNU8wFRpw== X-Received: from mimik.c.googlers.com ([fda3:e722:ac3:10:7f:e700:c0a8:4e]) (user=wuhaotsh job=sendgmr) by 2002:a0c:b611:: with SMTP id f17mr7062946qve.42.1611689575359; Tue, 26 Jan 2021 11:32:55 -0800 (PST) Date: Tue, 26 Jan 2021 11:32:33 -0800 In-Reply-To: <20210126193237.1534208-1-wuhaotsh@google.com> Message-Id: <20210126193237.1534208-3-wuhaotsh@google.com> Mime-Version: 1.0 References: <20210126193237.1534208-1-wuhaotsh@google.com> X-Mailer: git-send-email 2.30.0.365.g02bc693789-goog Subject: [PATCH 2/6] hw/i2c: Implement NPCM7XX SMBus Module Single Mode To: peter.maydell@linaro.org Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::f4a; envelope-from=3Z24QYAgKCowCAxq498xw44w1u.s426u2A-tuBu1343w3A.47w@flex--wuhaotsh.bounces.google.com; helo=mail-qv1-xf4a.google.com X-Spam_score_int: -95 X-Spam_score: -9.6 X-Spam_bar: --------- X-Spam_report: (-9.6 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_MED=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, USER_IN_DEF_DKIM_WL=-7.5 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: venture@google.com, hskinnemoen@google.com, qemu-devel@nongnu.org, wuhaotsh@google.com, kfting@nuvoton.com, qemu-arm@nongnu.org, Avi.Fishman@nuvoton.com, dje@google.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" Reply-to: Hao Wu From: wuhaotsh--- via X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This commit implements the single-byte mode of the SMBus. Each Nuvoton SoC has 16 System Management Bus (SMBus). These buses compliant with SMBus and I2C protocol. This patch implements the single-byte mode of the SMBus. In this mode, the user sends or receives a byte each time. The SMBus device transmits it to the underlying i2c device and sends an interrupt back to the QEMU guest. Reviewed-by: Doug Evans Reviewed-by: Tyrong Ting Signed-off-by: Hao Wu Reviewed-by: Corey Minyard --- docs/system/arm/nuvoton.rst | 2 +- hw/arm/npcm7xx.c | 68 ++- hw/i2c/meson.build | 1 + hw/i2c/npcm7xx_smbus.c | 766 +++++++++++++++++++++++++++++++++ hw/i2c/trace-events | 11 + include/hw/arm/npcm7xx.h | 2 + include/hw/i2c/npcm7xx_smbus.h | 88 ++++ 7 files changed, 921 insertions(+), 17 deletions(-) create mode 100644 hw/i2c/npcm7xx_smbus.c create mode 100644 include/hw/i2c/npcm7xx_smbus.h diff --git a/docs/system/arm/nuvoton.rst b/docs/system/arm/nuvoton.rst index a1786342e2..34fc799b2d 100644 --- a/docs/system/arm/nuvoton.rst +++ b/docs/system/arm/nuvoton.rst @@ -43,6 +43,7 @@ Supported devices * GPIO controller * Analog to Digital Converter (ADC) * Pulse Width Modulation (PWM) + * SMBus controller (SMBF) =20 Missing devices --------------- @@ -58,7 +59,6 @@ Missing devices =20 * Ethernet controllers (GMAC and EMC) * USB device (USBD) - * SMBus controller (SMBF) * Peripheral SPI controller (PSPI) * SD/MMC host * PECI interface diff --git a/hw/arm/npcm7xx.c b/hw/arm/npcm7xx.c index d1fe9bd1df..8f596ffd69 100644 --- a/hw/arm/npcm7xx.c +++ b/hw/arm/npcm7xx.c @@ -104,6 +104,22 @@ enum NPCM7xxInterrupt { NPCM7XX_OHCI_IRQ =3D 62, NPCM7XX_PWM0_IRQ =3D 93, /* PWM module 0 */ NPCM7XX_PWM1_IRQ, /* PWM module 1 */ + NPCM7XX_SMBUS0_IRQ =3D 64, + NPCM7XX_SMBUS1_IRQ, + NPCM7XX_SMBUS2_IRQ, + NPCM7XX_SMBUS3_IRQ, + NPCM7XX_SMBUS4_IRQ, + NPCM7XX_SMBUS5_IRQ, + NPCM7XX_SMBUS6_IRQ, + NPCM7XX_SMBUS7_IRQ, + NPCM7XX_SMBUS8_IRQ, + NPCM7XX_SMBUS9_IRQ, + NPCM7XX_SMBUS10_IRQ, + NPCM7XX_SMBUS11_IRQ, + NPCM7XX_SMBUS12_IRQ, + NPCM7XX_SMBUS13_IRQ, + NPCM7XX_SMBUS14_IRQ, + NPCM7XX_SMBUS15_IRQ, NPCM7XX_GPIO0_IRQ =3D 116, NPCM7XX_GPIO1_IRQ, NPCM7XX_GPIO2_IRQ, @@ -152,6 +168,26 @@ static const hwaddr npcm7xx_pwm_addr[] =3D { 0xf0104000, }; =20 +/* Direct memory-mapped access to each SMBus Module. */ +static const hwaddr npcm7xx_smbus_addr[] =3D { + 0xf0080000, + 0xf0081000, + 0xf0082000, + 0xf0083000, + 0xf0084000, + 0xf0085000, + 0xf0086000, + 0xf0087000, + 0xf0088000, + 0xf0089000, + 0xf008a000, + 0xf008b000, + 0xf008c000, + 0xf008d000, + 0xf008e000, + 0xf008f000, +}; + static const struct { hwaddr regs_addr; uint32_t unconnected_pins; @@ -353,6 +389,11 @@ static void npcm7xx_init(Object *obj) object_initialize_child(obj, "gpio[*]", &s->gpio[i], TYPE_NPCM7XX_= GPIO); } =20 + for (i =3D 0; i < ARRAY_SIZE(s->smbus); i++) { + object_initialize_child(obj, "smbus[*]", &s->smbus[i], + TYPE_NPCM7XX_SMBUS); + } + object_initialize_child(obj, "ehci", &s->ehci, TYPE_NPCM7XX_EHCI); object_initialize_child(obj, "ohci", &s->ohci, TYPE_SYSBUS_OHCI); =20 @@ -509,6 +550,17 @@ static void npcm7xx_realize(DeviceState *dev, Error **= errp) npcm7xx_irq(s, NPCM7XX_GPIO0_IRQ + i)); } =20 + /* SMBus modules. Cannot fail. */ + QEMU_BUILD_BUG_ON(ARRAY_SIZE(npcm7xx_smbus_addr) !=3D ARRAY_SIZE(s->sm= bus)); + for (i =3D 0; i < ARRAY_SIZE(s->smbus); i++) { + Object *obj =3D OBJECT(&s->smbus[i]); + + sysbus_realize(SYS_BUS_DEVICE(obj), &error_abort); + sysbus_mmio_map(SYS_BUS_DEVICE(obj), 0, npcm7xx_smbus_addr[i]); + sysbus_connect_irq(SYS_BUS_DEVICE(obj), 0, + npcm7xx_irq(s, NPCM7XX_SMBUS0_IRQ + i)); + } + /* USB Host */ object_property_set_bool(OBJECT(&s->ehci), "companion-enable", true, &error_abort); @@ -576,22 +628,6 @@ static void npcm7xx_realize(DeviceState *dev, Error **= errp) create_unimplemented_device("npcm7xx.pcierc", 0xe1000000, 64 * = KiB); create_unimplemented_device("npcm7xx.kcs", 0xf0007000, 4 * = KiB); create_unimplemented_device("npcm7xx.gfxi", 0xf000e000, 4 * = KiB); - create_unimplemented_device("npcm7xx.smbus[0]", 0xf0080000, 4 * = KiB); - create_unimplemented_device("npcm7xx.smbus[1]", 0xf0081000, 4 * = KiB); - create_unimplemented_device("npcm7xx.smbus[2]", 0xf0082000, 4 * = KiB); - create_unimplemented_device("npcm7xx.smbus[3]", 0xf0083000, 4 * = KiB); - create_unimplemented_device("npcm7xx.smbus[4]", 0xf0084000, 4 * = KiB); - create_unimplemented_device("npcm7xx.smbus[5]", 0xf0085000, 4 * = KiB); - create_unimplemented_device("npcm7xx.smbus[6]", 0xf0086000, 4 * = KiB); - create_unimplemented_device("npcm7xx.smbus[7]", 0xf0087000, 4 * = KiB); - create_unimplemented_device("npcm7xx.smbus[8]", 0xf0088000, 4 * = KiB); - create_unimplemented_device("npcm7xx.smbus[9]", 0xf0089000, 4 * = KiB); - create_unimplemented_device("npcm7xx.smbus[10]", 0xf008a000, 4 * = KiB); - create_unimplemented_device("npcm7xx.smbus[11]", 0xf008b000, 4 * = KiB); - create_unimplemented_device("npcm7xx.smbus[12]", 0xf008c000, 4 * = KiB); - create_unimplemented_device("npcm7xx.smbus[13]", 0xf008d000, 4 * = KiB); - create_unimplemented_device("npcm7xx.smbus[14]", 0xf008e000, 4 * = KiB); - create_unimplemented_device("npcm7xx.smbus[15]", 0xf008f000, 4 * = KiB); create_unimplemented_device("npcm7xx.espi", 0xf009f000, 4 * = KiB); create_unimplemented_device("npcm7xx.peci", 0xf0100000, 4 * = KiB); create_unimplemented_device("npcm7xx.siox[1]", 0xf0101000, 4 * = KiB); diff --git a/hw/i2c/meson.build b/hw/i2c/meson.build index 3a511539ad..cdcd694a7f 100644 --- a/hw/i2c/meson.build +++ b/hw/i2c/meson.build @@ -9,6 +9,7 @@ i2c_ss.add(when: 'CONFIG_EXYNOS4', if_true: files('exynos42= 10_i2c.c')) i2c_ss.add(when: 'CONFIG_IMX_I2C', if_true: files('imx_i2c.c')) i2c_ss.add(when: 'CONFIG_MPC_I2C', if_true: files('mpc_i2c.c')) i2c_ss.add(when: 'CONFIG_NRF51_SOC', if_true: files('microbit_i2c.c')) +i2c_ss.add(when: 'CONFIG_NPCM7XX', if_true: files('npcm7xx_smbus.c')) i2c_ss.add(when: 'CONFIG_SMBUS_EEPROM', if_true: files('smbus_eeprom.c')) i2c_ss.add(when: 'CONFIG_VERSATILE_I2C', if_true: files('versatile_i2c.c')) i2c_ss.add(when: 'CONFIG_OMAP', if_true: files('omap_i2c.c')) diff --git a/hw/i2c/npcm7xx_smbus.c b/hw/i2c/npcm7xx_smbus.c new file mode 100644 index 0000000000..e8a8fdbaff --- /dev/null +++ b/hw/i2c/npcm7xx_smbus.c @@ -0,0 +1,766 @@ +/* + * Nuvoton NPCM7xx SMBus Module. + * + * Copyright 2020 Google 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 WIT= HOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + */ + +#include "qemu/osdep.h" + +#include "hw/i2c/npcm7xx_smbus.h" +#include "migration/vmstate.h" +#include "qemu/bitops.h" +#include "qemu/guest-random.h" +#include "qemu/log.h" +#include "qemu/module.h" +#include "qemu/units.h" + +#include "trace.h" + +#define NPCM7XX_SMBUS_VERSION 1 +#define NPCM7XX_SMBUS_FIFO_EN 0 + +enum NPCM7xxSMBusCommonRegister { + NPCM7XX_SMB_SDA =3D 0x0, + NPCM7XX_SMB_ST =3D 0x2, + NPCM7XX_SMB_CST =3D 0x4, + NPCM7XX_SMB_CTL1 =3D 0x6, + NPCM7XX_SMB_ADDR1 =3D 0x8, + NPCM7XX_SMB_CTL2 =3D 0xa, + NPCM7XX_SMB_ADDR2 =3D 0xc, + NPCM7XX_SMB_CTL3 =3D 0xe, + NPCM7XX_SMB_CST2 =3D 0x18, + NPCM7XX_SMB_CST3 =3D 0x19, + NPCM7XX_SMB_VER =3D 0x1f, +}; + +enum NPCM7xxSMBusBank0Register { + NPCM7XX_SMB_ADDR3 =3D 0x10, + NPCM7XX_SMB_ADDR7 =3D 0x11, + NPCM7XX_SMB_ADDR4 =3D 0x12, + NPCM7XX_SMB_ADDR8 =3D 0x13, + NPCM7XX_SMB_ADDR5 =3D 0x14, + NPCM7XX_SMB_ADDR9 =3D 0x15, + NPCM7XX_SMB_ADDR6 =3D 0x16, + NPCM7XX_SMB_ADDR10 =3D 0x17, + NPCM7XX_SMB_CTL4 =3D 0x1a, + NPCM7XX_SMB_CTL5 =3D 0x1b, + NPCM7XX_SMB_SCLLT =3D 0x1c, + NPCM7XX_SMB_FIF_CTL =3D 0x1d, + NPCM7XX_SMB_SCLHT =3D 0x1e, +}; + +enum NPCM7xxSMBusBank1Register { + NPCM7XX_SMB_FIF_CTS =3D 0x10, + NPCM7XX_SMB_FAIR_PER =3D 0x11, + NPCM7XX_SMB_TXF_CTL =3D 0x12, + NPCM7XX_SMB_T_OUT =3D 0x14, + NPCM7XX_SMB_TXF_STS =3D 0x1a, + NPCM7XX_SMB_RXF_STS =3D 0x1c, + NPCM7XX_SMB_RXF_CTL =3D 0x1e, +}; + +/* ST fields */ +#define NPCM7XX_SMBST_STP BIT(7) +#define NPCM7XX_SMBST_SDAST BIT(6) +#define NPCM7XX_SMBST_BER BIT(5) +#define NPCM7XX_SMBST_NEGACK BIT(4) +#define NPCM7XX_SMBST_STASTR BIT(3) +#define NPCM7XX_SMBST_NMATCH BIT(2) +#define NPCM7XX_SMBST_MODE BIT(1) +#define NPCM7XX_SMBST_XMIT BIT(0) + +/* CST fields */ +#define NPCM7XX_SMBCST_ARPMATCH BIT(7) +#define NPCM7XX_SMBCST_MATCHAF BIT(6) +#define NPCM7XX_SMBCST_TGSCL BIT(5) +#define NPCM7XX_SMBCST_TSDA BIT(4) +#define NPCM7XX_SMBCST_GCMATCH BIT(3) +#define NPCM7XX_SMBCST_MATCH BIT(2) +#define NPCM7XX_SMBCST_BB BIT(1) +#define NPCM7XX_SMBCST_BUSY BIT(0) + +/* CST2 fields */ +#define NPCM7XX_SMBCST2_INTSTS BIT(7) +#define NPCM7XX_SMBCST2_MATCH7F BIT(6) +#define NPCM7XX_SMBCST2_MATCH6F BIT(5) +#define NPCM7XX_SMBCST2_MATCH5F BIT(4) +#define NPCM7XX_SMBCST2_MATCH4F BIT(3) +#define NPCM7XX_SMBCST2_MATCH3F BIT(2) +#define NPCM7XX_SMBCST2_MATCH2F BIT(1) +#define NPCM7XX_SMBCST2_MATCH1F BIT(0) + +/* CST3 fields */ +#define NPCM7XX_SMBCST3_EO_BUSY BIT(7) +#define NPCM7XX_SMBCST3_MATCH10F BIT(2) +#define NPCM7XX_SMBCST3_MATCH9F BIT(1) +#define NPCM7XX_SMBCST3_MATCH8F BIT(0) + +/* CTL1 fields */ +#define NPCM7XX_SMBCTL1_STASTRE BIT(7) +#define NPCM7XX_SMBCTL1_NMINTE BIT(6) +#define NPCM7XX_SMBCTL1_GCMEN BIT(5) +#define NPCM7XX_SMBCTL1_ACK BIT(4) +#define NPCM7XX_SMBCTL1_EOBINTE BIT(3) +#define NPCM7XX_SMBCTL1_INTEN BIT(2) +#define NPCM7XX_SMBCTL1_STOP BIT(1) +#define NPCM7XX_SMBCTL1_START BIT(0) + +/* CTL2 fields */ +#define NPCM7XX_SMBCTL2_SCLFRQ(rv) extract8((rv), 1, 6) +#define NPCM7XX_SMBCTL2_ENABLE BIT(0) + +/* CTL3 fields */ +#define NPCM7XX_SMBCTL3_SCL_LVL BIT(7) +#define NPCM7XX_SMBCTL3_SDA_LVL BIT(6) +#define NPCM7XX_SMBCTL3_BNK_SEL BIT(5) +#define NPCM7XX_SMBCTL3_400K_MODE BIT(4) +#define NPCM7XX_SMBCTL3_IDL_START BIT(3) +#define NPCM7XX_SMBCTL3_ARPMEN BIT(2) +#define NPCM7XX_SMBCTL3_SCLFRQ(rv) extract8((rv), 0, 2) + +/* ADDR fields */ +#define NPCM7XX_ADDR_EN BIT(7) +#define NPCM7XX_ADDR_A(rv) extract8((rv), 0, 6) + +#define KEEP_OLD_BIT(o, n, b) (((n) & (~(b))) | ((o) & (b))) +#define WRITE_ONE_CLEAR(o, n, b) ((n) & (b) ? (o) & (~(b)) : (o)) + +#define NPCM7XX_SMBUS_ENABLED(s) ((s)->ctl2 & NPCM7XX_SMBCTL2_ENABLE) + +/* Reset values */ +#define NPCM7XX_SMB_ST_INIT_VAL 0x00 +#define NPCM7XX_SMB_CST_INIT_VAL 0x10 +#define NPCM7XX_SMB_CST2_INIT_VAL 0x00 +#define NPCM7XX_SMB_CST3_INIT_VAL 0x00 +#define NPCM7XX_SMB_CTL1_INIT_VAL 0x00 +#define NPCM7XX_SMB_CTL2_INIT_VAL 0x00 +#define NPCM7XX_SMB_CTL3_INIT_VAL 0xc0 +#define NPCM7XX_SMB_CTL4_INIT_VAL 0x07 +#define NPCM7XX_SMB_CTL5_INIT_VAL 0x00 +#define NPCM7XX_SMB_ADDR_INIT_VAL 0x00 +#define NPCM7XX_SMB_SCLLT_INIT_VAL 0x00 +#define NPCM7XX_SMB_SCLHT_INIT_VAL 0x00 + +static uint8_t npcm7xx_smbus_get_version(void) +{ + return NPCM7XX_SMBUS_FIFO_EN << 7 | NPCM7XX_SMBUS_VERSION; +} + +static void npcm7xx_smbus_update_irq(NPCM7xxSMBusState *s) +{ + int level; + + if (s->ctl1 & NPCM7XX_SMBCTL1_INTEN) { + level =3D !!((s->ctl1 & NPCM7XX_SMBCTL1_NMINTE && + s->st & NPCM7XX_SMBST_NMATCH) || + (s->st & NPCM7XX_SMBST_BER) || + (s->st & NPCM7XX_SMBST_NEGACK) || + (s->st & NPCM7XX_SMBST_SDAST) || + (s->ctl1 & NPCM7XX_SMBCTL1_STASTRE && + s->st & NPCM7XX_SMBST_SDAST) || + (s->ctl1 & NPCM7XX_SMBCTL1_EOBINTE && + s->cst3 & NPCM7XX_SMBCST3_EO_BUSY)); + + if (level) { + s->cst2 |=3D NPCM7XX_SMBCST2_INTSTS; + } else { + s->cst2 &=3D ~NPCM7XX_SMBCST2_INTSTS; + } + qemu_set_irq(s->irq, level); + } +} + +static void npcm7xx_smbus_nack(NPCM7xxSMBusState *s) +{ + s->st &=3D ~NPCM7XX_SMBST_SDAST; + s->st |=3D NPCM7XX_SMBST_NEGACK; + s->status =3D NPCM7XX_SMBUS_STATUS_NEGACK; +} + +static void npcm7xx_smbus_send_byte(NPCM7xxSMBusState *s, uint8_t value) +{ + int rv =3D i2c_send(s->bus, value); + + if (rv) { + npcm7xx_smbus_nack(s); + } else { + s->st |=3D NPCM7XX_SMBST_SDAST; + } + trace_npcm7xx_smbus_send_byte((DEVICE(s)->canonical_path), value, !rv); + npcm7xx_smbus_update_irq(s); +} + +static void npcm7xx_smbus_recv_byte(NPCM7xxSMBusState *s) +{ + s->sda =3D i2c_recv(s->bus); + s->st |=3D NPCM7XX_SMBST_SDAST; + if (s->st & NPCM7XX_SMBCTL1_ACK) { + trace_npcm7xx_smbus_nack(DEVICE(s)->canonical_path); + i2c_nack(s->bus); + s->st &=3D NPCM7XX_SMBCTL1_ACK; + } + trace_npcm7xx_smbus_recv_byte((DEVICE(s)->canonical_path), s->sda); + npcm7xx_smbus_update_irq(s); +} + +static void npcm7xx_smbus_start(NPCM7xxSMBusState *s) +{ + /* + * We can start the bus if one of these is true: + * 1. The bus is idle (so we can request it) + * 2. We are the occupier (it's a repeated start condition.) + */ + int available =3D !i2c_bus_busy(s->bus) || + s->status !=3D NPCM7XX_SMBUS_STATUS_IDLE; + + if (available) { + s->st |=3D NPCM7XX_SMBST_MODE | NPCM7XX_SMBST_XMIT | NPCM7XX_SMBST= _SDAST; + s->cst |=3D NPCM7XX_SMBCST_BUSY; + } else { + s->st &=3D ~NPCM7XX_SMBST_MODE; + s->cst &=3D ~NPCM7XX_SMBCST_BUSY; + s->st |=3D NPCM7XX_SMBST_BER; + } + + trace_npcm7xx_smbus_start(DEVICE(s)->canonical_path, available); + s->cst |=3D NPCM7XX_SMBCST_BB; + s->status =3D NPCM7XX_SMBUS_STATUS_IDLE; + npcm7xx_smbus_update_irq(s); +} + +static void npcm7xx_smbus_send_address(NPCM7xxSMBusState *s, uint8_t value) +{ + int recv; + int rv; + + recv =3D value & BIT(0); + rv =3D i2c_start_transfer(s->bus, value >> 1, recv); + trace_npcm7xx_smbus_send_address(DEVICE(s)->canonical_path, + value >> 1, recv, !rv); + if (rv) { + qemu_log_mask(LOG_GUEST_ERROR, + "%s: requesting i2c bus for 0x%02x failed: %d\n", + DEVICE(s)->canonical_path, value, rv); + /* Failed to start transfer. NACK to reject.*/ + if (recv) { + s->st &=3D ~NPCM7XX_SMBST_XMIT; + } else { + s->st |=3D NPCM7XX_SMBST_XMIT; + } + npcm7xx_smbus_nack(s); + npcm7xx_smbus_update_irq(s); + return; + } + + s->st &=3D ~NPCM7XX_SMBST_NEGACK; + if (recv) { + s->status =3D NPCM7XX_SMBUS_STATUS_RECEIVING; + s->st &=3D ~NPCM7XX_SMBST_XMIT; + } else { + s->status =3D NPCM7XX_SMBUS_STATUS_SENDING; + s->st |=3D NPCM7XX_SMBST_XMIT; + } + + if (s->ctl1 & NPCM7XX_SMBCTL1_STASTRE) { + s->st |=3D NPCM7XX_SMBST_STASTR; + if (!recv) { + s->st |=3D NPCM7XX_SMBST_SDAST; + } + } else if (recv) { + npcm7xx_smbus_recv_byte(s); + } + npcm7xx_smbus_update_irq(s); +} + +static void npcm7xx_smbus_execute_stop(NPCM7xxSMBusState *s) +{ + i2c_end_transfer(s->bus); + s->st =3D 0; + s->cst =3D 0; + s->status =3D NPCM7XX_SMBUS_STATUS_IDLE; + s->cst3 |=3D NPCM7XX_SMBCST3_EO_BUSY; + trace_npcm7xx_smbus_stop(DEVICE(s)->canonical_path); + npcm7xx_smbus_update_irq(s); +} + + +static void npcm7xx_smbus_stop(NPCM7xxSMBusState *s) +{ + if (s->st & NPCM7XX_SMBST_MODE) { + switch (s->status) { + case NPCM7XX_SMBUS_STATUS_RECEIVING: + case NPCM7XX_SMBUS_STATUS_STOPPING_LAST_RECEIVE: + s->status =3D NPCM7XX_SMBUS_STATUS_STOPPING_LAST_RECEIVE; + break; + + case NPCM7XX_SMBUS_STATUS_NEGACK: + s->status =3D NPCM7XX_SMBUS_STATUS_STOPPING_NEGACK; + break; + + default: + npcm7xx_smbus_execute_stop(s); + break; + } + } +} + +static uint8_t npcm7xx_smbus_read_sda(NPCM7xxSMBusState *s) +{ + uint8_t value =3D s->sda; + + switch (s->status) { + case NPCM7XX_SMBUS_STATUS_STOPPING_LAST_RECEIVE: + npcm7xx_smbus_execute_stop(s); + break; + + case NPCM7XX_SMBUS_STATUS_RECEIVING: + npcm7xx_smbus_recv_byte(s); + break; + + default: + /* Do nothing */ + break; + } + + return value; +} + +static void npcm7xx_smbus_write_sda(NPCM7xxSMBusState *s, uint8_t value) +{ + s->sda =3D value; + if (s->st & NPCM7XX_SMBST_MODE) { + switch (s->status) { + case NPCM7XX_SMBUS_STATUS_IDLE: + npcm7xx_smbus_send_address(s, value); + break; + case NPCM7XX_SMBUS_STATUS_SENDING: + npcm7xx_smbus_send_byte(s, value); + break; + default: + qemu_log_mask(LOG_GUEST_ERROR, + "%s: write to SDA in invalid status %d: %u\n", + DEVICE(s)->canonical_path, s->status, value); + break; + } + } +} + +static void npcm7xx_smbus_write_st(NPCM7xxSMBusState *s, uint8_t value) +{ + s->st =3D WRITE_ONE_CLEAR(s->st, value, NPCM7XX_SMBST_STP); + s->st =3D WRITE_ONE_CLEAR(s->st, value, NPCM7XX_SMBST_BER); + s->st =3D WRITE_ONE_CLEAR(s->st, value, NPCM7XX_SMBST_STASTR); + s->st =3D WRITE_ONE_CLEAR(s->st, value, NPCM7XX_SMBST_NMATCH); + + if (value & NPCM7XX_SMBST_NEGACK) { + s->st &=3D ~NPCM7XX_SMBST_NEGACK; + if (s->status =3D=3D NPCM7XX_SMBUS_STATUS_STOPPING_NEGACK) { + npcm7xx_smbus_execute_stop(s); + } + } + + if (value & NPCM7XX_SMBST_STASTR && + s->status =3D=3D NPCM7XX_SMBUS_STATUS_RECEIVING) { + npcm7xx_smbus_recv_byte(s); + } + + npcm7xx_smbus_update_irq(s); +} + +static void npcm7xx_smbus_write_cst(NPCM7xxSMBusState *s, uint8_t value) +{ + uint8_t new_value =3D s->cst; + + s->cst =3D WRITE_ONE_CLEAR(new_value, value, NPCM7XX_SMBCST_BB); + npcm7xx_smbus_update_irq(s); +} + +static void npcm7xx_smbus_write_cst3(NPCM7xxSMBusState *s, uint8_t value) +{ + s->cst3 =3D WRITE_ONE_CLEAR(s->cst3, value, NPCM7XX_SMBCST3_EO_BUSY); + npcm7xx_smbus_update_irq(s); +} + +static void npcm7xx_smbus_write_ctl1(NPCM7xxSMBusState *s, uint8_t value) +{ + s->ctl1 =3D KEEP_OLD_BIT(s->ctl1, value, + NPCM7XX_SMBCTL1_START | NPCM7XX_SMBCTL1_STOP | NPCM7XX_SMBCTL1= _ACK); + + if (value & NPCM7XX_SMBCTL1_START) { + npcm7xx_smbus_start(s); + } + + if (value & NPCM7XX_SMBCTL1_STOP) { + npcm7xx_smbus_stop(s); + } + + npcm7xx_smbus_update_irq(s); +} + +static void npcm7xx_smbus_write_ctl2(NPCM7xxSMBusState *s, uint8_t value) +{ + s->ctl2 =3D value; + + if (!NPCM7XX_SMBUS_ENABLED(s)) { + /* Disable this SMBus module. */ + s->ctl1 =3D 0; + s->st =3D 0; + s->cst3 =3D s->cst3 & (~NPCM7XX_SMBCST3_EO_BUSY); + s->cst =3D 0; + } +} + +static void npcm7xx_smbus_write_ctl3(NPCM7xxSMBusState *s, uint8_t value) +{ + uint8_t old_ctl3 =3D s->ctl3; + + /* Write to SDA and SCL bits are ignored. */ + s->ctl3 =3D KEEP_OLD_BIT(old_ctl3, value, + NPCM7XX_SMBCTL3_SCL_LVL | NPCM7XX_SMBCTL3_SDA_= LVL); +} + +static uint64_t npcm7xx_smbus_read(void *opaque, hwaddr offset, unsigned s= ize) +{ + NPCM7xxSMBusState *s =3D opaque; + uint64_t value =3D 0; + uint8_t bank =3D s->ctl3 & NPCM7XX_SMBCTL3_BNK_SEL; + + switch (offset) { + case NPCM7XX_SMB_SDA: + value =3D npcm7xx_smbus_read_sda(s); + break; + + case NPCM7XX_SMB_ST: + value =3D s->st; + break; + + case NPCM7XX_SMB_CST: + value =3D s->cst; + break; + + case NPCM7XX_SMB_CTL1: + value =3D s->ctl1; + break; + + case NPCM7XX_SMB_ADDR1: + value =3D s->addr[0]; + break; + + case NPCM7XX_SMB_CTL2: + value =3D s->ctl2; + break; + + case NPCM7XX_SMB_ADDR2: + value =3D s->addr[1]; + break; + + case NPCM7XX_SMB_CTL3: + value =3D s->ctl3; + break; + + case NPCM7XX_SMB_CST2: + value =3D s->cst2; + break; + + case NPCM7XX_SMB_CST3: + value =3D s->cst3; + break; + + case NPCM7XX_SMB_VER: + value =3D npcm7xx_smbus_get_version(); + break; + + /* This register is either invalid or banked at this point. */ + default: + if (bank) { + /* Bank 1 */ + qemu_log_mask(LOG_GUEST_ERROR, + "%s: read from invalid offset 0x%" HWADDR_PRIx "\n", + DEVICE(s)->canonical_path, offset); + } else { + /* Bank 0 */ + switch (offset) { + case NPCM7XX_SMB_ADDR3: + value =3D s->addr[2]; + break; + + case NPCM7XX_SMB_ADDR7: + value =3D s->addr[6]; + break; + + case NPCM7XX_SMB_ADDR4: + value =3D s->addr[3]; + break; + + case NPCM7XX_SMB_ADDR8: + value =3D s->addr[7]; + break; + + case NPCM7XX_SMB_ADDR5: + value =3D s->addr[4]; + break; + + case NPCM7XX_SMB_ADDR9: + value =3D s->addr[8]; + break; + + case NPCM7XX_SMB_ADDR6: + value =3D s->addr[5]; + break; + + case NPCM7XX_SMB_ADDR10: + value =3D s->addr[9]; + break; + + case NPCM7XX_SMB_CTL4: + value =3D s->ctl4; + break; + + case NPCM7XX_SMB_CTL5: + value =3D s->ctl5; + break; + + case NPCM7XX_SMB_SCLLT: + value =3D s->scllt; + break; + + case NPCM7XX_SMB_SCLHT: + value =3D s->sclht; + break; + + default: + qemu_log_mask(LOG_GUEST_ERROR, + "%s: read from invalid offset 0x%" HWADDR_PRIx "\n= ", + DEVICE(s)->canonical_path, offset); + break; + } + } + break; + } + + trace_npcm7xx_smbus_read(DEVICE(s)->canonical_path, offset, value, siz= e); + + return value; +} + +static void npcm7xx_smbus_write(void *opaque, hwaddr offset, uint64_t valu= e, + unsigned size) +{ + NPCM7xxSMBusState *s =3D opaque; + uint8_t bank =3D s->ctl3 & NPCM7XX_SMBCTL3_BNK_SEL; + + trace_npcm7xx_smbus_write(DEVICE(s)->canonical_path, offset, value, si= ze); + + switch (offset) { + case NPCM7XX_SMB_SDA: + npcm7xx_smbus_write_sda(s, value); + break; + + case NPCM7XX_SMB_ST: + npcm7xx_smbus_write_st(s, value); + break; + + case NPCM7XX_SMB_CST: + npcm7xx_smbus_write_cst(s, value); + break; + + case NPCM7XX_SMB_CTL1: + npcm7xx_smbus_write_ctl1(s, value); + break; + + case NPCM7XX_SMB_ADDR1: + s->addr[0] =3D value; + break; + + case NPCM7XX_SMB_CTL2: + npcm7xx_smbus_write_ctl2(s, value); + break; + + case NPCM7XX_SMB_ADDR2: + s->addr[1] =3D value; + break; + + case NPCM7XX_SMB_CTL3: + npcm7xx_smbus_write_ctl3(s, value); + break; + + case NPCM7XX_SMB_CST2: + qemu_log_mask(LOG_GUEST_ERROR, + "%s: write to read-only reg: offset 0x%" HWADDR_PRIx "\n", + DEVICE(s)->canonical_path, offset); + break; + + case NPCM7XX_SMB_CST3: + npcm7xx_smbus_write_cst3(s, value); + break; + + case NPCM7XX_SMB_VER: + qemu_log_mask(LOG_GUEST_ERROR, + "%s: write to read-only reg: offset 0x%" HWADDR_PRIx "\n", + DEVICE(s)->canonical_path, offset); + break; + + /* This register is either invalid or banked at this point. */ + default: + if (bank) { + /* Bank 1 */ + qemu_log_mask(LOG_GUEST_ERROR, + "%s: write to invalid offset 0x%" HWADDR_PRIx "\n", + DEVICE(s)->canonical_path, offset); + } else { + /* Bank 0 */ + switch (offset) { + case NPCM7XX_SMB_ADDR3: + s->addr[2] =3D value; + break; + + case NPCM7XX_SMB_ADDR7: + s->addr[6] =3D value; + break; + + case NPCM7XX_SMB_ADDR4: + s->addr[3] =3D value; + break; + + case NPCM7XX_SMB_ADDR8: + s->addr[7] =3D value; + break; + + case NPCM7XX_SMB_ADDR5: + s->addr[4] =3D value; + break; + + case NPCM7XX_SMB_ADDR9: + s->addr[8] =3D value; + break; + + case NPCM7XX_SMB_ADDR6: + s->addr[5] =3D value; + break; + + case NPCM7XX_SMB_ADDR10: + s->addr[9] =3D value; + break; + + case NPCM7XX_SMB_CTL4: + s->ctl4 =3D value; + break; + + case NPCM7XX_SMB_CTL5: + s->ctl5 =3D value; + break; + + case NPCM7XX_SMB_SCLLT: + s->scllt =3D value; + break; + + case NPCM7XX_SMB_SCLHT: + s->sclht =3D value; + break; + + default: + qemu_log_mask(LOG_GUEST_ERROR, + "%s: write to invalid offset 0x%" HWADDR_PRIx "\n", + DEVICE(s)->canonical_path, offset); + break; + } + } + break; + } +} + +static const MemoryRegionOps npcm7xx_smbus_ops =3D { + .read =3D npcm7xx_smbus_read, + .write =3D npcm7xx_smbus_write, + .endianness =3D DEVICE_LITTLE_ENDIAN, + .valid =3D { + .min_access_size =3D 1, + .max_access_size =3D 1, + .unaligned =3D false, + }, +}; + +static void npcm7xx_smbus_enter_reset(Object *obj, ResetType type) +{ + NPCM7xxSMBusState *s =3D NPCM7XX_SMBUS(obj); + + s->st =3D NPCM7XX_SMB_ST_INIT_VAL; + s->cst =3D NPCM7XX_SMB_CST_INIT_VAL; + s->cst2 =3D NPCM7XX_SMB_CST2_INIT_VAL; + s->cst3 =3D NPCM7XX_SMB_CST3_INIT_VAL; + s->ctl1 =3D NPCM7XX_SMB_CTL1_INIT_VAL; + s->ctl2 =3D NPCM7XX_SMB_CTL2_INIT_VAL; + s->ctl3 =3D NPCM7XX_SMB_CTL3_INIT_VAL; + s->ctl4 =3D NPCM7XX_SMB_CTL4_INIT_VAL; + s->ctl5 =3D NPCM7XX_SMB_CTL5_INIT_VAL; + + for (int i =3D 0; i < NPCM7XX_SMBUS_NR_ADDRS; ++i) { + s->addr[i] =3D NPCM7XX_SMB_ADDR_INIT_VAL; + } + s->scllt =3D NPCM7XX_SMB_SCLLT_INIT_VAL; + s->sclht =3D NPCM7XX_SMB_SCLHT_INIT_VAL; + + s->status =3D NPCM7XX_SMBUS_STATUS_IDLE; +} + +static void npcm7xx_smbus_hold_reset(Object *obj) +{ + NPCM7xxSMBusState *s =3D NPCM7XX_SMBUS(obj); + + qemu_irq_lower(s->irq); +} + +static void npcm7xx_smbus_init(Object *obj) +{ + NPCM7xxSMBusState *s =3D NPCM7XX_SMBUS(obj); + SysBusDevice *sbd =3D SYS_BUS_DEVICE(obj); + + sysbus_init_irq(sbd, &s->irq); + memory_region_init_io(&s->iomem, obj, &npcm7xx_smbus_ops, s, + "regs", 4 * KiB); + sysbus_init_mmio(sbd, &s->iomem); + + s->bus =3D i2c_init_bus(DEVICE(s), "i2c-bus"); + s->status =3D NPCM7XX_SMBUS_STATUS_IDLE; +} + +static const VMStateDescription vmstate_npcm7xx_smbus =3D { + .name =3D "npcm7xx-smbus", + .version_id =3D 0, + .minimum_version_id =3D 0, + .fields =3D (VMStateField[]) { + VMSTATE_END_OF_LIST(), + }, +}; + +static void npcm7xx_smbus_class_init(ObjectClass *klass, void *data) +{ + ResettableClass *rc =3D RESETTABLE_CLASS(klass); + DeviceClass *dc =3D DEVICE_CLASS(klass); + + dc->desc =3D "NPCM7xx System Management Bus"; + dc->vmsd =3D &vmstate_npcm7xx_smbus; + rc->phases.enter =3D npcm7xx_smbus_enter_reset; + rc->phases.hold =3D npcm7xx_smbus_hold_reset; +} + +static const TypeInfo npcm7xx_smbus_types[] =3D { + { + .name =3D TYPE_NPCM7XX_SMBUS, + .parent =3D TYPE_SYS_BUS_DEVICE, + .instance_size =3D sizeof(NPCM7xxSMBusState), + .class_init =3D npcm7xx_smbus_class_init, + .instance_init =3D npcm7xx_smbus_init, + }, +}; +DEFINE_TYPES(npcm7xx_smbus_types); diff --git a/hw/i2c/trace-events b/hw/i2c/trace-events index 08db8fa689..c3bb70ad04 100644 --- a/hw/i2c/trace-events +++ b/hw/i2c/trace-events @@ -14,3 +14,14 @@ aspeed_i2c_bus_read(uint32_t busid, uint64_t offset, uns= igned size, uint64_t val aspeed_i2c_bus_write(uint32_t busid, uint64_t offset, unsigned size, uint6= 4_t value) "bus[%d]: To 0x%" PRIx64 " of size %u: 0x%" PRIx64 aspeed_i2c_bus_send(const char *mode, int i, int count, uint8_t byte) "%s = send %d/%d 0x%02x" aspeed_i2c_bus_recv(const char *mode, int i, int count, uint8_t byte) "%s = recv %d/%d 0x%02x" + +# npcm7xx_smbus.c + +npcm7xx_smbus_read(const char *id, uint64_t offset, uint64_t value, unsign= ed size) "%s offset: 0x%04" PRIx64 " value: 0x%02" PRIx64 " size: %u" +npcm7xx_smbus_write(const char *id, uint64_t offset, uint64_t value, unsig= ned size) "%s offset: 0x%04" PRIx64 " value: 0x%02" PRIx64 " size: %u" +npcm7xx_smbus_start(const char *id, int success) "%s starting, success: %d" +npcm7xx_smbus_send_address(const char *id, uint8_t addr, int recv, int suc= cess) "%s sending address: 0x%02x, recv: %d, success: %d" +npcm7xx_smbus_send_byte(const char *id, uint8_t value, int success) "%s se= nd byte: 0x%02x, success: %d" +npcm7xx_smbus_recv_byte(const char *id, uint8_t value) "%s recv byte: 0x%0= 2x" +npcm7xx_smbus_stop(const char *id) "%s stopping" +npcm7xx_smbus_nack(const char *id) "%s nacking" diff --git a/include/hw/arm/npcm7xx.h b/include/hw/arm/npcm7xx.h index f6227aa8aa..cea1bd1f62 100644 --- a/include/hw/arm/npcm7xx.h +++ b/include/hw/arm/npcm7xx.h @@ -20,6 +20,7 @@ #include "hw/adc/npcm7xx_adc.h" #include "hw/cpu/a9mpcore.h" #include "hw/gpio/npcm7xx_gpio.h" +#include "hw/i2c/npcm7xx_smbus.h" #include "hw/mem/npcm7xx_mc.h" #include "hw/misc/npcm7xx_clk.h" #include "hw/misc/npcm7xx_gcr.h" @@ -85,6 +86,7 @@ typedef struct NPCM7xxState { NPCM7xxMCState mc; NPCM7xxRNGState rng; NPCM7xxGPIOState gpio[8]; + NPCM7xxSMBusState smbus[16]; EHCISysBusState ehci; OHCISysBusState ohci; NPCM7xxFIUState fiu[2]; diff --git a/include/hw/i2c/npcm7xx_smbus.h b/include/hw/i2c/npcm7xx_smbus.h new file mode 100644 index 0000000000..b9761a6993 --- /dev/null +++ b/include/hw/i2c/npcm7xx_smbus.h @@ -0,0 +1,88 @@ +/* + * Nuvoton NPCM7xx SMBus Module. + * + * Copyright 2020 Google 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 WIT= HOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + */ +#ifndef NPCM7XX_SMBUS_H +#define NPCM7XX_SMBUS_H + +#include "exec/memory.h" +#include "hw/i2c/i2c.h" +#include "hw/irq.h" +#include "hw/sysbus.h" + +/* + * Number of addresses this module contains. Do not change this without + * incrementing the version_id in the vmstate. + */ +#define NPCM7XX_SMBUS_NR_ADDRS 10 + +typedef enum NPCM7xxSMBusStatus { + NPCM7XX_SMBUS_STATUS_IDLE, + NPCM7XX_SMBUS_STATUS_SENDING, + NPCM7XX_SMBUS_STATUS_RECEIVING, + NPCM7XX_SMBUS_STATUS_NEGACK, + NPCM7XX_SMBUS_STATUS_STOPPING_LAST_RECEIVE, + NPCM7XX_SMBUS_STATUS_STOPPING_NEGACK, +} NPCM7xxSMBusStatus; + +/* + * struct NPCM7xxSMBusState - System Management Bus device state. + * @bus: The underlying I2C Bus. + * @irq: GIC interrupt line to fire on events (if enabled). + * @sda: The serial data register. + * @st: The status register. + * @cst: The control status register. + * @cst2: The control status register 2. + * @cst3: The control status register 3. + * @ctl1: The control register 1. + * @ctl2: The control register 2. + * @ctl3: The control register 3. + * @ctl4: The control register 4. + * @ctl5: The control register 5. + * @addr: The SMBus module's own addresses on the I2C bus. + * @scllt: The SCL low time register. + * @sclht: The SCL high time register. + * @status: The current status of the SMBus. + */ +typedef struct NPCM7xxSMBusState { + SysBusDevice parent; + + MemoryRegion iomem; + + I2CBus *bus; + qemu_irq irq; + + uint8_t sda; + uint8_t st; + uint8_t cst; + uint8_t cst2; + uint8_t cst3; + uint8_t ctl1; + uint8_t ctl2; + uint8_t ctl3; + uint8_t ctl4; + uint8_t ctl5; + uint8_t addr[NPCM7XX_SMBUS_NR_ADDRS]; + + uint8_t scllt; + uint8_t sclht; + + NPCM7xxSMBusStatus status; +} NPCM7xxSMBusState; + +#define TYPE_NPCM7XX_SMBUS "npcm7xx-smbus" +#define NPCM7XX_SMBUS(obj) OBJECT_CHECK(NPCM7xxSMBusState, (obj), \ + TYPE_NPCM7XX_SMBUS) + +#endif /* NPCM7XX_SMBUS_H */ --=20 2.30.0.365.g02bc693789-goog From nobody Fri May 17 03:39:49 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=nongnu.org ARC-Seal: i=1; a=rsa-sha256; t=1611689818; cv=none; d=zohomail.com; s=zohoarc; b=VpHeYFeLAeg8UGJqC1iWZteHoWg6pHkWMGqWw60Br5sz5FpDaBmlKkkFv3jM1ZeHyVZOieo1QwvdIhJvT+Sjblt8TGg0Zu0Rz8D97rotjS+bjJttPRJNwXYI11Yl0ASpDyfkeRSyhCJLT8SUvk7j5CabQbPXyWf1XXUEvm8S4Og= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1611689818; h=Content-Type:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Reply-To:References:Sender:Subject:To; bh=TkPdhZlOcZG5Fdm2RkKNjU1YYrH6WfIpfURge5GDGkw=; b=EnTDrLDiO2JAv9oYVuwQ1hpb7Nai9OaO6A+WmDnVXbPBgvILbdoQrTpvIBcXSIqyKrfa90qSTEPFbzHJpKoc/7Ig1ClEDWPNCukHM5oFT4TlAiubumSeXzV+4ZU9YpToliBLC4+okiBHQ9doEwOYTlqsA+6RF2e46JNxCBu61CU= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1611689818437731.0018057394635; Tue, 26 Jan 2021 11:36:58 -0800 (PST) Received: from localhost ([::1]:42374 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1l4U91-0006pF-NY for importer@patchew.org; Tue, 26 Jan 2021 14:36:57 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:37034) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <3aW4QYAgKCo4ECzs6BAzy66y3w.u648w4C-vwDw3565y5C.69y@flex--wuhaotsh.bounces.google.com>) id 1l4U5N-0004Xm-Eb for qemu-devel@nongnu.org; Tue, 26 Jan 2021 14:33:09 -0500 Received: from mail-pl1-x64a.google.com ([2607:f8b0:4864:20::64a]:56034) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from <3aW4QYAgKCo4ECzs6BAzy66y3w.u648w4C-vwDw3565y5C.69y@flex--wuhaotsh.bounces.google.com>) id 1l4U5E-00047F-C8 for qemu-devel@nongnu.org; Tue, 26 Jan 2021 14:33:09 -0500 Received: by mail-pl1-x64a.google.com with SMTP id p19so10254719plr.22 for ; Tue, 26 Jan 2021 11:32:58 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:in-reply-to:message-id:mime-version:references:subject :from:to:cc; bh=TkPdhZlOcZG5Fdm2RkKNjU1YYrH6WfIpfURge5GDGkw=; b=M7P3/XUQeBVG/cW5rJU9Yr0tUJIVMs+ZlqEyePr843mKFj1hmEROk5fi3iXHOli5AE buZkLgwPGshDF+jl5HRrjmE3QWURe08ITLkijZ/qa9CR67bRkXQ8Ru87O1iGriGGkbOY /3XTJuutE+zHFTcyf0wtgDeqwhOovbx9+hp42D9McQlMq7ZwSY5bznEa7lb3P4Ey5z1K QSqI6G5FVzFUW/cNF7a4+BXeHeGJ7cycsLTLxGhsioZFj1INLY+H1qMLGyYvp/08tsk9 HAo6PWq5U5hc5ovmTCeqiSIJpSR896s7Z9Qb+TMlJN4ILDU61a9Jn/o1jW+92xGRUZWC W7fw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=TkPdhZlOcZG5Fdm2RkKNjU1YYrH6WfIpfURge5GDGkw=; b=JgH109pJH/j3rRLeA+z3XjZ5PfiOd8Sf7Yx/kRXXJHrI00MCw5UyMv2O95jZRwuB2F N7XhUkM0nvufoNXjo9G0SZpgar3clTmXe3dB3/vH568qAsDBWeFDCtpGs5cV+hq/sQ/z Mk7vOjhfQZtBEODk7wY/fLl0+IAJE2z6SXvjfFHj9GNucP7HfZvE7jp1CR25W6DRekBL e/oZy2awhJZ+8p9vwb7HDJpS6I4i/JlLFMHZAj73MiS1fCLb/KXaWpIm+GTIxg19APKf Z6Se+/9xn1wgscZe9xo7XmnL+bK8kx2L/Q6sF6ZNRoRck/Do55OR/62RGgyk00GVymYn rbRQ== X-Gm-Message-State: AOAM531ENJGWkFwF8coIhm0q/3niqCmy4G1/4qlX8bn9LB8c0E3F7WKr jSHc7hMb8SVy02sh6luxUkgbdlZLtwmw3Q== X-Google-Smtp-Source: ABdhPJxqNIGmOWP8qI6xUUOIL9gu+E6a0lpMxcxlJK5JtNq8foEE/RS89Eg66M45BLPS0pdI5E4UUKq5cFBG/w== X-Received: from mimik.c.googlers.com ([fda3:e722:ac3:10:7f:e700:c0a8:4e]) (user=wuhaotsh job=sendgmr) by 2002:a17:902:9888:b029:dc:374:bc8b with SMTP id s8-20020a1709029888b02900dc0374bc8bmr7455068plp.60.1611689577066; Tue, 26 Jan 2021 11:32:57 -0800 (PST) Date: Tue, 26 Jan 2021 11:32:34 -0800 In-Reply-To: <20210126193237.1534208-1-wuhaotsh@google.com> Message-Id: <20210126193237.1534208-4-wuhaotsh@google.com> Mime-Version: 1.0 References: <20210126193237.1534208-1-wuhaotsh@google.com> X-Mailer: git-send-email 2.30.0.365.g02bc693789-goog Subject: [PATCH 3/6] hw/arm: Add I2C device tree for NPCM750 eval board To: peter.maydell@linaro.org Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::64a; envelope-from=3aW4QYAgKCo4ECzs6BAzy66y3w.u648w4C-vwDw3565y5C.69y@flex--wuhaotsh.bounces.google.com; helo=mail-pl1-x64a.google.com X-Spam_score_int: -95 X-Spam_score: -9.6 X-Spam_bar: --------- X-Spam_report: (-9.6 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_MED=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, USER_IN_DEF_DKIM_WL=-7.5 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: venture@google.com, hskinnemoen@google.com, qemu-devel@nongnu.org, wuhaotsh@google.com, kfting@nuvoton.com, qemu-arm@nongnu.org, Avi.Fishman@nuvoton.com, dje@google.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" Reply-to: Hao Wu From: wuhaotsh--- via X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add an I2C device tree for NPCM750 evaluation board. Reviewed-by: Doug Evans Reviewed-by: Tyrong Ting Signed-off-by: Hao Wu --- hw/arm/npcm7xx_boards.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/hw/arm/npcm7xx_boards.c b/hw/arm/npcm7xx_boards.c index 3fdd5cab01..2d82f48848 100644 --- a/hw/arm/npcm7xx_boards.c +++ b/hw/arm/npcm7xx_boards.c @@ -98,6 +98,20 @@ static NPCM7xxState *npcm7xx_create_soc(MachineState *ma= chine, return NPCM7XX(obj); } =20 +static I2CBus *npcm7xx_i2c_get_bus(NPCM7xxState *soc, uint32_t num) +{ + g_assert(num < ARRAY_SIZE(soc->smbus)); + return I2C_BUS(qdev_get_child_bus(DEVICE(&soc->smbus[num]), "i2c-bus")= ); +} + +static void npcm750_evb_i2c_init(NPCM7xxState *soc) +{ + i2c_slave_create_simple(npcm7xx_i2c_get_bus(soc, 0), "tmp105", 0x48); + i2c_slave_create_simple(npcm7xx_i2c_get_bus(soc, 1), "tmp105", 0x48); + i2c_slave_create_simple(npcm7xx_i2c_get_bus(soc, 2), "tmp105", 0x48); + i2c_slave_create_simple(npcm7xx_i2c_get_bus(soc, 6), "tmp105", 0x48); +} + static void npcm750_evb_init(MachineState *machine) { NPCM7xxState *soc; @@ -108,6 +122,7 @@ static void npcm750_evb_init(MachineState *machine) =20 npcm7xx_load_bootrom(machine, soc); npcm7xx_connect_flash(&soc->fiu[0], 0, "w25q256", drive_get(IF_MTD, 0,= 0)); + npcm750_evb_i2c_init(soc); npcm7xx_load_kernel(machine, soc); } =20 --=20 2.30.0.365.g02bc693789-goog From nobody Fri May 17 03:39:49 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=nongnu.org ARC-Seal: i=1; a=rsa-sha256; t=1611690119; cv=none; d=zohomail.com; s=zohoarc; b=gaG2JvDOjnZqQDLOKCKCQYH4ZyeB4uqFMzg+ahTgMtcft/gLfVbkvQPMJwL4JMIC0BQPvKrAdfa2tSk436WFYV+p5KdBKp5zyuzXPH1S3I+ipqE1jp1+UsG5iRxWVS8NccA/86I3Yr2bGlNo3XkiXA7J7y+51viZ3GzpsPbobZ4= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1611690119; h=Content-Type:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Reply-To:References:Sender:Subject:To; bh=0PFajRoJ1DQ0XYaobEENMylsgDeBQsfIucOzPRxM9DY=; b=jFCul8GFhmSmR8qLG7mvS2hHMPPsx/4iKMN1U5b1tJvcM6odPGfDmsAe9Ov34qZS9UsyvZF4QhNhnJQojsnXZA2DE7pZOH82SfrMNlJbDVpq7GXImqDjxe5KJiUYDPl8vk253hw5NDqs57OazDUVb2kIgEm5pXn36KvoCk4goRc= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 161169011974782.94515541229634; Tue, 26 Jan 2021 11:41:59 -0800 (PST) Received: from localhost ([::1]:55752 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1l4UDu-00042m-Dy for importer@patchew.org; Tue, 26 Jan 2021 14:41:58 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:37102) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <3am4QYAgKCo8FD0t7CB0z77z4x.v759x5D-wxEx4676z6D.7Az@flex--wuhaotsh.bounces.google.com>) id 1l4U5S-0004az-Rp for qemu-devel@nongnu.org; Tue, 26 Jan 2021 14:33:14 -0500 Received: from mail-pl1-x649.google.com ([2607:f8b0:4864:20::649]:37157) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from <3am4QYAgKCo8FD0t7CB0z77z4x.v759x5D-wxEx4676z6D.7Az@flex--wuhaotsh.bounces.google.com>) id 1l4U5H-00047b-Kt for qemu-devel@nongnu.org; Tue, 26 Jan 2021 14:33:14 -0500 Received: by mail-pl1-x649.google.com with SMTP id c5so10232119plr.4 for ; Tue, 26 Jan 2021 11:33:00 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:in-reply-to:message-id:mime-version:references:subject :from:to:cc; bh=0PFajRoJ1DQ0XYaobEENMylsgDeBQsfIucOzPRxM9DY=; b=Lh8Eael0nAszss1OY0l67Svp6F1n2VyjD/bI1A7HM60gbeSJW5wKy+FeAhzbWDdXo4 KginxIYrHRPxr3XKEjNEml+RjaOuFIYY0/TPW3HhkgnhLN1Ynj/NUn1BjGPGNBeuUys0 7g01SrQ5DZABfV61wnyDrfVfMVXKCQMX+0I2cUfyVyZZGOdFZa+vOeN77pRZR477/1Ml Unnt+BDYmwnJWUd5/NyrVyMbmVHfqyHJNK9UYIpFqcfFeIvegYMaBNiZkfavcWO5uTiU YKqjSqHMQI/dMD2FlUTxXF7418yIkY++rqZEsUkbE+Hb+OyqWpYlzaD1uaABpnPPUI1O BnSg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=0PFajRoJ1DQ0XYaobEENMylsgDeBQsfIucOzPRxM9DY=; b=C37DVAbM4pV8Bz8uJr5UHO6D+6rNIRKFAsDQY37P+eUmmQxiovz/8h9S4YClrew09E VBkLZvOz9OoXvwxL64o29QwVcHiUww+csXYgdHOFjC1Uxo8C5y18YJyzmpBUIxENJS+M dHG6hsWEZj/h4t7CrES6OKtYfqTif/EpOTs/MXEu61X6oSPoKBzE7jWLUaNX4HBm/ouw 8YrqJw/0JIXHxNw6ECyvBr6EoBgqL6GqBSnB5j0uArTB60aTDHAOw//Kx5WCNuPQlFXI NmNqGI35QTKVKPGEGjtGFqWZFXrUSVogKszx9pK0KgDFDRAfnIIFovy+xlp0Os8XQErd /NFA== X-Gm-Message-State: AOAM531JlbLwtiHg+jEvivMr7nBqkkA8LbCRx54hjt1/uTjU4r+HFykN v6UrOqSrgOE2nIsDV9va7bZzdCnnIv2fsw== X-Google-Smtp-Source: ABdhPJwOhdUp/Q1WXe5tIKS4zVq2fH0RBEO4XVSRcyi5BwLRgBSvGuRG4Le6jZk+OrmihfA3aAv3fvkZ5w/HMw== X-Received: from mimik.c.googlers.com ([fda3:e722:ac3:10:7f:e700:c0a8:4e]) (user=wuhaotsh job=sendgmr) by 2002:a05:6a00:15cc:b029:1ba:5282:3ab8 with SMTP id o12-20020a056a0015ccb02901ba52823ab8mr6612813pfu.77.1611689578626; Tue, 26 Jan 2021 11:32:58 -0800 (PST) Date: Tue, 26 Jan 2021 11:32:35 -0800 In-Reply-To: <20210126193237.1534208-1-wuhaotsh@google.com> Message-Id: <20210126193237.1534208-5-wuhaotsh@google.com> Mime-Version: 1.0 References: <20210126193237.1534208-1-wuhaotsh@google.com> X-Mailer: git-send-email 2.30.0.365.g02bc693789-goog Subject: [PATCH 4/6] hw/arm: Add I2C device tree for Quanta GSJ To: peter.maydell@linaro.org Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::649; envelope-from=3am4QYAgKCo8FD0t7CB0z77z4x.v759x5D-wxEx4676z6D.7Az@flex--wuhaotsh.bounces.google.com; helo=mail-pl1-x649.google.com X-Spam_score_int: -95 X-Spam_score: -9.6 X-Spam_bar: --------- X-Spam_report: (-9.6 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_MED=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, USER_IN_DEF_DKIM_WL=-7.5 autolearn=unavailable autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: venture@google.com, hskinnemoen@google.com, qemu-devel@nongnu.org, wuhaotsh@google.com, kfting@nuvoton.com, qemu-arm@nongnu.org, Avi.Fishman@nuvoton.com, dje@google.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" Reply-to: Hao Wu From: wuhaotsh--- via X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add an I2C device tree for Quanta GSJ. We only included devices with existing QEMU implementation, including AT24 EEPROM and temperature sensors. Reviewed-by: Doug Evans Reviewed-by: Tyrong Ting Signed-off-by: Hao Wu --- hw/arm/npcm7xx_boards.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/hw/arm/npcm7xx_boards.c b/hw/arm/npcm7xx_boards.c index 2d82f48848..1418629e06 100644 --- a/hw/arm/npcm7xx_boards.c +++ b/hw/arm/npcm7xx_boards.c @@ -19,6 +19,7 @@ #include "exec/address-spaces.h" #include "hw/arm/npcm7xx.h" #include "hw/core/cpu.h" +#include "hw/i2c/smbus_eeprom.h" #include "hw/loader.h" #include "hw/qdev-properties.h" #include "qapi/error.h" @@ -112,6 +113,21 @@ static void npcm750_evb_i2c_init(NPCM7xxState *soc) i2c_slave_create_simple(npcm7xx_i2c_get_bus(soc, 6), "tmp105", 0x48); } =20 +static void quanta_gsj_i2c_init(NPCM7xxState *soc) +{ + uint8_t *eeprom_buf0 =3D g_malloc0(32 * 1024); + uint8_t *eeprom_buf1 =3D g_malloc0(32 * 1024); + + i2c_slave_create_simple(npcm7xx_i2c_get_bus(soc, 1), "tmp105", 0x48); + i2c_slave_create_simple(npcm7xx_i2c_get_bus(soc, 2), "tmp105", 0x48); + i2c_slave_create_simple(npcm7xx_i2c_get_bus(soc, 3), "tmp105", 0x48); + i2c_slave_create_simple(npcm7xx_i2c_get_bus(soc, 4), "tmp105", 0x48); + smbus_eeprom_init_one(npcm7xx_i2c_get_bus(soc, 9), 0x55, eeprom_buf0); + smbus_eeprom_init_one(npcm7xx_i2c_get_bus(soc, 10), 0x55, eeprom_buf1); + + /* TODO: Add addtional i2c devices. */ +} + static void npcm750_evb_init(MachineState *machine) { NPCM7xxState *soc; @@ -137,6 +153,7 @@ static void quanta_gsj_init(MachineState *machine) npcm7xx_load_bootrom(machine, soc); npcm7xx_connect_flash(&soc->fiu[0], 0, "mx25l25635e", drive_get(IF_MTD, 0, 0)); + quanta_gsj_i2c_init(soc); npcm7xx_load_kernel(machine, soc); } =20 --=20 2.30.0.365.g02bc693789-goog From nobody Fri May 17 03:39:49 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=nongnu.org ARC-Seal: i=1; a=rsa-sha256; t=1611689928; cv=none; d=zohomail.com; s=zohoarc; b=HJUIHSqt6oMkYSchtBAmiHX4emDOwn0uY9FN8gcDa9rE4DCI7kaVAtMBpfA3gb+TSeP3gyHJNsa6xnBd81nDEESSNYJI45OfZEl71daXGTPHT43Myftk+DtvjMoIrG+DGGwO7DTvJVJvX24C3DjhkmBav+nzskkagr1cXH8kzQA= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1611689928; h=Content-Type:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Reply-To:References:Sender:Subject:To; bh=PDVjhBTkNEN6+4rAJ7Cd8nEPSfTjViQIWXCbv9mKhXE=; b=m7YpcCwSA0krUZdxrfmmXjoZLfseW8FyrXnsQcajHzDrge1Tqgyob2osbDFe+asn+5c3UgobMOfFUTxfPs9ndGT71uhZniiocFCEy1J6BM7GfIghdKz7mAEKQ60q7m3YeMxoYA4QfAf45oL/zha3EDNnDJtL/F907h4C4fLuXTA= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1611689928633818.0025831175582; Tue, 26 Jan 2021 11:38:48 -0800 (PST) Received: from localhost ([::1]:48618 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1l4UAp-0000yY-I8 for importer@patchew.org; Tue, 26 Jan 2021 14:38:47 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:37098) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <3bG4QYAgKCpEHF2v9ED219916z.x97Bz7F-yzGz689818F.9C1@flex--wuhaotsh.bounces.google.com>) id 1l4U5S-0004an-MZ for qemu-devel@nongnu.org; Tue, 26 Jan 2021 14:33:14 -0500 Received: from mail-pj1-x1049.google.com ([2607:f8b0:4864:20::1049]:33474) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from <3bG4QYAgKCpEHF2v9ED219916z.x97Bz7F-yzGz689818F.9C1@flex--wuhaotsh.bounces.google.com>) id 1l4U5H-00048Y-F3 for qemu-devel@nongnu.org; Tue, 26 Jan 2021 14:33:14 -0500 Received: by mail-pj1-x1049.google.com with SMTP id q10so2134039pjd.0 for ; Tue, 26 Jan 2021 11:33:01 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:in-reply-to:message-id:mime-version:references:subject :from:to:cc; bh=PDVjhBTkNEN6+4rAJ7Cd8nEPSfTjViQIWXCbv9mKhXE=; b=M1LllxfDTd2UMzO7Ci2xDOU/L/dxjF6Jtosxf5YilU8axMlt3eaA2vfj6EyzbNgr77 W7qaRoYVOyJzaYchOYiuDqncYuXCAtBr1+isPmmLhUoYwEyS6SH0v3T3xGzb4Qercoh2 SeSu56g3zserLVJ12h1S01oU16fBTwdiI+Al2EoJoXidWG4R6qezCLy37LfajbdN9bHu THMD5d/KySf80pd09+olcwbmtDQ6DVG96gklFHsGjct9IzvHPvzK1R/GZj7kgU33Zy3/ CSaUrZfhgf4o+97zj2ydFbs9y8BisU3MYw6jepWluqkDP8Wwzmo+r/DY1Wm4lSvFGhid 6XOA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=PDVjhBTkNEN6+4rAJ7Cd8nEPSfTjViQIWXCbv9mKhXE=; b=tj4Hdnv63ZdkvffQEreouovRPkJG+weH9j8W0+t3uubs15XGAimVemFkPx+8XmwFHw IkzALYOS/PNextGrk/icUnz2z341/Lqsat6MeD8NzkfojXWD6CRzuZiR2yk3smgGuuBT iZMPG5WnH7XxhXnVTvNpVTO8P1VIwwa36rZSvJIPx4wfi73imOvmrjrAIvtrRbZIAjKo TSp1zxCICMNG1OEQbKQVYwKNZwKnt/3MarESCmP/C8RiNY30rvl8nEViS93eXmIZM1Up SRuW/9yH5HAZh9kP2hVEuSNJZgDVQRehncWy7HfwDs7SIzHrF/FMXUMhfs3gg85G5SHN rI9Q== X-Gm-Message-State: AOAM531qH5YzwGaqryIF5oZuDdliQ20DA+4MkhJzAdUbZ8znD9FxFg2L GRe2uqjoto0+3/1v565zqcdVlyJ4KZ5y/Q== X-Google-Smtp-Source: ABdhPJw/s/uLOIg7QdGLtXGWeGr6Oo1rN/cqgWatY2qagZHONQmI08KHANe9OGDAkpVrSvJxj4vqG3kU4wvpeQ== X-Received: from mimik.c.googlers.com ([fda3:e722:ac3:10:7f:e700:c0a8:4e]) (user=wuhaotsh job=sendgmr) by 2002:a17:902:e5cc:b029:df:bc77:3aba with SMTP id u12-20020a170902e5ccb02900dfbc773abamr7503516plf.72.1611689580298; Tue, 26 Jan 2021 11:33:00 -0800 (PST) Date: Tue, 26 Jan 2021 11:32:36 -0800 In-Reply-To: <20210126193237.1534208-1-wuhaotsh@google.com> Message-Id: <20210126193237.1534208-6-wuhaotsh@google.com> Mime-Version: 1.0 References: <20210126193237.1534208-1-wuhaotsh@google.com> X-Mailer: git-send-email 2.30.0.365.g02bc693789-goog Subject: [PATCH 5/6] hw/i2c: Add a QTest for NPCM7XX SMBus Device To: peter.maydell@linaro.org Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::1049; envelope-from=3bG4QYAgKCpEHF2v9ED219916z.x97Bz7F-yzGz689818F.9C1@flex--wuhaotsh.bounces.google.com; helo=mail-pj1-x1049.google.com X-Spam_score_int: -95 X-Spam_score: -9.6 X-Spam_bar: --------- X-Spam_report: (-9.6 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_MED=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, USER_IN_DEF_DKIM_WL=-7.5 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: venture@google.com, hskinnemoen@google.com, qemu-devel@nongnu.org, wuhaotsh@google.com, kfting@nuvoton.com, qemu-arm@nongnu.org, Avi.Fishman@nuvoton.com, dje@google.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" Reply-to: Hao Wu From: wuhaotsh--- via X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This patch adds a QTest for NPCM7XX SMBus's single byte mode. It sends a byte to a device in the evaluation board, and verify the retrieved value is equivalent to the sent value. Reviewed-by: Doug Evans Reviewed-by: Tyrong Ting Signed-off-by: Hao Wu --- tests/qtest/meson.build | 1 + tests/qtest/npcm7xx_smbus-test.c | 352 +++++++++++++++++++++++++++++++ 2 files changed, 353 insertions(+) create mode 100644 tests/qtest/npcm7xx_smbus-test.c diff --git a/tests/qtest/meson.build b/tests/qtest/meson.build index 16d04625b8..aa62d59817 100644 --- a/tests/qtest/meson.build +++ b/tests/qtest/meson.build @@ -138,6 +138,7 @@ qtests_npcm7xx =3D \ 'npcm7xx_gpio-test', 'npcm7xx_pwm-test', 'npcm7xx_rng-test', + 'npcm7xx_smbus-test', 'npcm7xx_timer-test', 'npcm7xx_watchdog_timer-test'] qtests_arm =3D \ diff --git a/tests/qtest/npcm7xx_smbus-test.c b/tests/qtest/npcm7xx_smbus-t= est.c new file mode 100644 index 0000000000..4594b107df --- /dev/null +++ b/tests/qtest/npcm7xx_smbus-test.c @@ -0,0 +1,352 @@ +/* + * QTests for Nuvoton NPCM7xx SMBus Modules. + * + * Copyright 2020 Google 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 WIT= HOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + */ + +#include "qemu/osdep.h" +#include "qemu/bitops.h" +#include "libqos/i2c.h" +#include "libqos/libqtest.h" +#include "hw/misc/tmp105_regs.h" + +#define NR_SMBUS_DEVICES 16 +#define SMBUS_ADDR(x) (0xf0080000 + 0x1000 * (x)) +#define SMBUS_IRQ(x) (64 + (x)) + +#define EVB_DEVICE_ADDR 0x48 +#define INVALID_DEVICE_ADDR 0x01 + +const int evb_bus_list[] =3D {0, 1, 2, 6}; + +/* Offsets */ +enum CommonRegister { + OFFSET_SDA =3D 0x0, + OFFSET_ST =3D 0x2, + OFFSET_CST =3D 0x4, + OFFSET_CTL1 =3D 0x6, + OFFSET_ADDR1 =3D 0x8, + OFFSET_CTL2 =3D 0xa, + OFFSET_ADDR2 =3D 0xc, + OFFSET_CTL3 =3D 0xe, + OFFSET_CST2 =3D 0x18, + OFFSET_CST3 =3D 0x19, +}; + +enum NPCM7xxSMBusBank0Register { + OFFSET_ADDR3 =3D 0x10, + OFFSET_ADDR7 =3D 0x11, + OFFSET_ADDR4 =3D 0x12, + OFFSET_ADDR8 =3D 0x13, + OFFSET_ADDR5 =3D 0x14, + OFFSET_ADDR9 =3D 0x15, + OFFSET_ADDR6 =3D 0x16, + OFFSET_ADDR10 =3D 0x17, + OFFSET_CTL4 =3D 0x1a, + OFFSET_CTL5 =3D 0x1b, + OFFSET_SCLLT =3D 0x1c, + OFFSET_FIF_CTL =3D 0x1d, + OFFSET_SCLHT =3D 0x1e, +}; + +enum NPCM7xxSMBusBank1Register { + OFFSET_FIF_CTS =3D 0x10, + OFFSET_FAIR_PER =3D 0x11, + OFFSET_TXF_CTL =3D 0x12, + OFFSET_T_OUT =3D 0x14, + OFFSET_TXF_STS =3D 0x1a, + OFFSET_RXF_STS =3D 0x1c, + OFFSET_RXF_CTL =3D 0x1e, +}; + +/* ST fields */ +#define ST_STP BIT(7) +#define ST_SDAST BIT(6) +#define ST_BER BIT(5) +#define ST_NEGACK BIT(4) +#define ST_STASTR BIT(3) +#define ST_NMATCH BIT(2) +#define ST_MODE BIT(1) +#define ST_XMIT BIT(0) + +/* CST fields */ +#define CST_ARPMATCH BIT(7) +#define CST_MATCHAF BIT(6) +#define CST_TGSCL BIT(5) +#define CST_TSDA BIT(4) +#define CST_GCMATCH BIT(3) +#define CST_MATCH BIT(2) +#define CST_BB BIT(1) +#define CST_BUSY BIT(0) + +/* CST2 fields */ +#define CST2_INSTTS BIT(7) +#define CST2_MATCH7F BIT(6) +#define CST2_MATCH6F BIT(5) +#define CST2_MATCH5F BIT(4) +#define CST2_MATCH4F BIT(3) +#define CST2_MATCH3F BIT(2) +#define CST2_MATCH2F BIT(1) +#define CST2_MATCH1F BIT(0) + +/* CST3 fields */ +#define CST3_EO_BUSY BIT(7) +#define CST3_MATCH10F BIT(2) +#define CST3_MATCH9F BIT(1) +#define CST3_MATCH8F BIT(0) + +/* CTL1 fields */ +#define CTL1_STASTRE BIT(7) +#define CTL1_NMINTE BIT(6) +#define CTL1_GCMEN BIT(5) +#define CTL1_ACK BIT(4) +#define CTL1_EOBINTE BIT(3) +#define CTL1_INTEN BIT(2) +#define CTL1_STOP BIT(1) +#define CTL1_START BIT(0) + +/* CTL2 fields */ +#define CTL2_SCLFRQ(rv) extract8((rv), 1, 6) +#define CTL2_ENABLE BIT(0) + +/* CTL3 fields */ +#define CTL3_SCL_LVL BIT(7) +#define CTL3_SDA_LVL BIT(6) +#define CTL3_BNK_SEL BIT(5) +#define CTL3_400K_MODE BIT(4) +#define CTL3_IDL_START BIT(3) +#define CTL3_ARPMEN BIT(2) +#define CTL3_SCLFRQ(rv) extract8((rv), 0, 2) + +/* ADDR fields */ +#define ADDR_EN BIT(7) +#define ADDR_A(rv) extract8((rv), 0, 6) + + +static void check_running(QTestState *qts, uint64_t base_addr) +{ + g_assert_true(qtest_readb(qts, base_addr + OFFSET_CST) & CST_BUSY); + g_assert_true(qtest_readb(qts, base_addr + OFFSET_CST) & CST_BB); +} + +static void check_stopped(QTestState *qts, uint64_t base_addr) +{ + uint8_t cst3; + + g_assert_cmphex(qtest_readb(qts, base_addr + OFFSET_ST), =3D=3D, 0); + g_assert_false(qtest_readb(qts, base_addr + OFFSET_CST) & CST_BUSY); + g_assert_false(qtest_readb(qts, base_addr + OFFSET_CST) & CST_BB); + + cst3 =3D qtest_readb(qts, base_addr + OFFSET_CST3); + g_assert_true(cst3 & CST3_EO_BUSY); + qtest_writeb(qts, base_addr + OFFSET_CST3, cst3); + cst3 =3D qtest_readb(qts, base_addr + OFFSET_CST3); + g_assert_false(cst3 & CST3_EO_BUSY); +} + +static void enable_bus(QTestState *qts, uint64_t base_addr) +{ + uint8_t ctl2 =3D qtest_readb(qts, base_addr + OFFSET_CTL2); + + ctl2 |=3D CTL2_ENABLE; + qtest_writeb(qts, base_addr + OFFSET_CTL2, ctl2); + g_assert_true(qtest_readb(qts, base_addr + OFFSET_CTL2) & CTL2_ENABLE); +} + +static void disable_bus(QTestState *qts, uint64_t base_addr) +{ + uint8_t ctl2 =3D qtest_readb(qts, base_addr + OFFSET_CTL2); + + ctl2 &=3D ~CTL2_ENABLE; + qtest_writeb(qts, base_addr + OFFSET_CTL2, ctl2); + g_assert_false(qtest_readb(qts, base_addr + OFFSET_CTL2) & CTL2_ENABLE= ); +} + +static void start_transfer(QTestState *qts, uint64_t base_addr) +{ + uint8_t ctl1; + + ctl1 =3D CTL1_START | CTL1_INTEN | CTL1_STASTRE; + qtest_writeb(qts, base_addr + OFFSET_CTL1, ctl1); + g_assert_cmphex(qtest_readb(qts, base_addr + OFFSET_CTL1), =3D=3D, + CTL1_INTEN | CTL1_STASTRE | CTL1_INTEN); + g_assert_cmphex(qtest_readb(qts, base_addr + OFFSET_ST), =3D=3D, + ST_MODE | ST_XMIT | ST_SDAST); + check_running(qts, base_addr); +} + +static void stop_transfer(QTestState *qts, uint64_t base_addr) +{ + uint8_t ctl1 =3D qtest_readb(qts, base_addr + OFFSET_CTL1); + + ctl1 &=3D ~(CTL1_START | CTL1_ACK); + ctl1 |=3D CTL1_STOP | CTL1_INTEN | CTL1_EOBINTE; + qtest_writeb(qts, base_addr + OFFSET_CTL1, ctl1); + ctl1 =3D qtest_readb(qts, base_addr + OFFSET_CTL1); + g_assert_false(ctl1 & CTL1_STOP); +} + +static void send_byte(QTestState *qts, uint64_t base_addr, uint8_t byte) +{ + g_assert_cmphex(qtest_readb(qts, base_addr + OFFSET_ST), =3D=3D, + ST_MODE | ST_XMIT | ST_SDAST); + qtest_writeb(qts, base_addr + OFFSET_SDA, byte); +} + +static uint8_t recv_byte(QTestState *qts, uint64_t base_addr) +{ + g_assert_cmphex(qtest_readb(qts, base_addr + OFFSET_ST), =3D=3D, + ST_MODE | ST_SDAST); + return qtest_readb(qts, base_addr + OFFSET_SDA); +} + +static void send_address(QTestState *qts, uint64_t base_addr, uint8_t addr, + bool recv, bool valid) +{ + uint8_t encoded_addr =3D (addr << 1) | (recv ? 1 : 0); + uint8_t st; + + qtest_writeb(qts, base_addr + OFFSET_SDA, encoded_addr); + st =3D qtest_readb(qts, base_addr + OFFSET_ST); + + if (valid) { + if (recv) { + g_assert_cmphex(st, =3D=3D, ST_MODE | ST_SDAST | ST_STASTR); + } else { + g_assert_cmphex(st, =3D=3D, ST_MODE | ST_XMIT | ST_SDAST | ST_= STASTR); + } + + qtest_writeb(qts, base_addr + OFFSET_ST, ST_STASTR); + st =3D qtest_readb(qts, base_addr + OFFSET_ST); + if (recv) { + g_assert_cmphex(st, =3D=3D, ST_MODE | ST_SDAST); + } else { + g_assert_cmphex(st, =3D=3D, ST_MODE | ST_XMIT | ST_SDAST); + } + } else { + if (recv) { + g_assert_cmphex(st, =3D=3D, ST_MODE | ST_NEGACK); + } else { + g_assert_cmphex(st, =3D=3D, ST_MODE | ST_XMIT | ST_NEGACK); + } + } +} + +static void send_nack(QTestState *qts, uint64_t base_addr) +{ + uint8_t ctl1 =3D qtest_readb(qts, base_addr + OFFSET_CTL1); + + ctl1 &=3D ~(CTL1_START | CTL1_STOP); + ctl1 |=3D CTL1_ACK | CTL1_INTEN; + qtest_writeb(qts, base_addr + OFFSET_CTL1, ctl1); +} + +/* Check the SMBus's status is set correctly when disabled. */ +static void test_disable_bus(gconstpointer data) +{ + intptr_t index =3D (intptr_t)data; + uint64_t base_addr =3D SMBUS_ADDR(index); + QTestState *qts =3D qtest_init("-machine npcm750-evb"); + + disable_bus(qts, base_addr); + g_assert_cmphex(qtest_readb(qts, base_addr + OFFSET_CTL1), =3D=3D, 0); + g_assert_cmphex(qtest_readb(qts, base_addr + OFFSET_ST), =3D=3D, 0); + g_assert_false(qtest_readb(qts, base_addr + OFFSET_CST3) & CST3_EO_BUS= Y); + g_assert_cmphex(qtest_readb(qts, base_addr + OFFSET_CST), =3D=3D, 0); + qtest_quit(qts); +} + +/* Check the SMBus returns a NACK for an invalid address. */ +static void test_invalid_addr(gconstpointer data) +{ + intptr_t index =3D (intptr_t)data; + uint64_t base_addr =3D SMBUS_ADDR(index); + int irq =3D SMBUS_IRQ(index); + QTestState *qts =3D qtest_init("-machine npcm750-evb"); + + qtest_irq_intercept_in(qts, "/machine/soc/a9mpcore/gic"); + enable_bus(qts, base_addr); + g_assert_false(qtest_get_irq(qts, irq)); + start_transfer(qts, base_addr); + send_address(qts, base_addr, INVALID_DEVICE_ADDR, false, false); + g_assert_true(qtest_get_irq(qts, irq)); + stop_transfer(qts, base_addr); + check_running(qts, base_addr); + qtest_writeb(qts, base_addr + OFFSET_ST, ST_NEGACK); + g_assert_false(qtest_readb(qts, base_addr + OFFSET_ST) & ST_NEGACK); + check_stopped(qts, base_addr); + qtest_quit(qts); +} + +/* Check the SMBus can send and receive bytes to a device in single mode. = */ +static void test_single_mode(gconstpointer data) +{ + intptr_t index =3D (intptr_t)data; + uint64_t base_addr =3D SMBUS_ADDR(index); + int irq =3D SMBUS_IRQ(index); + uint8_t value =3D 0x60; + QTestState *qts =3D qtest_init("-machine npcm750-evb"); + + qtest_irq_intercept_in(qts, "/machine/soc/a9mpcore/gic"); + enable_bus(qts, base_addr); + + /* Sending */ + g_assert_false(qtest_get_irq(qts, irq)); + start_transfer(qts, base_addr); + g_assert_true(qtest_get_irq(qts, irq)); + send_address(qts, base_addr, EVB_DEVICE_ADDR, false, true); + send_byte(qts, base_addr, TMP105_REG_CONFIG); + send_byte(qts, base_addr, value); + stop_transfer(qts, base_addr); + check_stopped(qts, base_addr); + + /* Receiving */ + start_transfer(qts, base_addr); + send_address(qts, base_addr, EVB_DEVICE_ADDR, false, true); + send_byte(qts, base_addr, TMP105_REG_CONFIG); + start_transfer(qts, base_addr); + send_address(qts, base_addr, EVB_DEVICE_ADDR, true, true); + send_nack(qts, base_addr); + stop_transfer(qts, base_addr); + check_running(qts, base_addr); + g_assert_cmphex(recv_byte(qts, base_addr), =3D=3D, value); + check_stopped(qts, base_addr); + qtest_quit(qts); +} + +static void smbus_add_test(const char *name, int index, GTestDataFunc fn) +{ + g_autofree char *full_name =3D g_strdup_printf( + "npcm7xx_smbus[%d]/%s", index, name); + qtest_add_data_func(full_name, (void *)(intptr_t)index, fn); +} +#define add_test(name, td) smbus_add_test(#name, td, test_##name) + +int main(int argc, char **argv) +{ + int i; + + g_test_init(&argc, &argv, NULL); + g_test_set_nonfatal_assertions(); + + for (i =3D 0; i < NR_SMBUS_DEVICES; ++i) { + add_test(disable_bus, i); + add_test(invalid_addr, i); + } + + for (i =3D 0; i < ARRAY_SIZE(evb_bus_list); ++i) { + add_test(single_mode, evb_bus_list[i]); + } + + return g_test_run(); +} --=20 2.30.0.365.g02bc693789-goog From nobody Fri May 17 03:39:49 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=nongnu.org ARC-Seal: i=1; a=rsa-sha256; t=1611689998; cv=none; d=zohomail.com; s=zohoarc; b=MbkXlSE8ekb4VFF4b3Z1lTweks4642CEk2yc+BdaauSwRPQutZxNzitgPWr52QLyW9iS+fYUtMkP9NN2Al4i3R/ra53ty7pUREDnxIgFHBQ1mFJ9jvGUCmNkFO8ns/xTR3fqU5joiz/GrxmBjTR3mIHa8j6+pVTUJlT4LtW7Gss= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1611689998; h=Content-Type:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Reply-To:References:Sender:Subject:To; bh=9gmay14fRMYJR9i4fevNvn8lyd2M4klZegZsR1++K5E=; b=PrfV2tPv5xVC/6vgLjjZHmtpjCmtwyKqWcHAQPQqseElb9q8ssxAxjmuE/uwAIELor8X4tAsRSED90lSRIlB2dM1zlq0vKeZHwFSw5DpSDBY7TarPZvQeIVb7hU67pdSPgDccPnvbhCpEdE3dTuh9BENCGIk2RGOVsDQNf7mHcs= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1611689998471589.9654166968888; Tue, 26 Jan 2021 11:39:58 -0800 (PST) Received: from localhost ([::1]:51022 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1l4UBx-0001zq-7l for importer@patchew.org; Tue, 26 Jan 2021 14:39:57 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:37150) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <3bW4QYAgKCpIIG3wAFE32AA270.yA8C08G-z0H079A929G.AD2@flex--wuhaotsh.bounces.google.com>) id 1l4U5V-0004dS-Ii for qemu-devel@nongnu.org; Tue, 26 Jan 2021 14:33:17 -0500 Received: from mail-qv1-xf49.google.com ([2607:f8b0:4864:20::f49]:45103) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from <3bW4QYAgKCpIIG3wAFE32AA270.yA8C08G-z0H079A929G.AD2@flex--wuhaotsh.bounces.google.com>) id 1l4U5I-00048s-4J for qemu-devel@nongnu.org; Tue, 26 Jan 2021 14:33:17 -0500 Received: by mail-qv1-xf49.google.com with SMTP id l3so7907197qvz.12 for ; Tue, 26 Jan 2021 11:33:02 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:in-reply-to:message-id:mime-version:references:subject :from:to:cc; bh=9gmay14fRMYJR9i4fevNvn8lyd2M4klZegZsR1++K5E=; b=FT3BxJFKqoEMtr8Bgs555YviSa9P6iULkbaZAlfBqm4+ylZWPzx5Qt+G0yWVtEk3hN qAqePxoKPT7oxTiFTm2FtLJM8PV3kpFkHuhJfZ7qDN+4E78CxHq8fI3GC38O5DZg2eFn 4yYXTHu5XSGhNUlu99mPcw+sU0MHb2ViM1bzDwCtXHgQaDIZCj/ABUo3pH5RlqZW2BVa 6WiwObj796Mh8Pp8pMWI0Tq+ugWdcTDrxqs6ZQBgbu4RKOHAoAobCpVs6cR3YFsMmUvc CQv4RNcM2/7W1hOPdVRSf5ODqQlpPJe5EmMLk2CnZQMkwBKdJ+XtUVDFst7WAWTa6ctK 2ESw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=9gmay14fRMYJR9i4fevNvn8lyd2M4klZegZsR1++K5E=; b=dSquLWKnhw6yBChmbfw11GkNb6Setz3H+j9EkoS7kN6rp5QlET2SCNi3wMWGULegVp 8Ni0zX8Ff1c0PRlkOgvXhlkp+/T1Xhkh6XpEE4SizUQ5bUkRmtXeXMmNVxl453a0rnsB yvljuQFrKnb+vX/9KmUPZm5duK0c+g2bI3uMmNXzy8rRRxxfpUwfVY166E5Wd1S6C7UV ycWrOK+tZ+eRExR14bstUr+UXlbk4G1Ff2oSsKEdziT4Vrem9gP7W4lPPAyi/G3ZmIy8 curAo74fdwFQjoJgX45y9+d2ECEYpy8AWMQNchj5q8mCIdxHr3MUQpokcsrIQTdhYO8t dD5Q== X-Gm-Message-State: AOAM531aEp+tUhLuNFMxFZzrbPHKVhSkXgZZrRby4EZptpVafEKkInd0 r219XJtsxHXOnp6Cqb5wV7ziXmDigZLHlw== X-Google-Smtp-Source: ABdhPJwGYvi11MxAepmPuKnJu2akR/k4nYT0vjKzREQoj7fzhXjNfKC2tp6zM0HKU1e5J+R1UHoThTpW3BB6xw== X-Received: from mimik.c.googlers.com ([fda3:e722:ac3:10:7f:e700:c0a8:4e]) (user=wuhaotsh job=sendgmr) by 2002:a05:6214:7aa:: with SMTP id v10mr7060958qvz.2.1611689581826; Tue, 26 Jan 2021 11:33:01 -0800 (PST) Date: Tue, 26 Jan 2021 11:32:37 -0800 In-Reply-To: <20210126193237.1534208-1-wuhaotsh@google.com> Message-Id: <20210126193237.1534208-7-wuhaotsh@google.com> Mime-Version: 1.0 References: <20210126193237.1534208-1-wuhaotsh@google.com> X-Mailer: git-send-email 2.30.0.365.g02bc693789-goog Subject: [PATCH 6/6] hw/i2c: Implement NPCM7XX SMBus Module FIFO Mode To: peter.maydell@linaro.org Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::f49; envelope-from=3bW4QYAgKCpIIG3wAFE32AA270.yA8C08G-z0H079A929G.AD2@flex--wuhaotsh.bounces.google.com; helo=mail-qv1-xf49.google.com X-Spam_score_int: -95 X-Spam_score: -9.6 X-Spam_bar: --------- X-Spam_report: (-9.6 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_MED=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, USER_IN_DEF_DKIM_WL=-7.5 autolearn=unavailable autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: venture@google.com, hskinnemoen@google.com, qemu-devel@nongnu.org, wuhaotsh@google.com, kfting@nuvoton.com, qemu-arm@nongnu.org, Avi.Fishman@nuvoton.com, dje@google.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" Reply-to: Hao Wu From: wuhaotsh--- via X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This patch implements the FIFO mode of the SMBus module. In FIFO, the user transmits or receives at most 16 bytes at a time. The FIFO mode allows the module to transmit large amount of data faster than single byte mode. Reviewed-by: Doug Evans Reviewed-by: Tyrong Ting Signed-off-by: Hao Wu Acked-by: Corey Minyard Reviewed-by: Corey Minyard --- hw/i2c/npcm7xx_smbus.c | 331 +++++++++++++++++++++++++++++-- hw/i2c/trace-events | 1 + include/hw/i2c/npcm7xx_smbus.h | 25 +++ tests/qtest/npcm7xx_smbus-test.c | 149 +++++++++++++- 4 files changed, 490 insertions(+), 16 deletions(-) diff --git a/hw/i2c/npcm7xx_smbus.c b/hw/i2c/npcm7xx_smbus.c index e8a8fdbaff..19a9cdb179 100644 --- a/hw/i2c/npcm7xx_smbus.c +++ b/hw/i2c/npcm7xx_smbus.c @@ -27,7 +27,7 @@ #include "trace.h" =20 #define NPCM7XX_SMBUS_VERSION 1 -#define NPCM7XX_SMBUS_FIFO_EN 0 +#define NPCM7XX_SMBUS_FIFO_EN 1 =20 enum NPCM7xxSMBusCommonRegister { NPCM7XX_SMB_SDA =3D 0x0, @@ -132,10 +132,41 @@ enum NPCM7xxSMBusBank1Register { #define NPCM7XX_ADDR_EN BIT(7) #define NPCM7XX_ADDR_A(rv) extract8((rv), 0, 6) =20 +/* FIFO Mode Register Fields */ +/* FIF_CTL fields */ +#define NPCM7XX_SMBFIF_CTL_FIFO_EN BIT(4) +#define NPCM7XX_SMBFIF_CTL_FAIR_RDY_IE BIT(2) +#define NPCM7XX_SMBFIF_CTL_FAIR_RDY BIT(1) +#define NPCM7XX_SMBFIF_CTL_FAIR_BUSY BIT(0) +/* FIF_CTS fields */ +#define NPCM7XX_SMBFIF_CTS_STR BIT(7) +#define NPCM7XX_SMBFIF_CTS_CLR_FIFO BIT(6) +#define NPCM7XX_SMBFIF_CTS_RFTE_IE BIT(3) +#define NPCM7XX_SMBFIF_CTS_RXF_TXE BIT(1) +/* TXF_CTL fields */ +#define NPCM7XX_SMBTXF_CTL_THR_TXIE BIT(6) +#define NPCM7XX_SMBTXF_CTL_TX_THR(rv) extract8((rv), 0, 5) +/* T_OUT fields */ +#define NPCM7XX_SMBT_OUT_ST BIT(7) +#define NPCM7XX_SMBT_OUT_IE BIT(6) +#define NPCM7XX_SMBT_OUT_CLKDIV(rv) extract8((rv), 0, 6) +/* TXF_STS fields */ +#define NPCM7XX_SMBTXF_STS_TX_THST BIT(6) +#define NPCM7XX_SMBTXF_STS_TX_BYTES(rv) extract8((rv), 0, 5) +/* RXF_STS fields */ +#define NPCM7XX_SMBRXF_STS_RX_THST BIT(6) +#define NPCM7XX_SMBRXF_STS_RX_BYTES(rv) extract8((rv), 0, 5) +/* RXF_CTL fields */ +#define NPCM7XX_SMBRXF_CTL_THR_RXIE BIT(6) +#define NPCM7XX_SMBRXF_CTL_LAST BIT(5) +#define NPCM7XX_SMBRXF_CTL_RX_THR(rv) extract8((rv), 0, 5) + #define KEEP_OLD_BIT(o, n, b) (((n) & (~(b))) | ((o) & (b))) #define WRITE_ONE_CLEAR(o, n, b) ((n) & (b) ? (o) & (~(b)) : (o)) =20 #define NPCM7XX_SMBUS_ENABLED(s) ((s)->ctl2 & NPCM7XX_SMBCTL2_ENABLE) +#define NPCM7XX_SMBUS_FIFO_ENABLED(s) (NPCM7XX_SMBUS_FIFO_EN && \ + (s)->fif_ctl & NPCM7XX_SMBFIF_CTL_FIFO_EN) =20 /* Reset values */ #define NPCM7XX_SMB_ST_INIT_VAL 0x00 @@ -150,6 +181,14 @@ enum NPCM7xxSMBusBank1Register { #define NPCM7XX_SMB_ADDR_INIT_VAL 0x00 #define NPCM7XX_SMB_SCLLT_INIT_VAL 0x00 #define NPCM7XX_SMB_SCLHT_INIT_VAL 0x00 +#define NPCM7XX_SMB_FIF_CTL_INIT_VAL 0x00 +#define NPCM7XX_SMB_FIF_CTS_INIT_VAL 0x00 +#define NPCM7XX_SMB_FAIR_PER_INIT_VAL 0x00 +#define NPCM7XX_SMB_TXF_CTL_INIT_VAL 0x00 +#define NPCM7XX_SMB_T_OUT_INIT_VAL 0x3f +#define NPCM7XX_SMB_TXF_STS_INIT_VAL 0x00 +#define NPCM7XX_SMB_RXF_STS_INIT_VAL 0x00 +#define NPCM7XX_SMB_RXF_CTL_INIT_VAL 0x01 =20 static uint8_t npcm7xx_smbus_get_version(void) { @@ -169,7 +208,13 @@ static void npcm7xx_smbus_update_irq(NPCM7xxSMBusState= *s) (s->ctl1 & NPCM7XX_SMBCTL1_STASTRE && s->st & NPCM7XX_SMBST_SDAST) || (s->ctl1 & NPCM7XX_SMBCTL1_EOBINTE && - s->cst3 & NPCM7XX_SMBCST3_EO_BUSY)); + s->cst3 & NPCM7XX_SMBCST3_EO_BUSY) || + (s->rxf_ctl & NPCM7XX_SMBRXF_CTL_THR_RXIE && + s->rxf_sts & NPCM7XX_SMBRXF_STS_RX_THST) || + (s->txf_ctl & NPCM7XX_SMBTXF_CTL_THR_TXIE && + s->txf_sts & NPCM7XX_SMBTXF_STS_TX_THST) || + (s->fif_cts & NPCM7XX_SMBFIF_CTS_RFTE_IE && + s->fif_cts & NPCM7XX_SMBFIF_CTS_RXF_TXE)); =20 if (level) { s->cst2 |=3D NPCM7XX_SMBCST2_INTSTS; @@ -187,6 +232,13 @@ static void npcm7xx_smbus_nack(NPCM7xxSMBusState *s) s->status =3D NPCM7XX_SMBUS_STATUS_NEGACK; } =20 +static void npcm7xx_smbus_clear_buffer(NPCM7xxSMBusState *s) +{ + s->fif_cts &=3D ~NPCM7XX_SMBFIF_CTS_RXF_TXE; + s->txf_sts =3D 0; + s->rxf_sts =3D 0; +} + static void npcm7xx_smbus_send_byte(NPCM7xxSMBusState *s, uint8_t value) { int rv =3D i2c_send(s->bus, value); @@ -195,6 +247,15 @@ static void npcm7xx_smbus_send_byte(NPCM7xxSMBusState = *s, uint8_t value) npcm7xx_smbus_nack(s); } else { s->st |=3D NPCM7XX_SMBST_SDAST; + if (NPCM7XX_SMBUS_FIFO_ENABLED(s)) { + s->fif_cts |=3D NPCM7XX_SMBFIF_CTS_RXF_TXE; + if (NPCM7XX_SMBTXF_STS_TX_BYTES(s->txf_sts) =3D=3D + NPCM7XX_SMBTXF_CTL_TX_THR(s->txf_ctl)) { + s->txf_sts =3D NPCM7XX_SMBTXF_STS_TX_THST; + } else { + s->txf_sts =3D 0; + } + } } trace_npcm7xx_smbus_send_byte((DEVICE(s)->canonical_path), value, !rv); npcm7xx_smbus_update_irq(s); @@ -213,6 +274,67 @@ static void npcm7xx_smbus_recv_byte(NPCM7xxSMBusState = *s) npcm7xx_smbus_update_irq(s); } =20 +static void npcm7xx_smbus_recv_fifo(NPCM7xxSMBusState *s) +{ + uint8_t expected_bytes =3D NPCM7XX_SMBRXF_CTL_RX_THR(s->rxf_ctl); + uint8_t received_bytes =3D NPCM7XX_SMBRXF_STS_RX_BYTES(s->rxf_sts); + uint8_t pos; + + if (received_bytes =3D=3D expected_bytes) { + return; + } + + while (received_bytes < expected_bytes && + received_bytes < NPCM7XX_SMBUS_FIFO_SIZE) { + pos =3D (s->rx_cur + received_bytes) % NPCM7XX_SMBUS_FIFO_SIZE; + s->rx_fifo[pos] =3D i2c_recv(s->bus); + trace_npcm7xx_smbus_recv_byte((DEVICE(s)->canonical_path), + s->rx_fifo[pos]); + ++received_bytes; + } + + trace_npcm7xx_smbus_recv_fifo((DEVICE(s)->canonical_path), + received_bytes, expected_bytes); + s->rxf_sts =3D received_bytes; + if (unlikely(received_bytes < expected_bytes)) { + qemu_log_mask(LOG_GUEST_ERROR, + "%s: invalid rx_thr value: 0x%02x\n", + DEVICE(s)->canonical_path, expected_bytes); + return; + } + + s->rxf_sts |=3D NPCM7XX_SMBRXF_STS_RX_THST; + if (s->rxf_ctl & NPCM7XX_SMBRXF_CTL_LAST) { + trace_npcm7xx_smbus_nack(DEVICE(s)->canonical_path); + i2c_nack(s->bus); + s->rxf_ctl &=3D ~NPCM7XX_SMBRXF_CTL_LAST; + } + if (received_bytes =3D=3D NPCM7XX_SMBUS_FIFO_SIZE) { + s->st |=3D NPCM7XX_SMBST_SDAST; + s->fif_cts |=3D NPCM7XX_SMBFIF_CTS_RXF_TXE; + } else if (!(s->rxf_ctl & NPCM7XX_SMBRXF_CTL_THR_RXIE)) { + s->st |=3D NPCM7XX_SMBST_SDAST; + } else { + s->st &=3D ~NPCM7XX_SMBST_SDAST; + } + npcm7xx_smbus_update_irq(s); +} + +static void npcm7xx_smbus_read_byte_fifo(NPCM7xxSMBusState *s) +{ + uint8_t received_bytes =3D NPCM7XX_SMBRXF_STS_RX_BYTES(s->rxf_sts); + + if (received_bytes =3D=3D 0) { + npcm7xx_smbus_recv_fifo(s); + return; + } + + s->sda =3D s->rx_fifo[s->rx_cur]; + s->rx_cur =3D (s->rx_cur + 1u) % NPCM7XX_SMBUS_FIFO_SIZE; + --s->rxf_sts; + npcm7xx_smbus_update_irq(s); +} + static void npcm7xx_smbus_start(NPCM7xxSMBusState *s) { /* @@ -226,6 +348,9 @@ static void npcm7xx_smbus_start(NPCM7xxSMBusState *s) if (available) { s->st |=3D NPCM7XX_SMBST_MODE | NPCM7XX_SMBST_XMIT | NPCM7XX_SMBST= _SDAST; s->cst |=3D NPCM7XX_SMBCST_BUSY; + if (NPCM7XX_SMBUS_FIFO_ENABLED(s)) { + s->fif_cts |=3D NPCM7XX_SMBFIF_CTS_RXF_TXE; + } } else { s->st &=3D ~NPCM7XX_SMBST_MODE; s->cst &=3D ~NPCM7XX_SMBCST_BUSY; @@ -277,7 +402,15 @@ static void npcm7xx_smbus_send_address(NPCM7xxSMBusSta= te *s, uint8_t value) s->st |=3D NPCM7XX_SMBST_SDAST; } } else if (recv) { - npcm7xx_smbus_recv_byte(s); + s->st |=3D NPCM7XX_SMBST_SDAST; + if (NPCM7XX_SMBUS_FIFO_ENABLED(s)) { + npcm7xx_smbus_recv_fifo(s); + } else { + npcm7xx_smbus_recv_byte(s); + } + } else if (NPCM7XX_SMBUS_FIFO_ENABLED(s)) { + s->st |=3D NPCM7XX_SMBST_SDAST; + s->fif_cts |=3D NPCM7XX_SMBFIF_CTS_RXF_TXE; } npcm7xx_smbus_update_irq(s); } @@ -320,11 +453,31 @@ static uint8_t npcm7xx_smbus_read_sda(NPCM7xxSMBusSta= te *s) =20 switch (s->status) { case NPCM7XX_SMBUS_STATUS_STOPPING_LAST_RECEIVE: - npcm7xx_smbus_execute_stop(s); + if (NPCM7XX_SMBUS_FIFO_ENABLED(s)) { + if (NPCM7XX_SMBRXF_STS_RX_BYTES(s->rxf_sts) <=3D 1) { + npcm7xx_smbus_execute_stop(s); + } + if (NPCM7XX_SMBRXF_STS_RX_BYTES(s->rxf_sts) =3D=3D 0) { + qemu_log_mask(LOG_GUEST_ERROR, + "%s: read to SDA with an empty rx-fifo buffe= r, " + "result undefined: %u\n", + DEVICE(s)->canonical_path, s->sda); + break; + } + npcm7xx_smbus_read_byte_fifo(s); + value =3D s->sda; + } else { + npcm7xx_smbus_execute_stop(s); + } break; =20 case NPCM7XX_SMBUS_STATUS_RECEIVING: - npcm7xx_smbus_recv_byte(s); + if (NPCM7XX_SMBUS_FIFO_ENABLED(s)) { + npcm7xx_smbus_read_byte_fifo(s); + value =3D s->sda; + } else { + npcm7xx_smbus_recv_byte(s); + } break; =20 default: @@ -370,8 +523,12 @@ static void npcm7xx_smbus_write_st(NPCM7xxSMBusState *= s, uint8_t value) } =20 if (value & NPCM7XX_SMBST_STASTR && - s->status =3D=3D NPCM7XX_SMBUS_STATUS_RECEIVING) { - npcm7xx_smbus_recv_byte(s); + s->status =3D=3D NPCM7XX_SMBUS_STATUS_RECEIVING) { + if (NPCM7XX_SMBUS_FIFO_ENABLED(s)) { + npcm7xx_smbus_recv_fifo(s); + } else { + npcm7xx_smbus_recv_byte(s); + } } =20 npcm7xx_smbus_update_irq(s); @@ -417,6 +574,7 @@ static void npcm7xx_smbus_write_ctl2(NPCM7xxSMBusState = *s, uint8_t value) s->st =3D 0; s->cst3 =3D s->cst3 & (~NPCM7XX_SMBCST3_EO_BUSY); s->cst =3D 0; + npcm7xx_smbus_clear_buffer(s); } } =20 @@ -429,6 +587,70 @@ static void npcm7xx_smbus_write_ctl3(NPCM7xxSMBusState= *s, uint8_t value) NPCM7XX_SMBCTL3_SCL_LVL | NPCM7XX_SMBCTL3_SDA_= LVL); } =20 +static void npcm7xx_smbus_write_fif_ctl(NPCM7xxSMBusState *s, uint8_t valu= e) +{ + uint8_t new_ctl =3D value; + + new_ctl =3D KEEP_OLD_BIT(s->fif_ctl, new_ctl, NPCM7XX_SMBFIF_CTL_FAIR_= RDY); + new_ctl =3D WRITE_ONE_CLEAR(new_ctl, value, NPCM7XX_SMBFIF_CTL_FAIR_RD= Y); + new_ctl =3D KEEP_OLD_BIT(s->fif_ctl, new_ctl, NPCM7XX_SMBFIF_CTL_FAIR_= BUSY); + s->fif_ctl =3D new_ctl; +} + +static void npcm7xx_smbus_write_fif_cts(NPCM7xxSMBusState *s, uint8_t valu= e) +{ + s->fif_cts =3D WRITE_ONE_CLEAR(s->fif_cts, value, NPCM7XX_SMBFIF_CTS_S= TR); + s->fif_cts =3D WRITE_ONE_CLEAR(s->fif_cts, value, NPCM7XX_SMBFIF_CTS_R= XF_TXE); + s->fif_cts =3D KEEP_OLD_BIT(value, s->fif_cts, NPCM7XX_SMBFIF_CTS_RFTE= _IE); + + if (value & NPCM7XX_SMBFIF_CTS_CLR_FIFO) { + npcm7xx_smbus_clear_buffer(s); + } +} + +static void npcm7xx_smbus_write_txf_ctl(NPCM7xxSMBusState *s, uint8_t valu= e) +{ + s->txf_ctl =3D value; +} + +static void npcm7xx_smbus_write_t_out(NPCM7xxSMBusState *s, uint8_t value) +{ + uint8_t new_t_out =3D value; + + if ((value & NPCM7XX_SMBT_OUT_ST) || (!(s->t_out & NPCM7XX_SMBT_OUT_ST= ))) { + new_t_out &=3D ~NPCM7XX_SMBT_OUT_ST; + } else { + new_t_out |=3D NPCM7XX_SMBT_OUT_ST; + } + + s->t_out =3D new_t_out; +} + +static void npcm7xx_smbus_write_txf_sts(NPCM7xxSMBusState *s, uint8_t valu= e) +{ + s->txf_sts =3D WRITE_ONE_CLEAR(s->txf_sts, value, NPCM7XX_SMBTXF_STS_T= X_THST); +} + +static void npcm7xx_smbus_write_rxf_sts(NPCM7xxSMBusState *s, uint8_t valu= e) +{ + if (value & NPCM7XX_SMBRXF_STS_RX_THST) { + s->rxf_sts &=3D ~NPCM7XX_SMBRXF_STS_RX_THST; + if (s->status =3D=3D NPCM7XX_SMBUS_STATUS_RECEIVING) { + npcm7xx_smbus_recv_fifo(s); + } + } +} + +static void npcm7xx_smbus_write_rxf_ctl(NPCM7xxSMBusState *s, uint8_t valu= e) +{ + uint8_t new_ctl =3D value; + + if (!(value & NPCM7XX_SMBRXF_CTL_LAST)) { + new_ctl =3D KEEP_OLD_BIT(s->rxf_ctl, new_ctl, NPCM7XX_SMBRXF_CTL_L= AST); + } + s->rxf_ctl =3D new_ctl; +} + static uint64_t npcm7xx_smbus_read(void *opaque, hwaddr offset, unsigned s= ize) { NPCM7xxSMBusState *s =3D opaque; @@ -484,9 +706,41 @@ static uint64_t npcm7xx_smbus_read(void *opaque, hwadd= r offset, unsigned size) default: if (bank) { /* Bank 1 */ - qemu_log_mask(LOG_GUEST_ERROR, - "%s: read from invalid offset 0x%" HWADDR_PRIx "\n", - DEVICE(s)->canonical_path, offset); + switch (offset) { + case NPCM7XX_SMB_FIF_CTS: + value =3D s->fif_cts; + break; + + case NPCM7XX_SMB_FAIR_PER: + value =3D s->fair_per; + break; + + case NPCM7XX_SMB_TXF_CTL: + value =3D s->txf_ctl; + break; + + case NPCM7XX_SMB_T_OUT: + value =3D s->t_out; + break; + + case NPCM7XX_SMB_TXF_STS: + value =3D s->txf_sts; + break; + + case NPCM7XX_SMB_RXF_STS: + value =3D s->rxf_sts; + break; + + case NPCM7XX_SMB_RXF_CTL: + value =3D s->rxf_ctl; + break; + + default: + qemu_log_mask(LOG_GUEST_ERROR, + "%s: read from invalid offset 0x%" HWADDR_PRIx "\n= ", + DEVICE(s)->canonical_path, offset); + break; + } } else { /* Bank 0 */ switch (offset) { @@ -534,6 +788,10 @@ static uint64_t npcm7xx_smbus_read(void *opaque, hwadd= r offset, unsigned size) value =3D s->scllt; break; =20 + case NPCM7XX_SMB_FIF_CTL: + value =3D s->fif_ctl; + break; + case NPCM7XX_SMB_SCLHT: value =3D s->sclht; break; @@ -614,9 +872,41 @@ static void npcm7xx_smbus_write(void *opaque, hwaddr o= ffset, uint64_t value, default: if (bank) { /* Bank 1 */ - qemu_log_mask(LOG_GUEST_ERROR, - "%s: write to invalid offset 0x%" HWADDR_PRIx "\n", - DEVICE(s)->canonical_path, offset); + switch (offset) { + case NPCM7XX_SMB_FIF_CTS: + npcm7xx_smbus_write_fif_cts(s, value); + break; + + case NPCM7XX_SMB_FAIR_PER: + s->fair_per =3D value; + break; + + case NPCM7XX_SMB_TXF_CTL: + npcm7xx_smbus_write_txf_ctl(s, value); + break; + + case NPCM7XX_SMB_T_OUT: + npcm7xx_smbus_write_t_out(s, value); + break; + + case NPCM7XX_SMB_TXF_STS: + npcm7xx_smbus_write_txf_sts(s, value); + break; + + case NPCM7XX_SMB_RXF_STS: + npcm7xx_smbus_write_rxf_sts(s, value); + break; + + case NPCM7XX_SMB_RXF_CTL: + npcm7xx_smbus_write_rxf_ctl(s, value); + break; + + default: + qemu_log_mask(LOG_GUEST_ERROR, + "%s: write to invalid offset 0x%" HWADDR_PRIx "\n", + DEVICE(s)->canonical_path, offset); + break; + } } else { /* Bank 0 */ switch (offset) { @@ -664,6 +954,10 @@ static void npcm7xx_smbus_write(void *opaque, hwaddr o= ffset, uint64_t value, s->scllt =3D value; break; =20 + case NPCM7XX_SMB_FIF_CTL: + npcm7xx_smbus_write_fif_ctl(s, value); + break; + case NPCM7XX_SMB_SCLHT: s->sclht =3D value; break; @@ -710,7 +1004,18 @@ static void npcm7xx_smbus_enter_reset(Object *obj, Re= setType type) s->scllt =3D NPCM7XX_SMB_SCLLT_INIT_VAL; s->sclht =3D NPCM7XX_SMB_SCLHT_INIT_VAL; =20 + s->fif_ctl =3D NPCM7XX_SMB_FIF_CTL_INIT_VAL; + s->fif_cts =3D NPCM7XX_SMB_FIF_CTS_INIT_VAL; + s->fair_per =3D NPCM7XX_SMB_FAIR_PER_INIT_VAL; + s->txf_ctl =3D NPCM7XX_SMB_TXF_CTL_INIT_VAL; + s->t_out =3D NPCM7XX_SMB_T_OUT_INIT_VAL; + s->txf_sts =3D NPCM7XX_SMB_TXF_STS_INIT_VAL; + s->rxf_sts =3D NPCM7XX_SMB_RXF_STS_INIT_VAL; + s->rxf_ctl =3D NPCM7XX_SMB_RXF_CTL_INIT_VAL; + + npcm7xx_smbus_clear_buffer(s); s->status =3D NPCM7XX_SMBUS_STATUS_IDLE; + s->rx_cur =3D 0; } =20 static void npcm7xx_smbus_hold_reset(Object *obj) diff --git a/hw/i2c/trace-events b/hw/i2c/trace-events index c3bb70ad04..82fe6f965f 100644 --- a/hw/i2c/trace-events +++ b/hw/i2c/trace-events @@ -25,3 +25,4 @@ npcm7xx_smbus_send_byte(const char *id, uint8_t value, in= t success) "%s send byt npcm7xx_smbus_recv_byte(const char *id, uint8_t value) "%s recv byte: 0x%0= 2x" npcm7xx_smbus_stop(const char *id) "%s stopping" npcm7xx_smbus_nack(const char *id) "%s nacking" +npcm7xx_smbus_recv_fifo(const char *id, uint8_t received, uint8_t expected= ) "%s recv fifo: received %u, expected %u" diff --git a/include/hw/i2c/npcm7xx_smbus.h b/include/hw/i2c/npcm7xx_smbus.h index b9761a6993..7d59ee917e 100644 --- a/include/hw/i2c/npcm7xx_smbus.h +++ b/include/hw/i2c/npcm7xx_smbus.h @@ -27,6 +27,9 @@ */ #define NPCM7XX_SMBUS_NR_ADDRS 10 =20 +/* Size of the FIFO buffer. */ +#define NPCM7XX_SMBUS_FIFO_SIZE 16 + typedef enum NPCM7xxSMBusStatus { NPCM7XX_SMBUS_STATUS_IDLE, NPCM7XX_SMBUS_STATUS_SENDING, @@ -53,6 +56,16 @@ typedef enum NPCM7xxSMBusStatus { * @addr: The SMBus module's own addresses on the I2C bus. * @scllt: The SCL low time register. * @sclht: The SCL high time register. + * @fif_ctl: The FIFO control register. + * @fif_cts: The FIFO control status register. + * @fair_per: The fair preriod register. + * @txf_ctl: The transmit FIFO control register. + * @t_out: The SMBus timeout register. + * @txf_sts: The transmit FIFO status register. + * @rxf_sts: The receive FIFO status register. + * @rxf_ctl: The receive FIFO control register. + * @rx_fifo: The FIFO buffer for receiving in FIFO mode. + * @rx_cur: The current position of rx_fifo. * @status: The current status of the SMBus. */ typedef struct NPCM7xxSMBusState { @@ -78,6 +91,18 @@ typedef struct NPCM7xxSMBusState { uint8_t scllt; uint8_t sclht; =20 + uint8_t fif_ctl; + uint8_t fif_cts; + uint8_t fair_per; + uint8_t txf_ctl; + uint8_t t_out; + uint8_t txf_sts; + uint8_t rxf_sts; + uint8_t rxf_ctl; + + uint8_t rx_fifo[NPCM7XX_SMBUS_FIFO_SIZE]; + uint8_t rx_cur; + NPCM7xxSMBusStatus status; } NPCM7xxSMBusState; =20 diff --git a/tests/qtest/npcm7xx_smbus-test.c b/tests/qtest/npcm7xx_smbus-t= est.c index 4594b107df..4f9f493872 100644 --- a/tests/qtest/npcm7xx_smbus-test.c +++ b/tests/qtest/npcm7xx_smbus-test.c @@ -132,6 +132,44 @@ enum NPCM7xxSMBusBank1Register { #define ADDR_EN BIT(7) #define ADDR_A(rv) extract8((rv), 0, 6) =20 +/* FIF_CTL fields */ +#define FIF_CTL_FIFO_EN BIT(4) + +/* FIF_CTS fields */ +#define FIF_CTS_CLR_FIFO BIT(6) +#define FIF_CTS_RFTE_IE BIT(3) +#define FIF_CTS_RXF_TXE BIT(1) + +/* TXF_CTL fields */ +#define TXF_CTL_THR_TXIE BIT(6) +#define TXF_CTL_TX_THR(rv) extract8((rv), 0, 5) + +/* TXF_STS fields */ +#define TXF_STS_TX_THST BIT(6) +#define TXF_STS_TX_BYTES(rv) extract8((rv), 0, 5) + +/* RXF_CTL fields */ +#define RXF_CTL_THR_RXIE BIT(6) +#define RXF_CTL_LAST BIT(5) +#define RXF_CTL_RX_THR(rv) extract8((rv), 0, 5) + +/* RXF_STS fields */ +#define RXF_STS_RX_THST BIT(6) +#define RXF_STS_RX_BYTES(rv) extract8((rv), 0, 5) + + +static void choose_bank(QTestState *qts, uint64_t base_addr, uint8_t bank) +{ + uint8_t ctl3 =3D qtest_readb(qts, base_addr + OFFSET_CTL3); + + if (bank) { + ctl3 |=3D CTL3_BNK_SEL; + } else { + ctl3 &=3D ~CTL3_BNK_SEL; + } + + qtest_writeb(qts, base_addr + OFFSET_CTL3, ctl3); +} =20 static void check_running(QTestState *qts, uint64_t base_addr) { @@ -203,10 +241,33 @@ static void send_byte(QTestState *qts, uint64_t base_= addr, uint8_t byte) qtest_writeb(qts, base_addr + OFFSET_SDA, byte); } =20 +static bool check_recv(QTestState *qts, uint64_t base_addr) +{ + uint8_t st, fif_ctl, rxf_ctl, rxf_sts; + bool fifo; + + st =3D qtest_readb(qts, base_addr + OFFSET_ST); + choose_bank(qts, base_addr, 0); + fif_ctl =3D qtest_readb(qts, base_addr + OFFSET_FIF_CTL); + fifo =3D fif_ctl & FIF_CTL_FIFO_EN; + if (!fifo) { + return st =3D=3D (ST_MODE | ST_SDAST); + } + + choose_bank(qts, base_addr, 1); + rxf_ctl =3D qtest_readb(qts, base_addr + OFFSET_RXF_CTL); + rxf_sts =3D qtest_readb(qts, base_addr + OFFSET_RXF_STS); + + if ((rxf_ctl & RXF_CTL_THR_RXIE) && RXF_STS_RX_BYTES(rxf_sts) < 16) { + return st =3D=3D ST_MODE; + } else { + return st =3D=3D (ST_MODE | ST_SDAST); + } +} + static uint8_t recv_byte(QTestState *qts, uint64_t base_addr) { - g_assert_cmphex(qtest_readb(qts, base_addr + OFFSET_ST), =3D=3D, - ST_MODE | ST_SDAST); + g_assert_true(check_recv(qts, base_addr)); return qtest_readb(qts, base_addr + OFFSET_SDA); } =20 @@ -229,7 +290,7 @@ static void send_address(QTestState *qts, uint64_t base= _addr, uint8_t addr, qtest_writeb(qts, base_addr + OFFSET_ST, ST_STASTR); st =3D qtest_readb(qts, base_addr + OFFSET_ST); if (recv) { - g_assert_cmphex(st, =3D=3D, ST_MODE | ST_SDAST); + g_assert_true(check_recv(qts, base_addr)); } else { g_assert_cmphex(st, =3D=3D, ST_MODE | ST_XMIT | ST_SDAST); } @@ -251,6 +312,29 @@ static void send_nack(QTestState *qts, uint64_t base_a= ddr) qtest_writeb(qts, base_addr + OFFSET_CTL1, ctl1); } =20 +static void start_fifo_mode(QTestState *qts, uint64_t base_addr) +{ + choose_bank(qts, base_addr, 0); + qtest_writeb(qts, base_addr + OFFSET_FIF_CTL, FIF_CTL_FIFO_EN); + g_assert_true(qtest_readb(qts, base_addr + OFFSET_FIF_CTL) & + FIF_CTL_FIFO_EN); + choose_bank(qts, base_addr, 1); + qtest_writeb(qts, base_addr + OFFSET_FIF_CTS, + FIF_CTS_CLR_FIFO | FIF_CTS_RFTE_IE); + g_assert_cmphex(qtest_readb(qts, base_addr + OFFSET_FIF_CTS), =3D=3D, + FIF_CTS_RFTE_IE); + g_assert_cmphex(qtest_readb(qts, base_addr + OFFSET_TXF_STS), =3D=3D, = 0); + g_assert_cmphex(qtest_readb(qts, base_addr + OFFSET_RXF_STS), =3D=3D, = 0); +} + +static void start_recv_fifo(QTestState *qts, uint64_t base_addr, uint8_t b= ytes) +{ + choose_bank(qts, base_addr, 1); + qtest_writeb(qts, base_addr + OFFSET_TXF_CTL, 0); + qtest_writeb(qts, base_addr + OFFSET_RXF_CTL, + RXF_CTL_THR_RXIE | RXF_CTL_LAST | bytes); +} + /* Check the SMBus's status is set correctly when disabled. */ static void test_disable_bus(gconstpointer data) { @@ -324,6 +408,64 @@ static void test_single_mode(gconstpointer data) qtest_quit(qts); } =20 +/* Check the SMBus can send and receive bytes in FIFO mode. */ +static void test_fifo_mode(gconstpointer data) +{ + intptr_t index =3D (intptr_t)data; + uint64_t base_addr =3D SMBUS_ADDR(index); + int irq =3D SMBUS_IRQ(index); + uint8_t value =3D 0x60; + QTestState *qts =3D qtest_init("-machine npcm750-evb"); + + qtest_irq_intercept_in(qts, "/machine/soc/a9mpcore/gic"); + enable_bus(qts, base_addr); + start_fifo_mode(qts, base_addr); + g_assert_false(qtest_get_irq(qts, irq)); + + /* Sending */ + start_transfer(qts, base_addr); + send_address(qts, base_addr, EVB_DEVICE_ADDR, false, true); + choose_bank(qts, base_addr, 1); + g_assert_true(qtest_readb(qts, base_addr + OFFSET_FIF_CTS) & + FIF_CTS_RXF_TXE); + qtest_writeb(qts, base_addr + OFFSET_TXF_CTL, TXF_CTL_THR_TXIE); + send_byte(qts, base_addr, TMP105_REG_CONFIG); + send_byte(qts, base_addr, value); + g_assert_true(qtest_readb(qts, base_addr + OFFSET_FIF_CTS) & + FIF_CTS_RXF_TXE); + g_assert_true(qtest_readb(qts, base_addr + OFFSET_TXF_STS) & + TXF_STS_TX_THST); + g_assert_cmpuint(TXF_STS_TX_BYTES( + qtest_readb(qts, base_addr + OFFSET_TXF_STS)), =3D= =3D, 0); + g_assert_true(qtest_get_irq(qts, irq)); + stop_transfer(qts, base_addr); + check_stopped(qts, base_addr); + + /* Receiving */ + start_fifo_mode(qts, base_addr); + start_transfer(qts, base_addr); + send_address(qts, base_addr, EVB_DEVICE_ADDR, false, true); + send_byte(qts, base_addr, TMP105_REG_CONFIG); + start_transfer(qts, base_addr); + qtest_writeb(qts, base_addr + OFFSET_FIF_CTS, FIF_CTS_RXF_TXE); + start_recv_fifo(qts, base_addr, 1); + send_address(qts, base_addr, EVB_DEVICE_ADDR, true, true); + g_assert_false(qtest_readb(qts, base_addr + OFFSET_FIF_CTS) & + FIF_CTS_RXF_TXE); + g_assert_true(qtest_readb(qts, base_addr + OFFSET_RXF_STS) & + RXF_STS_RX_THST); + g_assert_cmpuint(RXF_STS_RX_BYTES( + qtest_readb(qts, base_addr + OFFSET_RXF_STS)), =3D= =3D, 1); + send_nack(qts, base_addr); + stop_transfer(qts, base_addr); + check_running(qts, base_addr); + g_assert_cmphex(recv_byte(qts, base_addr), =3D=3D, value); + g_assert_cmpuint(RXF_STS_RX_BYTES( + qtest_readb(qts, base_addr + OFFSET_RXF_STS)), =3D= =3D, 0); + check_stopped(qts, base_addr); + qtest_quit(qts); +} + static void smbus_add_test(const char *name, int index, GTestDataFunc fn) { g_autofree char *full_name =3D g_strdup_printf( @@ -346,6 +488,7 @@ int main(int argc, char **argv) =20 for (i =3D 0; i < ARRAY_SIZE(evb_bus_list); ++i) { add_test(single_mode, evb_bus_list[i]); + add_test(fifo_mode, evb_bus_list[i]); } =20 return g_test_run(); --=20 2.30.0.365.g02bc693789-goog