From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from EUR03-VE1-obe.outbound.protection.outlook.com (EUR03-VE1-obe.outbound.protection.outlook.com [40.107.5.76]) by mx.groups.io with SMTP id smtpd.web12.9827.1586866489971209471 for ; Tue, 14 Apr 2020 05:14:50 -0700 Authentication-Results: mx.groups.io; dkim=fail reason="body hash did not verify" header.i=@nxp1.onmicrosoft.com header.s=selector2-nxp1-onmicrosoft-com header.b=PNhBIP1P; spf=pass (domain: oss.nxp.com, ip: 40.107.5.76, mailfrom: pankaj.bansal@oss.nxp.com) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=jP4pPRw448FiWudNMTxJ4c7MNPp8uTcDgTEJsv8rOHqLmeCdNJrfu27Ao8/rHzS08n/SOI2KF+mCKwIAcTl7+bu5l9l19h22021vKMEv0zZGOUYK+RBvKcxPm0Bw5iFowmgxC75Q+uCElxiFdYTbb1R9TBx/j2kmaUw6oZ5LV9Y7bcThTZFdPDnaZt2rTRtGbVqw8eX8Z19OAkOOS+0X30Mhz9LI46MqfdXbafPMgF7/QHEOk37FRg0yDRTVmRrPVVuzj/QfnISauQwnTVICf6pAhBn22wbBscXb2eLbiu10deQR1bQV7W0CDHwofPl+Qm/QjbB7FsOd3PrjPilOYA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=0H9a6Y26YNNKdkuAv6zM7omVafArUbu3YT/i3rH5QOw=; b=I9eQtQGfxmn57ZtZS6jWaBUmR6UZyy7UuZ5xlRK29A2741kQ19iqT5WvfRaNEm4bBWzGGHCD5ADkQdSEcqrU2e4P1g2apFdkvjMP95iyPnzVArsgFh/VJ+iBLDcbKQvIThde4q5J6TSTEdH0ftYh/5NPsKkzKFiDdJDqHdR9mY/X1mx1UEOjDR5pnZZx3es3Vi/vuVSM8h10+LoNL+tqrrgXPopmoN+a2cYLLSVkpbqdw8OHYRfcVRvPROhZA7RgDRb/9a4fQu939vCgJyqwOZvNJgXHpVMBr8CupGIfUsXZSNfN7GPFe6qSy0+cUO+igMJbN3gYvFhTTwLRWkd+Gg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=oss.nxp.com; dmarc=pass action=none header.from=oss.nxp.com; dkim=pass header.d=oss.nxp.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=NXP1.onmicrosoft.com; s=selector2-NXP1-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=0H9a6Y26YNNKdkuAv6zM7omVafArUbu3YT/i3rH5QOw=; b=PNhBIP1Pgx6DJkFPsnueGIUA+4Mshrak8ZW1P+x9cGxrTrOSJCrP0u3QILiSr3W9HL573545yOqZJE3994K3vDfbyFXbNiFKWhf/GlFDOrAKy8Y/qRiRpxC4qwDC2lFVNNjAkoWsWIJ6PToEBYRhNZ+b/EVKpfFeGak87zc4lik= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=pankaj.bansal@oss.nxp.com; Received: from VI1PR04MB5933.eurprd04.prod.outlook.com (2603:10a6:803:ec::16) by VI1PR04MB4461.eurprd04.prod.outlook.com (2603:10a6:803:70::33) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2900.28; Tue, 14 Apr 2020 12:14:47 +0000 Received: from VI1PR04MB5933.eurprd04.prod.outlook.com ([fe80::45c4:8846:5327:9513]) by VI1PR04MB5933.eurprd04.prod.outlook.com ([fe80::45c4:8846:5327:9513%7]) with mapi id 15.20.2900.028; Tue, 14 Apr 2020 12:14:47 +0000 From: "Pankaj Bansal" To: Leif Lindholm , Meenakshi Aggarwal , Michael D Kinney , devel@edk2.groups.io, Varun Sethi , Samer El-Haj-Mahmoud , Jon Nettleton , Ard Biesheuvel Subject: [PATCH edk2-platforms v3 01/24] Silicon/NXP: Add I2c lib Date: Wed, 15 Apr 2020 17:43:19 +0530 Message-ID: <20200415121342.9246-2-pankaj.bansal@oss.nxp.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200415121342.9246-1-pankaj.bansal@oss.nxp.com> References: <20200415121342.9246-1-pankaj.bansal@oss.nxp.com> X-ClientProxiedBy: SG2PR01CA0092.apcprd01.prod.exchangelabs.com (2603:1096:3:15::18) To VI1PR04MB5933.eurprd04.prod.outlook.com (2603:10a6:803:ec::16) Return-Path: pankaj.bansal@oss.nxp.com MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 Received: from uefi-workstation.ap.freescale.net (92.120.0.69) by SG2PR01CA0092.apcprd01.prod.exchangelabs.com (2603:1096:3:15::18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2900.15 via Frontend Transport; Tue, 14 Apr 2020 12:14:44 +0000 X-Mailer: git-send-email 2.17.1 X-Originating-IP: [92.120.0.69] X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-HT: Tenant X-MS-Office365-Filtering-Correlation-Id: 8735c1ac-30bf-4c5f-c55a-08d7e06d6c1b X-MS-TrafficTypeDiagnostic: VI1PR04MB4461:|VI1PR04MB4461: X-MS-Exchange-SharedMailbox-RoutingAgent-Processed: True X-MS-Exchange-Transport-Forked: True X-Microsoft-Antispam-PRVS: X-MS-Oob-TLC-OOBClassifiers: OLM:7219; X-Forefront-PRVS: 0373D94D15 X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:VI1PR04MB5933.eurprd04.prod.outlook.com;PTR:;CAT:NONE;SFTY:;SFS:(10009020)(4636009)(376002)(366004)(346002)(136003)(39850400004)(396003)(966005)(30864003)(1076003)(186003)(8936002)(16526019)(86362001)(110136005)(26005)(478600001)(81156014)(8676002)(6512007)(66946007)(316002)(44832011)(66476007)(66556008)(52116002)(5660300002)(6666004)(2906002)(6486002)(6506007)(956004)(19627235002)(2616005);DIR:OUT;SFP:1101; Received-SPF: None (protection.outlook.com: oss.nxp.com does not designate permitted sender hosts) X-MS-Exchange-SenderADCheck: 1 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 4QLZyz+B7KzWzqJ/sZlGTLkc6UWRP7CjemuF91bdDW04/rsR/KtMMsI8HTxbfiWFuxiDFf6xFUGEnmgcKRYPAHXonoYQz3jYyfvMZlv7j1yH7LHYVaSoo76qUjfAGHdsRERa1RCtaG/8oEUfPqnUfTaH1lDXaw4pP6y4veVGIkYJSwh9+MRq7I5j2n6SqL0TCzv/sG+cjusRqxohyVqaNC1JWzvtpFdGkvJwiRcOUHj93JYpAaMgETqyUM5LWka1WR54MPkZQfvPGWGcSzOLEFv4SLxpyHXPHZNjVitLOcEX5HKeWC30z0mENJyqklNN1P197tx+hVOWFN5oPxAU5lmjAJ+xQymxaZkO+Xk8FMpsndlfKSuGq4suEAxP8UO3UBKlCzhfaDC1Al/YF27x+yn6HMnvilpsnAub/Y5Qb08CG+R4AEWZn3n9GKyIPgeF31ZCdDBYDquIlpgqsTgSJGghrX6LhlMrqj0DvSp6b4q/ksSWhJpfRC8QtjxItCGjXqR1TqVneGGhQsgl1otgUg== X-MS-Exchange-AntiSpam-MessageData: dhpf12aLyhZylzCkCN77UJXZXISb7ozcOCo/y9ehjRfguHGgOkeXFeJrNgFh35Fb6b//vxPeCi8rLLNKTwAAFVJtDHaIP0L/O3ydT0c//XmkxvfmdxWuF5G4Tku5/Axayw2DBnpCVFNaHWdBnGayAQ== X-OriginatorOrg: oss.nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: 8735c1ac-30bf-4c5f-c55a-08d7e06d6c1b X-MS-Exchange-CrossTenant-OriginalArrivalTime: 14 Apr 2020 12:14:47.1837 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: 4BlwZqHOk3J6mwWtvRr/SVfqY53syfCCmp+nPG+zig5fxSVHLk2fQmQkg3RhGqSP21i8Ae5MVLIkoqxzWVBtxg== X-MS-Exchange-Transport-CrossTenantHeadersStamped: VI1PR04MB4461 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain From: Pankaj Bansal I2c lib is going to be used in PrePeiCore sec module to get the System clock information from devices connected to i2c (like fpga or clock generator) since we don't have support of DXE modules this early in boot stage, move the i2c controller functionality in library. This I2cLib is not bug fix over I2cDxe. The I2cLib has been completely re-written and not code movement from I2cDxe to I2cLib This is because I2cDxe has been written assuming that the I2c transaction would always be of minimum two operations. But this may not be the case always. e.g. RTC write in PCF2129 is single operation. Also the I2cDxe driver doesn't generate repeat start if i2c transaction is more than two operations, it generates stop. This violates PI I2C spec. Now we have removed these assumptions as well as added repeat start between successive operations, which comply with PI I2C spec. Signed-off-by: Pankaj Bansal --- Notes: - moved I2cLib addition in NxpQoriqLs.dsc.inc to PATCH 2 - Added Qoriq Layerscape in description of CLOCK_DIVISOR_PAIR - ERRXXXXXX -> A-XXXXXX - Added u-boot patch reference to errata workaround description - Added Glossary and Revision Reference in file header - Dividor -> divider - Added explaination before calling I2cErratumA009203 - PtrAddress -> AddressPtr - Update commit description Silicon/NXP/NxpQoriqLs.dec | 10 +- Silicon/NXP/Library/I2cLib/I2cLib.inf | 31 ++ Silicon/NXP/Include/Library/I2cLib.h | 120 ++++ Silicon/NXP/Library/I2cLib/I2cLibInternal.h | 105 ++++ Silicon/NXP/Library/I2cLib/I2cLib.c | 589 ++++++++++++++++++++ 5 files changed, 854 insertions(+), 1 deletion(-) diff --git a/Silicon/NXP/NxpQoriqLs.dec b/Silicon/NXP/NxpQoriqLs.dec index 764b9bb0e2d3..4a1cfb3e278e 100644 --- a/Silicon/NXP/NxpQoriqLs.dec +++ b/Silicon/NXP/NxpQoriqLs.dec @@ -1,6 +1,6 @@ # @file. # -# Copyright 2017-2019 NXP +# Copyright 2017-2020 NXP # # SPDX-License-Identifier: BSD-2-Clause-Patent # @@ -13,6 +13,10 @@ [Includes] Include =20 +[LibraryClasses] + ## @libraryclass Provides services to read/write to I2c devices + I2cLib|Include/Library/I2cLib.h + [Guids.common] gNxpQoriqLsTokenSpaceGuid =3D {0x98657342, 0x4aee, 0x4fc6, {0xbc, 0= xb5, 0xff, 0x45, 0xb7, 0xa8, 0x71, 0xf2}} gNxpNonDiscoverableI2cMasterGuid =3D { 0x5f2c099c, 0x54a3, 0x4dd4, {0x9e= , 0xc5, 0xe9, 0x12, 0x8c, 0x36, 0x81, 0x6a}} @@ -101,3 +105,7 @@ gNxpQoriqLsTokenSpaceGuid.PcdPciLutBigEndian|FALSE|BOOLEAN|0x00000312 gNxpQoriqLsTokenSpaceGuid.PcdWatchdogBigEndian|FALSE|BOOLEAN|0x00000313 gNxpQoriqLsTokenSpaceGuid.PcdIfcBigEndian|FALSE|BOOLEAN|0x00000314 + +[PcdsFeatureFlag] + gNxpQoriqLsTokenSpaceGuid.PcdI2cErratumA009203|FALSE|BOOLEAN|0x00000315 + diff --git a/Silicon/NXP/Library/I2cLib/I2cLib.inf b/Silicon/NXP/Library/I2= cLib/I2cLib.inf new file mode 100644 index 000000000000..b9bd79ac1ef1 --- /dev/null +++ b/Silicon/NXP/Library/I2cLib/I2cLib.inf @@ -0,0 +1,31 @@ +# @file +# +# Component description file for I2cLib module +# Copyright 2017, 2020 NXP +# +# SPDX-License-Identifier: BSD-2-Clause-Patent +# +# + +[Defines] + INF_VERSION =3D 0x0001001A + BASE_NAME =3D I2cLib + FILE_GUID =3D 8ecefc8f-a2c4-4091-b81f-20f7aeb0567f + MODULE_TYPE =3D BASE + VERSION_STRING =3D 1.0 + LIBRARY_CLASS =3D I2cLib + +[Sources.common] + I2cLib.c + +[LibraryClasses] + IoLib + TimerLib + +[Packages] + MdePkg/MdePkg.dec + Silicon/NXP/NxpQoriqLs.dec + +[FeaturePcd] + gNxpQoriqLsTokenSpaceGuid.PcdI2cErratumA009203 + diff --git a/Silicon/NXP/Include/Library/I2cLib.h b/Silicon/NXP/Include/Lib= rary/I2cLib.h new file mode 100644 index 000000000000..e39237abd3ee --- /dev/null +++ b/Silicon/NXP/Include/Library/I2cLib.h @@ -0,0 +1,120 @@ +/** @file + I2c Lib to control I2c controller. + + Copyright 2020 NXP + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#ifndef I2C_LIB_H__ +#define I2C_LIB_H__ + +#include +#include + +/** + software reset of the entire I2C module. + The module is reset and disabled. + Status register fields (IBSR) are cleared. + + @param[in] Base Base Address of I2c controller's registers + + @return EFI_SUCCESS successfuly reset the I2c module +**/ +EFI_STATUS +I2cReset ( + IN UINTN Base + ); + +/** + Early init I2C for reading the sysclk from I2c slave device. + I2c bus clock is determined from the clock input to I2c controller. + The clock input to I2c controller is derived from the sysclk. + sysclk is determined by clock generator, which is controller by i2c. + + So, it's a chicken-egg problem to read the sysclk from clock generator. + To break this cycle (i.e. to read the sysclk), we setup the i2c bus cloc= k to + lowest value, in the hope that it won't be out of clock generator's supp= orted + i2c clock frequency. Once we have the correct sysclk, we can setup the + correct i2c bus clock. + + @param[in] Base Base Address of I2c controller's registers + + @return EFI_SUCCESS successfuly setup the i2c bus for reading sysclk +**/ +EFI_STATUS +I2cEarlyInitialize ( + IN UINTN Base + ); + +/** + Configure I2c bus to operate at a given speed + + @param[in] Base Base Address of I2c controller's registers + @param[in] I2cBusClock Input clock to I2c controller + @param[in] Speed speed to be configured for I2c bus + + @return EFI_SUCCESS successfuly setup the i2c bus +**/ +EFI_STATUS +I2cInitialize ( + IN UINTN Base, + IN UINT64 I2cBusClock, + IN UINT64 Speed + ); + +/** + Transfer data to/from I2c slave device + + @param[in] Base Base Address of I2c controller's registers + @param[in] SlaveAddress Slave Address from which data is to be read + @param[in] RequestPacket Pointer to an EFI_I2C_REQUEST_PACKET structure + describing the I2C transaction + + @return EFI_SUCCESS successfuly transfer the data + @return EFI_DEVICE_ERROR There was an error while transferring data th= rough + I2c bus + @return EFI_NO_RESPONSE There was no Ack from i2c device + @return EFI_TIMEOUT I2c Bus is busy + @return EFI_NOT_READY I2c Bus Arbitration lost +**/ +EFI_STATUS +I2cBusXfer ( + IN UINTN Base, + IN UINT32 SlaveAddress, + IN EFI_I2C_REQUEST_PACKET *RequestPacket + ); + +/** + Read a register from I2c slave device. This API is wrapper around I2cBus= Xfer + + @param[in] Base Base Address of I2c controller's regi= sters + @param[in] SlaveAddress Slave Address from which register val= ue is + to be read + @param[in] RegAddress Register Address in Slave's memory ma= p + @param[in] RegAddressWidthInBytes Number of bytes in RegAddress to send= to + I2c Slave for simple reads without an= y + register, make this value =3D 0 + (RegAddress is don't care in that cas= e) + @param[out] RegValue Value to be read from I2c slave's reg= iser + @param[in] RegValueNumBytes Number of bytes to read from I2c slav= e + register + + @return EFI_SUCCESS successfuly read the registers + @return EFI_DEVICE_ERROR There was an error while transferring data th= rough + I2c bus + @return EFI_NO_RESPONSE There was no Ack from i2c device + @return EFI_TIMEOUT I2c Bus is busy + @return EFI_NOT_READY I2c Bus Arbitration lost +**/ +EFI_STATUS +I2cBusReadReg ( + IN UINTN Base, + IN UINT32 SlaveAddress, + IN UINT64 RegAddress, + IN UINT8 RegAddressWidthInBytes, + OUT UINT8 *RegValue, + IN UINT32 RegValueNumBytes + ); + +#endif // I2C_LIB_H__ diff --git a/Silicon/NXP/Library/I2cLib/I2cLibInternal.h b/Silicon/NXP/Libr= ary/I2cLib/I2cLibInternal.h new file mode 100644 index 000000000000..2ca4a3639d2c --- /dev/null +++ b/Silicon/NXP/Library/I2cLib/I2cLibInternal.h @@ -0,0 +1,105 @@ +/** @file + I2c Lib to control I2c controller. + + Copyright 2020 NXP + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#ifndef I2C_LIB_INTERNAL_H__ +#define I2C_LIB_INTERNAL_H__ + +#include +#include + +/** Module Disable + 0b - The module is enabled. You must clear this field before any other I= BCR + fields have any effect. + 1b - The module is reset and disabled. This is the power-on reset situat= ion. + When high, the interface is held in reset, but registers can still = be + accessed. Status register fields (IBSR) are not valid when the modu= le + is disabled. +**/ +#define I2C_IBCR_MDIS BIT7 +// I2c Bus Interrupt Enable +#define I2C_IBCR_IBIE BIT6 +/** Master / Slave Mode 0b - Slave mode 1b - Master mode + When you change this field from 0 to 1, the module generates a START sig= nal + on the bus and selects the master mode. When you change this field from = 1 to + 0, the module generates a STOP signal and changes the operation mode fro= m + master to slave. You should generate a STOP signal only if IBSR[IBIF]=3D= 1. + The module clears this field without generating a STOP signal when the + master loses arbitration. +*/ +#define I2C_IBCR_MSSL BIT5 +// 0b - Receive 1b - Transmit +#define I2C_IBCR_TXRX BIT4 +/** Data acknowledge disable + Values written to this field are only used when the I2C module is a rece= iver, + not a transmitter. + 0b - The module sends an acknowledge signal to the bus at the 9th clock = bit + after receiving one byte of data. + 1b - The module does not send an acknowledge-signal response (that is, + acknowledge bit =3D 1). +**/ +#define I2C_IBCR_NOACK BIT3 +/**Repeat START + If the I2C module is the current bus master, and you program RSTA=3D1, t= he I2C + module generates a repeated START condition. This field always reads as = a 0. + If you attempt a repeated START at the wrong time, if the bus is owned b= y + another master the result is loss of arbitration. +**/ +#define I2C_IBCR_RSTA BIT2 +// DMA enable +#define I2C_IBCR_DMAEN BIT1 + +// Transfer Complete +#define I2C_IBSR_TCF BIT7 +// I2C bus Busy. 0b - Bus is idle, 1b - Bus is busy +#define I2C_IBSR_IBB BIT5 +// Arbitration Lost. software must clear this field by writing a one to it= . +#define I2C_IBSR_IBAL BIT4 +// I2C bus interrupt flag +#define I2C_IBSR_IBIF BIT1 +// Received acknowledge 0b - Acknowledge received 1b - No acknowledge rece= ived +#define I2C_IBSR_RXAK BIT0 + +//Bus idle interrupt enable +#define I2C_IBIC_BIIE BIT7 + +// Glitch filter enable +#define I2C_IBDBG_GLFLT_EN BIT3 + +#define I2C_BUS_TEST_BUSY TRUE +#define I2C_BUS_TEST_IDLE !I2C_BUS_TEST_BUSY +#define I2C_BUS_TEST_RX_ACK TRUE +#define I2C_BUS_NO_TEST_RX_ACK !I2C_BUS_TEST_RX_ACK + +#define ARRAY_LAST_ELEM(x) (x)[ARRAY_SIZE (x) - 1] +#define I2C_NUM_RETRIES 500 + +typedef struct _I2C_REGS { + UINT8 Ibad; // I2c Bus Address Register + UINT8 Ibfd; // I2c Bus Frequency Dividor Register + UINT8 Ibcr; // I2c Bus Control Register + UINT8 Ibsr; // I2c Bus Status Register + UINT8 Ibdr; // I2C Bus Data I/O Register + UINT8 Ibic; // I2C Bus Interrupt Config Register + UINT8 Ibdbg; // I2C Bus Debug Register +} I2C_REGS; + +/* + * sorted list of clock divisor, Ibfd register value pairs + */ +typedef struct _I2C_CLOCK_DIVISOR_PAIR { + UINT16 Divisor; + UINT16 Ibfd; // I2c Bus Frequency Dividor Register value +} I2C_CLOCK_DIVISOR_PAIR; + +typedef struct { + UINTN OperationCount; + EFI_I2C_OPERATION Operation[2]; +} I2C_REG_REQUEST; + +#endif // I2C_LIB_INTERNAL_H__ + diff --git a/Silicon/NXP/Library/I2cLib/I2cLib.c b/Silicon/NXP/Library/I2cL= ib/I2cLib.c new file mode 100644 index 000000000000..34443cdaf763 --- /dev/null +++ b/Silicon/NXP/Library/I2cLib/I2cLib.c @@ -0,0 +1,589 @@ +/** @file + I2c Lib to control I2c controller. + + Copyright 2017, 2020 NXP + + SPDX-License-Identifier: BSD-2-Clause-Patent + + @par Revision Reference: + - PI Version 1.7 + + @par Glossary: + - Ibfd - I2c Bus Frequency Divider +**/ +#include +#include +#include +#include +#include + +#include "I2cLibInternal.h" + +/** + I2C divisor and Ibfd register values when glitch filter is enabled + + In case of duplicate SCL Divisor value, the Ibfd value with high MUL val= ue + has been selected. A higher MUL value results in a lower sampling rate o= f + the I2C signals. This gives the I2C module greater immunity against glit= ches + in the I2C signals. + + These values can be referred from NXP QorIQ Layerscape series SOC Refere= nce + Manual in which this I2C ip has been used. e.g. LX2160ARM, LS1043ARM +**/ +STATIC CONST I2C_CLOCK_DIVISOR_PAIR mI2cClockDivisorGlitchEnabled[] =3D { + { 34, 0x0 }, { 36, 0x1 }, { 38, 0x2 }, { 40, 0x3 }, + { 42, 0x4 }, { 44, 0x8 }, { 48, 0x9 }, { 52, 0xA }, + { 54, 0x7 }, { 56, 0xB }, { 60, 0xC }, { 64, 0x10 }, + { 68, 0x40 }, { 72, 0x41 }, { 76, 0x42 }, { 80, 0x43 }, + { 84, 0x44 }, { 88, 0x48 }, { 96, 0x49 }, { 104, 0x4A }, + { 108, 0x47 }, { 112, 0x4B }, { 120, 0x4C }, { 128, 0x50 }, + { 136, 0x80 }, { 144, 0x81 }, { 152, 0x82 }, { 160, 0x83 }, + { 168, 0x84 }, { 176, 0x88 }, { 192, 0x89 }, { 208, 0x8A }, + { 216, 0x87 }, { 224, 0x8B }, { 240, 0x8C }, { 256, 0x90 }, + { 288, 0x91 }, { 320, 0x92 }, { 336, 0x8F }, { 352, 0x93 }, + { 384, 0x98 }, { 416, 0x95 }, { 448, 0x99 }, { 480, 0x96 }, + { 512, 0x9A }, { 576, 0x9B }, { 640, 0xA0 }, { 704, 0x9D }, + { 768, 0xA1 }, { 832, 0x9E }, { 896, 0xA2 }, { 960, 0x67 }, + { 1024, 0xA3 }, { 1152, 0xA4 }, { 1280, 0xA8 }, { 1536, 0xA9 }, + { 1792, 0xAA }, { 1920, 0xA7 }, { 2048, 0xAB }, { 2304, 0xAC }, + { 2560, 0xB0 }, { 3072, 0xB1 }, { 3584, 0xB2 }, { 3840, 0xAF }, + { 4096, 0xB3 }, { 4608, 0xB4 }, { 5120, 0xB8 }, { 6144, 0xB9 }, + { 7168, 0xBA }, { 7680, 0xB7 }, { 8192, 0xBB }, { 9216, 0xBC }, + { 10240, 0xBD }, { 12288, 0xBE }, { 15360, 0xBF } +}; + +/** + I2C divisor and Ibfd register values when glitch filter is disabled + + In case of duplicate SCL Divisor value, the Ibfd value with high MUL val= ue + has been selected. A higher MUL value results in a lower sampling rate o= f + the I2C signals. This gives the I2C module greater immunity against glit= ches + in the I2C signals. + + These values can be referred from NXP QorIQ Layerscape series SOC Refere= nce + Manual in which this I2C ip has been used. e.g. LX2160ARM, LS1043ARM +**/ +STATIC CONST I2C_CLOCK_DIVISOR_PAIR mI2cClockDivisorGlitchDisabled[] =3D { + { 20, 0x0 },{ 22, 0x1 },{ 24, 0x2 },{ 26, 0x3 }, + { 28, 0x8 },{ 30, 0x5 },{ 32, 0x9 },{ 34, 0x6 }, + { 36, 0x0A },{ 40, 0x40 },{ 44, 0x41 },{ 48, 0x42 }, + { 52, 0x43 },{ 56, 0x48 },{ 60, 0x45 },{ 64, 0x49 }, + { 68, 0x46 },{ 72, 0x4A },{ 80, 0x80 },{ 88, 0x81 }, + { 96, 0x82 },{ 104, 0x83 },{ 112, 0x88 },{ 120, 0x85 }, + { 128, 0x89 },{ 136, 0x86 },{ 144, 0x8A },{ 160, 0x8B }, + { 176, 0x8C },{ 192, 0x90 },{ 208, 0x56 },{ 224, 0x91 }, + { 240, 0x1F },{ 256, 0x92 },{ 272, 0x8F },{ 288, 0x93 }, + { 320, 0x98 },{ 352, 0x95 },{ 384, 0x99 },{ 416, 0x96 }, + { 448, 0x9A },{ 480, 0x5F },{ 512, 0x9B },{ 576, 0x9C }, + { 640, 0xA0 },{ 768, 0xA1 },{ 896, 0xA2 },{ 960, 0x9F }, + { 1024, 0xA3 },{ 1152, 0xA4 },{ 1280, 0xA8 },{ 1536, 0xA9 }, + { 1792, 0xAA },{ 1920, 0xA7 },{ 2048, 0xAB },{ 2304, 0xAC }, + { 2560, 0xAD },{ 3072, 0xB1 },{ 3584, 0xB2 },{ 3840, 0xAF }, + { 4096, 0xB3 },{ 4608, 0xB4 },{ 5120, 0xB8 },{ 6144, 0xB9 }, + { 7168, 0xBA },{ 7680, 0xB7 },{ 8192, 0xBB },{ 9216, 0xBC }, + { 10240, 0xBD },{ 12288, 0xBE },{ 15360, 0xBF } +}; + +/** + A-009203 : I2C may not work reliably with the default setting + + Description : The clocking circuitry of I2C module may not work reliably= due + to the slow rise time of SCL signal. + Workaround : Enable the receiver digital filter by setting IBDBG[GLFLT_= EN] + to 1. refer https://patchwork.ozlabs.org/patch/453575/ +**/ +STATIC +VOID +I2cErratumA009203 ( + IN UINTN Base + ) +{ + I2C_REGS *Regs; + + Regs =3D (I2C_REGS *)Base; + + MmioOr8 ((UINTN)&Regs->Ibdbg, I2C_IBDBG_GLFLT_EN); +} + +/** + software reset of the entire I2C module. + The module is reset and disabled. + Status register fields (IBSR) are cleared. + + @param[in] Base Base Address of I2c controller's registers + + @return EFI_SUCCESS successfuly reset the I2c module +**/ +EFI_STATUS +I2cReset ( + IN UINTN Base + ) +{ + I2C_REGS *Regs; + + Regs =3D (I2C_REGS *)Base; + + MmioOr8 ((UINTN)&Regs->Ibcr, I2C_IBCR_MDIS); + MmioOr8 ((UINTN)&Regs->Ibsr, (I2C_IBSR_IBAL | I2C_IBSR_IBIF)); + MmioAnd8 ((UINTN)&Regs->Ibcr, ~(I2C_IBCR_IBIE | I2C_IBCR_DMAEN)); + MmioAnd8 ((UINTN)&Regs->Ibic, (UINT8)(~I2C_IBIC_BIIE)); + + return EFI_SUCCESS; +} + +/** + Early init I2C for reading the sysclk from I2c slave device. + I2c bus clock is determined from the clock input to I2c controller. + The clock input to I2c controller is derived from the sysclk. + sysclk is determined by clock generator, which is controller by i2c. + + So, it's a chicken-egg problem to read the sysclk from clock generator. + To break this cycle (i.e. to read the sysclk), we setup the i2c bus cloc= k to + lowest value, in the hope that it won't be out of clock generator's supp= orted + i2c clock frequency. Once we have the correct sysclk, we can setup the + correct i2c bus clock. + + @param[in] Base Base Address of I2c controller's registers + + @return EFI_SUCCESS successfuly setup the i2c bus for reading sysclk +**/ +EFI_STATUS +I2cEarlyInitialize ( + IN UINTN Base + ) +{ + I2C_REGS *Regs; + UINT8 Ibfd; + + Regs =3D (I2C_REGS *)Base; + if (FeaturePcdGet (PcdI2cErratumA009203)) { + // Apply Erratum A-009203 before writing Ibfd register + I2cErratumA009203 (Base); + } + + if (MmioRead8 ((UINTN)&Regs->Ibdbg) & I2C_IBDBG_GLFLT_EN) { + Ibfd =3D ARRAY_LAST_ELEM (mI2cClockDivisorGlitchEnabled).Ibfd; + } else { + Ibfd =3D ARRAY_LAST_ELEM (mI2cClockDivisorGlitchDisabled).Ibfd; + } + + MmioWrite8 ((UINTN)&Regs->Ibfd, Ibfd); + + I2cReset (Base); + + return EFI_SUCCESS; +} + +/** + Configure I2c bus to operate at a given speed + + @param[in] Base Base Address of I2c controller's registers + @param[in] I2cBusClock Input clock to I2c controller + @param[in] Speed speed to be configured for I2c bus + + @return EFI_SUCCESS successfuly setup the i2c bus +**/ +EFI_STATUS +I2cInitialize ( + IN UINTN Base, + IN UINT64 I2cBusClock, + IN UINT64 Speed + ) +{ + I2C_REGS *Regs; + UINT16 ClockDivisor; + UINT8 Ibfd; // I2c Bus Frequency Divider Regist= er + CONST I2C_CLOCK_DIVISOR_PAIR *ClockDivisorPair; + UINT32 ClockDivisorPairSize; + UINT32 Index; + + Regs =3D (I2C_REGS *)Base; + if (FeaturePcdGet (PcdI2cErratumA009203)) { + // Apply Erratum A-009203 before writing Ibfd register + I2cErratumA009203 (Base); + } + + Ibfd =3D 0; + ClockDivisor =3D (I2cBusClock + Speed - 1) / Speed; + + if (MmioRead8 ((UINTN)&Regs->Ibdbg) & I2C_IBDBG_GLFLT_EN) { + ClockDivisorPair =3D mI2cClockDivisorGlitchEnabled; + ClockDivisorPairSize =3D ARRAY_SIZE (mI2cClockDivisorGlitchEnabled); + } else { + ClockDivisorPair =3D mI2cClockDivisorGlitchDisabled; + ClockDivisorPairSize =3D ARRAY_SIZE (mI2cClockDivisorGlitchDisabled); + } + + if (ClockDivisor > ClockDivisorPair[ClockDivisorPairSize - 1].Divisor) { + Ibfd =3D ClockDivisorPair[ClockDivisorPairSize - 1].Ibfd; + } else { + for (Index =3D 0; Index < ClockDivisorPairSize; Index++) { + if (ClockDivisorPair[Index].Divisor >=3D ClockDivisor) { + Ibfd =3D ClockDivisorPair[Index].Ibfd; + break; + } + } + } + + MmioWrite8 ((UINTN)&Regs->Ibfd, Ibfd); + + I2cReset (Base); + + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +I2cBusTestBusBusy ( + IN I2C_REGS *Regs, + IN BOOLEAN TestBusy + ) +{ + UINT32 Index; + UINT8 Reg; + + for (Index =3D 0; Index < I2C_NUM_RETRIES; Index++) { + Reg =3D MmioRead8 ((UINTN)&Regs->Ibsr); + + if (Reg & I2C_IBSR_IBAL) { + MmioWrite8 ((UINTN)&Regs->Ibsr, Reg); + return EFI_NOT_READY; + } + + if (TestBusy && (Reg & I2C_IBSR_IBB)) { + break; + } + + if (!TestBusy && !(Reg & I2C_IBSR_IBB)) { + break; + } + + MicroSecondDelay (1); + } + + if (Index =3D=3D I2C_NUM_RETRIES) { + return EFI_TIMEOUT; + } + + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +I2cTransferComplete ( + IN I2C_REGS *Regs, + IN BOOLEAN TestRxAck +) +{ + UINT32 Index; + UINT8 Reg; + + for (Index =3D 0; Index < I2C_NUM_RETRIES; Index++) { + Reg =3D MmioRead8 ((UINTN)&Regs->Ibsr); + + if (Reg & I2C_IBSR_IBIF) { + // Write 1 to clear the IBIF field + MmioWrite8 ((UINTN)&Regs->Ibsr, Reg); + break; + } + + MicroSecondDelay (1); + } + + if (Index =3D=3D I2C_NUM_RETRIES) { + return EFI_TIMEOUT; + } + + if (TestRxAck && (Reg & I2C_IBSR_RXAK)) { + return EFI_NO_RESPONSE; + } + + if (Reg & I2C_IBSR_TCF) { + return EFI_SUCCESS; + } + + return EFI_DEVICE_ERROR; +} + +STATIC +EFI_STATUS +I2cRead ( + IN I2C_REGS *Regs, + IN UINT32 SlaveAddress, + IN EFI_I2C_OPERATION *Operation, + IN BOOLEAN IsLastOperation +) +{ + EFI_STATUS Status; + UINTN Index; + + // Write Slave Address + MmioWrite8 ((UINTN)&Regs->Ibdr, (SlaveAddress << BIT0) | BIT0); + Status =3D I2cTransferComplete (Regs, I2C_BUS_TEST_RX_ACK); + if (EFI_ERROR (Status)) { + return Status; + } + // select Receive mode. + MmioAnd8 ((UINTN)&Regs->Ibcr, ~I2C_IBCR_TXRX); + if (Operation->LengthInBytes > 1) { + // Set No ACK =3D 0 + MmioAnd8 ((UINTN)&Regs->Ibcr, ~I2C_IBCR_NOACK); + } + + // Perform a dummy read to initiate the receive operation. + MmioRead8 ((UINTN)&Regs->Ibdr); + + for (Index =3D 0; Index < Operation->LengthInBytes; Index++) { + Status =3D I2cTransferComplete (Regs, I2C_BUS_NO_TEST_RX_ACK); + if (EFI_ERROR (Status)) { + return Status; + } + if (Index =3D=3D (Operation->LengthInBytes - 2)) { + // Set No ACK =3D 1 + MmioOr8 ((UINTN)&Regs->Ibcr, I2C_IBCR_NOACK); + } else if (Index =3D=3D (Operation->LengthInBytes - 1)) { + if (!IsLastOperation) { + // select Transmit mode (for repeat start) + MmioOr8 ((UINTN)&Regs->Ibcr, I2C_IBCR_TXRX); + } else { + // Generate Stop Signal + MmioAnd8 ((UINTN)&Regs->Ibcr, ~(I2C_IBCR_MSSL | I2C_IBCR_TXRX)); + Status =3D I2cBusTestBusBusy (Regs, I2C_BUS_TEST_IDLE); + if (EFI_ERROR (Status)) { + return Status; + } + } + } + Operation->Buffer[Index] =3D MmioRead8 ((UINTN)&Regs->Ibdr); + } + + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +I2cWrite ( + IN I2C_REGS *Regs, + IN UINT32 SlaveAddress, + IN EFI_I2C_OPERATION *Operation +) +{ + EFI_STATUS Status; + UINTN Index; + + // Write Slave Address + MmioWrite8 ((UINTN)&Regs->Ibdr, (SlaveAddress << BIT0) & (UINT8)(~BIT0))= ; + Status =3D I2cTransferComplete (Regs, I2C_BUS_TEST_RX_ACK); + if (EFI_ERROR (Status)) { + return Status; + } + + // Write Data + for (Index =3D 0; Index < Operation->LengthInBytes; Index++) { + MmioWrite8 ((UINTN)&Regs->Ibdr, Operation->Buffer[Index]); + Status =3D I2cTransferComplete (Regs, I2C_BUS_TEST_RX_ACK); + if (EFI_ERROR (Status)) { + return Status; + } + } + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +I2cStop ( + IN I2C_REGS *Regs + ) +{ + EFI_STATUS Status; + UINT8 Reg; + + Status =3D EFI_SUCCESS; + Reg =3D MmioRead8 ((UINTN)&Regs->Ibsr); + if (Reg & I2C_IBSR_IBB) { + // Generate Stop Signal + MmioAnd8 ((UINTN)&Regs->Ibcr, ~(I2C_IBCR_MSSL | I2C_IBCR_TXRX)); + Status =3D I2cBusTestBusBusy (Regs, I2C_BUS_TEST_IDLE); + if (EFI_ERROR (Status)) { + return Status; + } + } + + // Disable I2c Controller + MmioOr8 ((UINTN)&Regs->Ibcr, I2C_IBCR_MDIS); + + return Status; +} + +STATIC +EFI_STATUS +I2cStart ( + IN I2C_REGS *Regs + ) +{ + EFI_STATUS Status; + + MmioOr8 ((UINTN)&Regs->Ibsr, (I2C_IBSR_IBAL | I2C_IBSR_IBIF)); + MmioAnd8 ((UINTN)&Regs->Ibcr, (UINT8)(~I2C_IBCR_MDIS)); + + //Wait controller to be stable + MicroSecondDelay (1); + + // Generate Start Signal + MmioOr8 ((UINTN)&Regs->Ibcr, I2C_IBCR_MSSL); + Status =3D I2cBusTestBusBusy (Regs, I2C_BUS_TEST_BUSY); + if (EFI_ERROR (Status)) { + return Status; + } + + // Select Transmit Mode. set No ACK =3D 1 + MmioOr8 ((UINTN)&Regs->Ibcr, (I2C_IBCR_TXRX | I2C_IBCR_NOACK)); + + return Status; +} + +/** + Transfer data to/from I2c slave device + + @param[in] Base Base Address of I2c controller's registers + @param[in] SlaveAddress Slave Address from which data is to be read + @param[in] RequestPacket Pointer to an EFI_I2C_REQUEST_PACKET structure + describing the I2C transaction + + @return EFI_SUCCESS successfuly transfer the data + @return EFI_DEVICE_ERROR There was an error while transferring data th= rough + I2c bus + @return EFI_NO_RESPONSE There was no Ack from i2c device + @return EFI_TIMEOUT I2c Bus is busy + @return EFI_NOT_READY I2c Bus Arbitration lost +**/ +EFI_STATUS +I2cBusXfer ( + IN UINTN Base, + IN UINT32 SlaveAddress, + IN EFI_I2C_REQUEST_PACKET *RequestPacket + ) +{ + UINTN Index; + I2C_REGS *Regs; + EFI_I2C_OPERATION *Operation; + EFI_STATUS Status; + BOOLEAN IsLastOperation; + + Regs =3D (I2C_REGS *)Base; + IsLastOperation =3D FALSE; + + Status =3D I2cBusTestBusBusy (Regs, I2C_BUS_TEST_IDLE); + if (EFI_ERROR (Status)) { + goto ErrorExit; + } + + Status =3D I2cStart (Regs); + if (EFI_ERROR (Status)) { + goto ErrorExit; + } + + for (Index =3D 0, Operation =3D RequestPacket->Operation; + Index < RequestPacket->OperationCount; + Index++, Operation++) { + if (Index =3D=3D (RequestPacket->OperationCount - 1)) { + IsLastOperation =3D TRUE; + } + // Send repeat start after first transmit/recieve + if (Index) { + MmioOr8 ((UINTN)&Regs->Ibcr, I2C_IBCR_RSTA); + Status =3D I2cBusTestBusBusy (Regs, I2C_BUS_TEST_BUSY); + if (EFI_ERROR (Status)) { + goto ErrorExit; + } + } + // Read/write data + if (Operation->Flags & I2C_FLAG_READ) { + Status =3D I2cRead (Regs, SlaveAddress, Operation, IsLastOperation); + } else { + Status =3D I2cWrite (Regs, SlaveAddress, Operation); + } + if (EFI_ERROR (Status)) { + goto ErrorExit; + } + } + +ErrorExit: + + I2cStop (Regs); + + return Status; +} + +/** + Read a register from I2c slave device. This API is wrapper around I2cBus= Xfer + + @param[in] Base Base Address of I2c controller's regi= sters + @param[in] SlaveAddress Slave Address from which register val= ue is + to be read + @param[in] RegAddress Register Address in Slave's memory ma= p + @param[in] RegAddressWidthInBytes Number of bytes in RegAddress to send= to + I2c Slave for simple reads without an= y + register, make this value =3D 0 + (RegAddress is don't care in that cas= e) + @param[out] RegValue Value to be read from I2c slave's reg= iser + @param[in] RegValueNumBytes Number of bytes to read from I2c slav= e + register + + @return EFI_SUCCESS successfuly read the registers + @return EFI_DEVICE_ERROR There was an error while transferring data th= rough + I2c bus + @return EFI_NO_RESPONSE There was no Ack from i2c device + @return EFI_TIMEOUT I2c Bus is busy + @return EFI_NOT_READY I2c Bus Arbitration lost +**/ +EFI_STATUS +I2cBusReadReg ( + IN UINTN Base, + IN UINT32 SlaveAddress, + IN UINT64 RegAddress, + IN UINT8 RegAddressWidthInBytes, + OUT UINT8 *RegValue, + IN UINT32 RegValueNumBytes + ) +{ + EFI_I2C_OPERATION *Operations; + I2C_REG_REQUEST RequestPacket; + UINTN OperationCount; + UINT8 Address[sizeof (RegAddress)]; + UINT8 *AddressPtr; + EFI_STATUS Status; + + ZeroMem (&RequestPacket, sizeof (RequestPacket)); + OperationCount =3D 0; + Operations =3D RequestPacket.Operation; + AddressPtr =3D Address; + + if (RegAddressWidthInBytes > ARRAY_SIZE (Address)) { + return EFI_INVALID_PARAMETER; + } + + if (RegAddressWidthInBytes !=3D 0) { + Operations[OperationCount].LengthInBytes =3D RegAddressWidthInBytes; + Operations[OperationCount].Buffer =3D AddressPtr; + while (RegAddressWidthInBytes--) { + *AddressPtr++ =3D RegAddress >> (8 * RegAddressWidthInBytes); + } + OperationCount++; + } + + Operations[OperationCount].LengthInBytes =3D RegValueNumBytes; + Operations[OperationCount].Buffer =3D RegValue; + Operations[OperationCount].Flags =3D I2C_FLAG_READ; + OperationCount++; + + RequestPacket.OperationCount =3D OperationCount; + + Status =3D I2cBusXfer ( + Base, SlaveAddress, + (EFI_I2C_REQUEST_PACKET *)&RequestPacket + ); + + return Status; +} + --=20 2.17.1