From nobody Wed Feb 11 10:24:18 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4706AC61DA4 for ; Wed, 15 Mar 2023 16:18:35 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232712AbjCOQSd (ORCPT ); Wed, 15 Mar 2023 12:18:33 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59066 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232529AbjCOQSF (ORCPT ); Wed, 15 Mar 2023 12:18:05 -0400 Received: from mx0a-00128a01.pphosted.com (mx0a-00128a01.pphosted.com [148.163.135.77]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 83B0C62D87; Wed, 15 Mar 2023 09:17:45 -0700 (PDT) Received: from pps.filterd (m0167089.ppops.net [127.0.0.1]) by mx0a-00128a01.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 32FDggOI015690; Wed, 15 Mar 2023 12:17:17 -0400 Received: from nwd2mta3.analog.com ([137.71.173.56]) by mx0a-00128a01.pphosted.com (PPS) with ESMTPS id 3pb2bbd549-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 15 Mar 2023 12:17:17 -0400 Received: from ASHBMBX9.ad.analog.com (ASHBMBX9.ad.analog.com [10.64.17.10]) by nwd2mta3.analog.com (8.14.7/8.14.7) with ESMTP id 32FGHGaD016889 (version=TLSv1/SSLv3 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=FAIL); Wed, 15 Mar 2023 12:17:16 -0400 Received: from ASHBMBX9.ad.analog.com (10.64.17.10) by ASHBMBX9.ad.analog.com (10.64.17.10) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.986.14; Wed, 15 Mar 2023 12:17:15 -0400 Received: from zeus.spd.analog.com (10.66.68.11) by ashbmbx9.ad.analog.com (10.64.17.10) with Microsoft SMTP Server id 15.2.986.14 via Frontend Transport; Wed, 15 Mar 2023 12:17:15 -0400 Received: from IST-LT-39247.ad.analog.com (IST-LT-39247.ad.analog.com [10.25.16.17]) by zeus.spd.analog.com (8.15.1/8.15.1) with ESMTP id 32FGGj0m027526; Wed, 15 Mar 2023 12:17:03 -0400 From: Ibrahim Tilki To: , , , , , CC: Ibrahim Tilki , , , , , Zeynep Arslanbenzer Subject: [PATCH v4 1/2] drivers: rtc: add max313xx series rtc driver Date: Wed, 15 Mar 2023 19:16:25 +0300 Message-ID: <20230315161626.247-2-Ibrahim.Tilki@analog.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230315161626.247-1-Ibrahim.Tilki@analog.com> References: <20230315161626.247-1-Ibrahim.Tilki@analog.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-ADIRuleOP-NewSCL: Rule Triggered X-Proofpoint-GUID: 3JDsBTxlOoIViaaAy-tVhnPn4IhvvANe X-Proofpoint-ORIG-GUID: 3JDsBTxlOoIViaaAy-tVhnPn4IhvvANe X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.942,Hydra:6.0.573,FMLib:17.11.170.22 definitions=2023-03-15_08,2023-03-15_01,2023-02-09_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 bulkscore=0 priorityscore=1501 adultscore=0 mlxlogscore=999 impostorscore=0 spamscore=0 malwarescore=0 lowpriorityscore=0 clxscore=1015 phishscore=0 suspectscore=0 mlxscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2302240000 definitions=main-2303150137 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Adding support for Analog Devices MAX313XX series RTCs. Signed-off-by: Ibrahim Tilki Signed-off-by: Zeynep Arslanbenzer --- drivers/rtc/Kconfig | 11 + drivers/rtc/Makefile | 1 + drivers/rtc/rtc-max313xx.c | 1056 ++++++++++++++++++++++++++++++++++++ 3 files changed, 1068 insertions(+) create mode 100644 drivers/rtc/rtc-max313xx.c diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig index 5a71579af..b861309d4 100644 --- a/drivers/rtc/Kconfig +++ b/drivers/rtc/Kconfig @@ -323,6 +323,17 @@ config RTC_DRV_LP8788 help Say Y to enable support for the LP8788 RTC/ALARM driver. =20 +config RTC_DRV_MAX313XX + tristate "Analog Devices MAX313XX RTC driver" + depends on I2C + select REGMAP_I2C + help + If you say yes here you will get support for the + Analog Devices MAX313XX series RTC family. + + This driver can also be built as a module. If so, the module + will be called rtc-max313xx. + config RTC_DRV_MAX6900 tristate "Maxim MAX6900" help diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile index ea445d1eb..880db99be 100644 --- a/drivers/rtc/Makefile +++ b/drivers/rtc/Makefile @@ -88,6 +88,7 @@ obj-$(CONFIG_RTC_DRV_M41T94) +=3D rtc-m41t94.o obj-$(CONFIG_RTC_DRV_M48T35) +=3D rtc-m48t35.o obj-$(CONFIG_RTC_DRV_M48T59) +=3D rtc-m48t59.o obj-$(CONFIG_RTC_DRV_M48T86) +=3D rtc-m48t86.o +obj-$(CONFIG_RTC_DRV_MAX313XX) +=3D rtc-max313xx.o obj-$(CONFIG_RTC_DRV_MAX6900) +=3D rtc-max6900.o obj-$(CONFIG_RTC_DRV_MAX6902) +=3D rtc-max6902.o obj-$(CONFIG_RTC_DRV_MAX6916) +=3D rtc-max6916.o diff --git a/drivers/rtc/rtc-max313xx.c b/drivers/rtc/rtc-max313xx.c new file mode 100644 index 000000000..9bb628f1c --- /dev/null +++ b/drivers/rtc/rtc-max313xx.c @@ -0,0 +1,1056 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Analog Devices MAX313XX series I2C RTC driver + * + * Copyright 2023 Analog Devices Inc. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* common registers */ +#define MAX313XX_INT_ALARM1 BIT(0) +#define MAX313XX_HRS_F_AM_PM BIT(5) +#define MAX313XX_HRS_F_12_24 BIT(6) +#define MAX313XX_MONTH_CENTURY BIT(7) + +#define MAX313XX_TIME_SIZE 0x07 + +/* device specific registers */ +#define MAX3134X_CFG2_REG 0x01 +#define MAX3134X_CFG2_SET_RTC BIT(1) + +#define MAX31341_TRICKLE_RES_MASK GENMASK(1, 0) +#define MAX31341_TRICKLE_DIODE_EN BIT(2) +#define MAX31341_TRICKLE_ENABLE_BIT BIT(3) +#define MAX31341_POWER_MGMT_REG 0x56 +#define MAX31341_POWER_MGMT_TRICKLE_BIT BIT(0) + +#define MAX3133X_TRICKLE_RES_MASK GENMASK(2, 1) +#define MAX3133X_TRICKLE_DIODE_EN BIT(3) +#define MAX3133X_TRICKLE_ENABLE_BIT BIT(0) + +#define MAX31329_TRICKLE_ENABLE_BIT BIT(7) +#define MAX31343_TRICKLE_ENABLE_MASK GENMASK(7, 4) +#define MAX31343_TRICKLE_ENABLE_CODE 5 +#define MAX31329_43_TRICKLE_RES_MASK GENMASK(1, 0) +#define MAX31329_43_TRICKLE_DIODE_EN BIT(2) + +#define MAX31329_CONFIG2_REG 0x04 +#define MAX31329_CONFIG2_CLKIN_EN BIT(2) +#define MAX31329_CONFIG2_CLKIN_FREQ GENMASK(1, 0) + +#define MAX31341_42_CONFIG1_REG 0x00 +#define MAX31341_42_CONFIG1_CLKIN_EN BIT(7) +#define MAX31341_42_CONFIG1_CLKIN_FREQ GENMASK(5, 4) +#define MAX31341_42_CONFIG1_OSC_DISABLE BIT(3) +#define MAX31341_42_CONFIG1_SWRST BIT(0) + +enum max313xx_ids { + ID_MAX31328, + ID_MAX31329, + ID_MAX31331, + ID_MAX31334, + ID_MAX31341, + ID_MAX31342, + ID_MAX31343, + MAX313XX_ID_NR +}; + +struct clkout_cfg { + const int *freq_avail; + u8 freq_size; + u8 freq_pos; + u8 reg; + u8 en_bit; + bool en_invert; +}; + +struct chip_desc { + struct clkout_cfg *clkout; + const char *clkout_name; + u8 sec_reg; + u8 alarm1_sec_reg; + + u8 int_en_reg; + u8 int_status_reg; + + u8 ram_reg; + u8 ram_size; + + u8 temp_reg; + + u8 trickle_reg; +}; + +#define clk_hw_to_max313xx(_hw) container_of(_hw, struct max313xx, clkout) + +struct max313xx { + enum max313xx_ids id; + struct regmap *regmap; + struct rtc_device *rtc; + struct clk_hw clkout; + struct clk *clkin; + const struct chip_desc *chip; + int irq; +}; + +static const int max313xx_clkin_freq[] =3D { 1, 50, 60, 32768 }; + +static const int max31328_clkout_freq[] =3D { 1, 1024, 4096, 8192 }; +static const int max31329_clkout_freq[] =3D { 1, 4096, 8192, 32768 }; +static const int max3133x_clkout_freq[] =3D { 1, 64, 1024, 32768 }; +static const int max31341_42_clkout_freq[] =3D { 1, 50, 60, 32768 }; +static const int max31343_clkout_freq[] =3D { 1, 2, 4, 8, 16, 32, 64, 128,= 32875 }; + +static struct clkout_cfg max31328_clkout =3D { + .freq_avail =3D max31328_clkout_freq, + .freq_size =3D ARRAY_SIZE(max31328_clkout_freq), + .freq_pos =3D 3, + .reg =3D 0x0E, + .en_bit =3D BIT(3), + .en_invert =3D true, +}; + +static struct clkout_cfg max31329_clkout =3D { + .freq_avail =3D max31329_clkout_freq, + .freq_size =3D ARRAY_SIZE(max31329_clkout_freq), + .freq_pos =3D 5, + .reg =3D 0x04, + .en_bit =3D BIT(7), +}; + +static struct clkout_cfg max3133x_clkout =3D { + .freq_avail =3D max3133x_clkout_freq, + .freq_size =3D ARRAY_SIZE(max3133x_clkout_freq), + .freq_pos =3D 0, + .reg =3D 0x04, + .en_bit =3D BIT(2), +}; + +static struct clkout_cfg max31341_42_clkout =3D { + .freq_avail =3D max31341_42_clkout_freq, + .freq_size =3D ARRAY_SIZE(max31341_42_clkout_freq), + .freq_pos =3D 1, + .reg =3D 0x00, + .en_bit =3D BIT(6), + .en_invert =3D true, +}; + +static struct clkout_cfg max31343_clkout =3D { + .freq_avail =3D max31343_clkout_freq, + .freq_size =3D ARRAY_SIZE(max31343_clkout_freq), + .freq_pos =3D 3, + .reg =3D 0x04, + .en_bit =3D BIT(7), +}; + +static const struct chip_desc chip[MAX313XX_ID_NR] =3D { + [ID_MAX31328] =3D { + .int_en_reg =3D 0x0E, + .int_status_reg =3D 0x0F, + .sec_reg =3D 0x00, + .alarm1_sec_reg =3D 0x07, + .temp_reg =3D 0x11, + .clkout =3D &max31328_clkout, + .clkout_name =3D "max31328-sqw", + }, + [ID_MAX31329] =3D { + .int_en_reg =3D 0x01, + .int_status_reg =3D 0x00, + .sec_reg =3D 0x06, + .alarm1_sec_reg =3D 0x0D, + .ram_reg =3D 0x22, + .ram_size =3D 64, + .trickle_reg =3D 0x19, + .clkout =3D &max31329_clkout, + .clkout_name =3D "max31329-clkout", + }, + [ID_MAX31331] =3D { + .int_en_reg =3D 0x01, + .int_status_reg =3D 0x00, + .sec_reg =3D 0x08, + .alarm1_sec_reg =3D 0x0F, + .ram_reg =3D 0x20, + .ram_size =3D 32, + .trickle_reg =3D 0x1B, + .clkout =3D &max3133x_clkout, + .clkout_name =3D "max31331-clkout", + }, + [ID_MAX31334] =3D { + .int_en_reg =3D 0x01, + .int_status_reg =3D 0x00, + .sec_reg =3D 0x09, + .alarm1_sec_reg =3D 0x10, + .ram_reg =3D 0x30, + .ram_size =3D 32, + .trickle_reg =3D 0x1E, + .clkout =3D &max3133x_clkout, + .clkout_name =3D "max31334-clkout", + }, + [ID_MAX31341] =3D { + .int_en_reg =3D 0x04, + .int_status_reg =3D 0x05, + .sec_reg =3D 0x06, + .alarm1_sec_reg =3D 0x0D, + .ram_reg =3D 0x16, + .ram_size =3D 64, + .trickle_reg =3D 0x57, + .clkout =3D &max31341_42_clkout, + .clkout_name =3D "max31341-clkout", + }, + [ID_MAX31342] =3D { + .int_en_reg =3D 0x04, + .int_status_reg =3D 0x05, + .sec_reg =3D 0x06, + .alarm1_sec_reg =3D 0x0D, + .clkout =3D &max31341_42_clkout, + .clkout_name =3D "max31342-clkout", + }, + [ID_MAX31343] =3D { + .int_en_reg =3D 0x01, + .int_status_reg =3D 0x00, + .sec_reg =3D 0x06, + .alarm1_sec_reg =3D 0x0D, + .ram_reg =3D 0x22, + .ram_size =3D 64, + .temp_reg =3D 0x1A, + .trickle_reg =3D 0x19, + .clkout =3D &max31343_clkout, + .clkout_name =3D "max31343-clko", + }, +}; + +static const u32 max313xx_trickle_ohms[] =3D { 3000, 6000, 11000 }; + +static bool max313xx_volatile_reg(struct device *dev, unsigned int reg) +{ + struct max313xx *rtc =3D dev_get_drvdata(dev); + const struct chip_desc *chip =3D rtc->chip; + + /* time keeping registers */ + if (reg >=3D chip->sec_reg && reg < chip->sec_reg + MAX313XX_TIME_SIZE) + return true; + + /* interrupt status register */ + if (reg =3D=3D chip->int_status_reg) + return true; + + /* temperature registers */ + return chip->temp_reg && + (reg =3D=3D chip->temp_reg || reg =3D=3D chip->temp_reg + 1); +} + +static const struct regmap_config regmap_config =3D { + .reg_bits =3D 8, + .val_bits =3D 8, + .cache_type =3D REGCACHE_RBTREE, + .volatile_reg =3D max313xx_volatile_reg, +}; + +static int max313xx_get_hour(u8 hour_reg) +{ + int hour; + + /* 24Hr mode */ + if (!FIELD_GET(MAX313XX_HRS_F_12_24, hour_reg)) + return bcd2bin(hour_reg & 0x3f); + + /* 12Hr mode */ + hour =3D bcd2bin(hour_reg & 0x1f); + if (hour =3D=3D 12) + hour =3D 0; + + if (FIELD_GET(MAX313XX_HRS_F_AM_PM, hour_reg)) + hour +=3D 12; + + return hour; +} + +static int max313xx_read_time(struct device *dev, struct rtc_time *t) +{ + struct max313xx *rtc =3D dev_get_drvdata(dev); + u8 regs[7]; + int ret; + + ret =3D regmap_bulk_read(rtc->regmap, rtc->chip->sec_reg, regs, 7); + if (ret) + return ret; + + t->tm_sec =3D bcd2bin(regs[0] & 0x7f); + t->tm_min =3D bcd2bin(regs[1] & 0x7f); + t->tm_hour =3D max313xx_get_hour(regs[2]); + t->tm_wday =3D bcd2bin(regs[3] & 0x07) - 1; + t->tm_mday =3D bcd2bin(regs[4] & 0x3f); + t->tm_mon =3D bcd2bin(regs[5] & 0x1f) - 1; + t->tm_year =3D bcd2bin(regs[6]) + 100; + + if (FIELD_GET(MAX313XX_MONTH_CENTURY, regs[5])) + t->tm_year +=3D 100; + + return 0; +} + +static int max313xx_pre_set_time(struct max313xx *rtc) +{ + if (!rtc->clkin) + return 0; + + /* Clkin needs to be disabled before setting time. */ + switch (rtc->id) { + case ID_MAX31341: + case ID_MAX31342: + return regmap_clear_bits(rtc->regmap, + MAX31341_42_CONFIG1_REG, + MAX31341_42_CONFIG1_CLKIN_EN); + default: + return 0; + } +} + +static int max313xx_post_set_time(struct max313xx *rtc) +{ + int ret; + + switch (rtc->id) { + case ID_MAX31341: + case ID_MAX31342: + ret =3D regmap_set_bits(rtc->regmap, MAX3134X_CFG2_REG, + MAX3134X_CFG2_SET_RTC); + if (ret) + return ret; + + fsleep(10000); + + ret =3D regmap_clear_bits(rtc->regmap, MAX3134X_CFG2_REG, + MAX3134X_CFG2_SET_RTC); + if (ret) + return ret; + + if (rtc->clkin) + ret =3D regmap_set_bits(rtc->regmap, + MAX31341_42_CONFIG1_REG, + MAX31341_42_CONFIG1_CLKIN_EN); + + break; + default: + return 0; + } + + return ret; +} + +static int max313xx_set_time(struct device *dev, struct rtc_time *t) +{ + struct max313xx *rtc =3D dev_get_drvdata(dev); + u8 regs[7]; + int ret; + + regs[0] =3D bin2bcd(t->tm_sec); + regs[1] =3D bin2bcd(t->tm_min); + regs[2] =3D bin2bcd(t->tm_hour); + regs[3] =3D bin2bcd(t->tm_wday + 1); + regs[4] =3D bin2bcd(t->tm_mday); + regs[5] =3D bin2bcd(t->tm_mon + 1); + regs[6] =3D bin2bcd(t->tm_year % 100); + + if (t->tm_year >=3D 200) + regs[5] |=3D FIELD_PREP(MAX313XX_MONTH_CENTURY, 1); + + ret =3D max313xx_pre_set_time(rtc); + if (ret) + return ret; + + ret =3D regmap_bulk_write(rtc->regmap, rtc->chip->sec_reg, regs, 7); + if (ret) + return ret; + + return max313xx_post_set_time(rtc); +} + +static int max313xx_read_alarm(struct device *dev, struct rtc_wkalrm *t) +{ + struct max313xx *rtc =3D dev_get_drvdata(dev); + unsigned int status, int_en; + struct rtc_time time; + u8 regs[6]; + int ret; + + ret =3D regmap_bulk_read(rtc->regmap, rtc->chip->alarm1_sec_reg, regs, + sizeof(regs)); + if (ret) + return ret; + + t->time.tm_sec =3D bcd2bin(regs[0] & 0x7f); + t->time.tm_min =3D bcd2bin(regs[1] & 0x7f); + t->time.tm_hour =3D bcd2bin(regs[2] & 0x3f); + t->time.tm_mday =3D bcd2bin(regs[3] & 0x3f); + t->time.tm_mon =3D bcd2bin(regs[4] & 0x1f) - 1; + t->time.tm_year =3D bcd2bin(regs[5]) + 100; + + ret =3D max313xx_read_time(dev, &time); + if (ret) + return ret; + + if (time.tm_year >=3D 200) + t->time.tm_year +=3D 100; + + ret =3D regmap_read(rtc->regmap, rtc->chip->int_status_reg, &status); + if (ret) + return ret; + + ret =3D regmap_read(rtc->regmap, rtc->chip->int_en_reg, &int_en); + if (ret) + return ret; + + t->enabled =3D FIELD_GET(MAX313XX_INT_ALARM1, int_en); + t->pending =3D FIELD_GET(MAX313XX_INT_ALARM1, status); + + return 0; +} + +static int max313xx_set_alarm(struct device *dev, struct rtc_wkalrm *t) +{ + struct max313xx *rtc =3D dev_get_drvdata(dev); + unsigned int reg; + u8 regs[6]; + int ret; + + regs[0] =3D bin2bcd(t->time.tm_sec); + regs[1] =3D bin2bcd(t->time.tm_min); + regs[2] =3D bin2bcd(t->time.tm_hour); + regs[3] =3D bin2bcd(t->time.tm_mday); + regs[4] =3D bin2bcd(t->time.tm_mon + 1); + regs[5] =3D bin2bcd(t->time.tm_year % 100); + + ret =3D regmap_bulk_write(rtc->regmap, rtc->chip->alarm1_sec_reg, regs, + sizeof(regs)); + if (ret) + return ret; + + reg =3D FIELD_PREP(MAX313XX_INT_ALARM1, t->enabled); + ret =3D regmap_update_bits(rtc->regmap, rtc->chip->int_en_reg, + MAX313XX_INT_ALARM1, reg); + if (ret) + return ret; + + /* Clear status register */ + return regmap_read(rtc->regmap, rtc->chip->int_status_reg, ®); +} + +static int max313xx_alarm_irq_enable(struct device *dev, unsigned int enab= led) +{ + struct max313xx *rtc =3D dev_get_drvdata(dev); + + return regmap_update_bits(rtc->regmap, rtc->chip->int_en_reg, + MAX313XX_INT_ALARM1, + FIELD_PREP(MAX313XX_INT_ALARM1, enabled)); +} + +static const struct rtc_class_ops max3133x_rtc_ops =3D { + .read_time =3D max313xx_read_time, + .set_time =3D max313xx_set_time, + .read_alarm =3D max313xx_read_alarm, + .set_alarm =3D max313xx_set_alarm, + .alarm_irq_enable =3D max313xx_alarm_irq_enable, +}; + +static irqreturn_t max313xx_irq(int irq, void *dev_id) +{ + struct max313xx *rtc =3D dev_id; + struct mutex *lock =3D &rtc->rtc->ops_lock; + int stat, ret; + + mutex_lock(lock); + ret =3D regmap_read(rtc->regmap, rtc->chip->int_status_reg, &stat); + if (ret) + goto out; + + if (FIELD_GET(MAX313XX_INT_ALARM1, stat)) { + ret =3D regmap_update_bits(rtc->regmap, rtc->chip->int_en_reg, + MAX313XX_INT_ALARM1, 0); + if (ret) + goto out; + + rtc_update_irq(rtc->rtc, 1, RTC_AF | RTC_IRQF); + } + +out: + mutex_unlock(lock); + + return IRQ_HANDLED; +} + +static int max313xx_nvmem_reg_read(void *priv, unsigned int offset, + void *val, size_t bytes) +{ + struct max313xx *rtc =3D priv; + unsigned int reg =3D rtc->chip->ram_reg + offset; + + return regmap_bulk_read(rtc->regmap, reg, val, bytes); +} + +static int max313xx_nvmem_reg_write(void *priv, unsigned int offset, + void *val, size_t bytes) +{ + struct max313xx *rtc =3D priv; + unsigned int reg =3D rtc->chip->ram_reg + offset; + + return regmap_bulk_write(rtc->regmap, reg, val, bytes); +} + +struct nvmem_config max313xx_nvmem_cfg =3D { + .reg_read =3D max313xx_nvmem_reg_read, + .reg_write =3D max313xx_nvmem_reg_write, + .word_size =3D 8, +}; + +static unsigned long max313xx_clkout_recalc_rate(struct clk_hw *hw, + unsigned long parent_rate) +{ + struct max313xx *rtc =3D clk_hw_to_max313xx(hw); + const struct clkout_cfg *clkout =3D rtc->chip->clkout; + unsigned int freq_mask; + unsigned int reg; + int ret; + + ret =3D regmap_read(rtc->regmap, clkout->reg, ®); + if (ret) + return 0; + + freq_mask =3D __roundup_pow_of_two(clkout->freq_size) - 1; + + return clkout->freq_avail[(reg >> clkout->freq_pos) & freq_mask]; +} + +static long max313xx_clkout_round_rate(struct clk_hw *hw, unsigned long ra= te, + unsigned long *prate) +{ + struct max313xx *rtc =3D clk_hw_to_max313xx(hw); + struct clkout_cfg *clkout =3D rtc->chip->clkout; + int index; + + index =3D find_closest(rate, clkout->freq_avail, clkout->freq_size); + return clkout->freq_avail[index]; +} + +static int max313xx_clkout_set_rate(struct clk_hw *hw, unsigned long rate, + unsigned long parent_rate) +{ + struct max313xx *rtc =3D clk_hw_to_max313xx(hw); + struct clkout_cfg *clkout =3D rtc->chip->clkout; + unsigned int freq_mask; + int index; + + index =3D find_closest(rate, clkout->freq_avail, clkout->freq_size); + freq_mask =3D __roundup_pow_of_two(clkout->freq_size) - 1; + + return regmap_update_bits(rtc->regmap, clkout->reg, + freq_mask << clkout->freq_pos, + index << clkout->freq_pos); +} + +static int max313xx_clkout_enable(struct clk_hw *hw) +{ + struct max313xx *rtc =3D clk_hw_to_max313xx(hw); + struct clkout_cfg *clkout =3D rtc->chip->clkout; + + if (clkout->en_invert) + return regmap_clear_bits(rtc->regmap, clkout->reg, + clkout->en_bit); + + return regmap_set_bits(rtc->regmap, clkout->reg, clkout->en_bit); +} + +static void max313xx_clkout_disable(struct clk_hw *hw) +{ + struct max313xx *rtc =3D clk_hw_to_max313xx(hw); + struct clkout_cfg *clkout =3D rtc->chip->clkout; + + switch (rtc->id) { + case ID_MAX31331: + case ID_MAX31334: + if (rtc->irq > 0) { + dev_err(rtc->rtc->dev.parent, + "clkout cannot be disabled when IRQ is requested"); + return; + } + break; + default: + break; + } + + if (clkout->en_invert) + regmap_set_bits(rtc->regmap, clkout->reg, clkout->en_bit); + else + regmap_clear_bits(rtc->regmap, clkout->reg, clkout->en_bit); +} + +static int max313xx_clkout_is_enabled(struct clk_hw *hw) +{ + struct max313xx *rtc =3D clk_hw_to_max313xx(hw); + struct clkout_cfg *clkout =3D rtc->chip->clkout; + unsigned int reg; + int ret; + + ret =3D regmap_read(rtc->regmap, clkout->reg, ®); + if (ret) + return ret; + + return !!(reg & clkout->en_bit) ^ clkout->en_invert; +} + +static const struct clk_ops max313xx_clkout_ops =3D { + .recalc_rate =3D max313xx_clkout_recalc_rate, + .round_rate =3D max313xx_clkout_round_rate, + .set_rate =3D max313xx_clkout_set_rate, + .enable =3D max313xx_clkout_enable, + .disable =3D max313xx_clkout_disable, + .is_enabled =3D max313xx_clkout_is_enabled, +}; + +struct clk_init_data max313xx_clk_init =3D { + .name =3D "max313xx-clkout", + .ops =3D &max313xx_clkout_ops, +}; + +static int max313xx_read_temp(struct device *dev, enum hwmon_sensor_types = type, + u32 attr, int channel, long *val) +{ + struct max313xx *rtc =3D dev_get_drvdata(dev); + u8 reg[2]; + s16 temp; + int ret; + + if (type !=3D hwmon_temp || attr !=3D hwmon_temp_input) + return -EOPNOTSUPP; + + ret =3D regmap_bulk_read(rtc->regmap, rtc->chip->temp_reg, reg, 2); + if (ret) + return ret; + + temp =3D get_unaligned_be16(reg); + + *val =3D (temp / 64) * 250; + + return 0; +} + +static umode_t max313xx_is_visible(const void *data, + enum hwmon_sensor_types type, + u32 attr, int channel) +{ + if (type =3D=3D hwmon_temp && attr =3D=3D hwmon_temp_input) + return 0444; + + return 0; +} + +static const struct hwmon_channel_info *max313xx_info[] =3D { + HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT), + NULL +}; + +static const struct hwmon_ops max313xx_hwmon_ops =3D { + .is_visible =3D max313xx_is_visible, + .read =3D max313xx_read_temp, +}; + +static const struct hwmon_chip_info max313xx_chip_info =3D { + .ops =3D &max313xx_hwmon_ops, + .info =3D max313xx_info, +}; + +static int max313xx_init(struct max313xx *rtc) +{ + int ret; + + switch (rtc->id) { + case ID_MAX31341: + case ID_MAX31342: + ret =3D regmap_clear_bits(rtc->regmap, MAX31341_42_CONFIG1_REG, + MAX31341_42_CONFIG1_OSC_DISABLE); + if (ret) + return ret; + + return regmap_set_bits(rtc->regmap, MAX31341_42_CONFIG1_REG, + MAX31341_42_CONFIG1_SWRST); + default: + return 0; + } +} + +static int max313xx_clkout_register(struct device *dev) +{ + struct max313xx *rtc =3D dev_get_drvdata(dev); + int ret; + + if (!device_property_present(dev, "#clock-cells")) + return 0; + + max313xx_clk_init.name =3D rtc->chip->clkout_name; + device_property_read_string(dev, "clock-output-names", + &max313xx_clk_init.name); + rtc->clkout.init =3D &max313xx_clk_init; + + ret =3D devm_clk_hw_register(dev, &rtc->clkout); + if (ret) + return dev_err_probe(dev, ret, "cannot register clock\n"); + + return devm_of_clk_add_hw_provider(dev, of_clk_hw_simple_get, + &rtc->clkout); +} + +static int max313xx_trickle_charger_setup(struct device *dev) +{ + struct max313xx *rtc =3D dev_get_drvdata(dev); + bool trickle_diode_en; + u32 charger_en =3D 0; + int index, reg; + u32 ohms =3D 0; + int ret; + + device_property_read_u32(dev, "aux-voltage-chargeable", &charger_en); + if (charger_en > 1) + return dev_err_probe(dev, -EINVAL, + "invalid value %d for property aux-voltage-chargeable\n", + charger_en); + + if (!charger_en) + return 0; + + trickle_diode_en =3D device_property_read_bool(dev, "adi,trickle-diode-en= able"); + + device_property_read_u32(dev, "trickle-resistor-ohms", &ohms); + + if (!rtc->chip->trickle_reg) { + dev_warn(dev, "device does not have trickle charger\n"); + return 0; + } + + index =3D find_closest(ohms, max313xx_trickle_ohms, + ARRAY_SIZE(max313xx_trickle_ohms)) + 1; + + switch (rtc->id) { + case ID_MAX31329: + reg =3D FIELD_PREP(MAX31329_TRICKLE_ENABLE_BIT, 1) | + FIELD_PREP(MAX31329_43_TRICKLE_RES_MASK, index) | + FIELD_PREP(MAX31329_43_TRICKLE_DIODE_EN, trickle_diode_en); + break; + case ID_MAX31331: + case ID_MAX31334: + reg =3D FIELD_PREP(MAX3133X_TRICKLE_ENABLE_BIT, 1) | + FIELD_PREP(MAX3133X_TRICKLE_RES_MASK, index) | + FIELD_PREP(MAX3133X_TRICKLE_DIODE_EN, trickle_diode_en); + break; + case ID_MAX31341: + if (index =3D=3D 1) + index =3D 0; + + reg =3D FIELD_PREP(MAX31341_TRICKLE_ENABLE_BIT, 1) | + FIELD_PREP(MAX31341_TRICKLE_RES_MASK, index) | + FIELD_PREP(MAX31341_TRICKLE_DIODE_EN, trickle_diode_en); + + ret =3D regmap_set_bits(rtc->regmap, MAX31341_POWER_MGMT_REG, + MAX31341_POWER_MGMT_TRICKLE_BIT); + if (ret) + return ret; + + break; + case ID_MAX31343: + reg =3D FIELD_PREP(MAX31329_43_TRICKLE_RES_MASK, index) | + FIELD_PREP(MAX31329_43_TRICKLE_DIODE_EN, trickle_diode_en) | + FIELD_PREP(MAX31343_TRICKLE_ENABLE_MASK, + MAX31343_TRICKLE_ENABLE_CODE); + break; + default: + return -EOPNOTSUPP; + } + + return regmap_write(rtc->regmap, rtc->chip->trickle_reg, reg); +} + +static int max313xx_find_clkin_freq_index(struct clk *clk) +{ + unsigned long rate =3D clk_get_rate(clk); + int freq; + int i; + + i =3D find_closest(rate, max313xx_clkin_freq, + ARRAY_SIZE(max313xx_clkin_freq)); + if (max313xx_clkin_freq[i] =3D=3D rate) + return i; + + for (i =3D ARRAY_SIZE(max313xx_clkin_freq) - 1; i >=3D 0; i--) { + freq =3D max313xx_clkin_freq[i]; + if (freq =3D=3D clk_round_rate(clk, freq)) + return i; + } + + /* supplied clock cannot produce one of desired frequency rate */ + return -ENODEV; +} + +static int max313xx_clkin_init(struct device *dev) +{ + struct max313xx *rtc =3D dev_get_drvdata(dev); + int rate; + int ret; + + rtc->clkin =3D devm_clk_get_enabled(dev, NULL); + if (IS_ERR(rtc->clkin)) { + if (PTR_ERR(rtc->clkin) =3D=3D -ENOENT) + rtc->clkin =3D NULL; + else + return dev_err_probe(dev, PTR_ERR(rtc->clkin), + "error while clkin setup\n"); + } + + if (!rtc->clkin) { + switch (rtc->id) { + case ID_MAX31329: + return regmap_clear_bits(rtc->regmap, + MAX31329_CONFIG2_REG, + MAX31329_CONFIG2_CLKIN_EN); + case ID_MAX31341: + case ID_MAX31342: + return regmap_clear_bits(rtc->regmap, + MAX31341_42_CONFIG1_REG, + MAX31341_42_CONFIG1_CLKIN_EN); + default: + return 0; + } + } + + rate =3D max313xx_find_clkin_freq_index(rtc->clkin); + if (rate < 0) + return dev_err_probe(dev, rate, + "clkin cannot produce required frequency\n"); + + ret =3D clk_set_rate(rtc->clkin, max313xx_clkin_freq[rate]); + if (ret) + return ret; + + switch (rtc->id) { + case ID_MAX31329: + ret =3D regmap_update_bits(rtc->regmap, MAX31329_CONFIG2_REG, + MAX31329_CONFIG2_CLKIN_FREQ, rate); + if (ret) + return ret; + + return regmap_set_bits(rtc->regmap, MAX31329_CONFIG2_REG, + MAX31329_CONFIG2_CLKIN_EN); + case ID_MAX31341: + case ID_MAX31342: + ret =3D regmap_update_bits(rtc->regmap, MAX31341_42_CONFIG1_REG, + MAX31341_42_CONFIG1_CLKIN_FREQ, + FIELD_PREP(MAX31341_42_CONFIG1_CLKIN_FREQ, rate)); + if (ret) + return ret; + + return regmap_set_bits(rtc->regmap, MAX31341_42_CONFIG1_REG, + MAX31341_42_CONFIG1_CLKIN_EN); + default: + rtc->clkin =3D NULL; + dev_warn(dev, "device does not have clock input\n"); + return 0; + } +} + +static int max313xx_irq_init(struct device *dev, const char *devname) +{ + struct max313xx *rtc =3D dev_get_drvdata(dev); + int ret; + + switch (rtc->id) { + case ID_MAX31328: + /* max31328 sqw and interrupt pin is shared */ + if (rtc->irq > 0 && rtc->clkout.clk) + return dev_err_probe(dev, -EOPNOTSUPP, + "cannot have both sqw clock output and irq enabled"); + + break; + case ID_MAX31331: + case ID_MAX31334: + if (rtc->clkout.clk) { + /* + * interrupt muxing depends on clkout so enable clkout + * if configured before requesting interrupt + */ + ret =3D clk_prepare_enable(rtc->clkout.clk); + if (ret) + return dev_err_probe(dev, ret, + "cannot enable clkout\n"); + } + break; + default: + if (rtc->clkin) { + if (rtc->clkout.clk && rtc->irq > 0) + return dev_err_probe(dev, -EOPNOTSUPP, + "irq not possible when both clkin and clkout are configured\n"); + + if (rtc->irq <=3D 0) + break; + + /* clkout needs to be disabled for interrupt */ + if (rtc->chip->clkout->en_invert) + ret =3D regmap_set_bits(rtc->regmap, + rtc->chip->clkout->reg, + rtc->chip->clkout->en_bit); + else + ret =3D regmap_clear_bits(rtc->regmap, + rtc->chip->clkout->reg, + rtc->chip->clkout->en_bit); + + if (ret) + return ret; + } + break; + } + + if (rtc->irq > 0) { + return devm_request_threaded_irq(dev, rtc->irq, NULL, + &max313xx_irq, IRQF_ONESHOT, + devname, rtc); + } + + clear_bit(RTC_FEATURE_ALARM, rtc->rtc->features); + + return 0; +} + +static int max313xx_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + struct device *dev =3D &client->dev; + struct max313xx *max313xx; + struct device *hwmon; + const void *match; + int ret; + + max313xx =3D devm_kzalloc(&client->dev, sizeof(*max313xx), GFP_KERNEL); + if (!max313xx) + return -ENOMEM; + + dev_set_drvdata(&client->dev, max313xx); + + max313xx->regmap =3D devm_regmap_init_i2c(client, ®map_config); + if (IS_ERR(max313xx->regmap)) { + return dev_err_probe(dev, PTR_ERR(max313xx->regmap), + "regmap init failed\n"); + } + + i2c_set_clientdata(client, max313xx); + + match =3D device_get_match_data(dev); + if (match) + max313xx->chip =3D match; + else if (id) + max313xx->chip =3D (struct chip_desc *)id->driver_data; + else + return -ENODEV; + + max313xx->id =3D max313xx->chip - chip; + + dev_dbg(dev, "RTC_ID: %d\n", max313xx->id); + + ret =3D max313xx_init(max313xx); + if (ret) + return ret; + + max313xx->rtc =3D devm_rtc_allocate_device(dev); + if (IS_ERR(max313xx->rtc)) + return PTR_ERR(max313xx->rtc); + + max313xx->rtc->ops =3D &max3133x_rtc_ops; + max313xx->rtc->range_min =3D RTC_TIMESTAMP_BEGIN_2000; + max313xx->rtc->range_max =3D RTC_TIMESTAMP_END_2199; + + ret =3D devm_rtc_register_device(max313xx->rtc); + if (ret) + return ret; + + max313xx->irq =3D client->irq; + + ret =3D max313xx_clkout_register(dev); + if (ret) + return ret; + + ret =3D max313xx_clkin_init(dev); + if (ret) + return ret; + + /* IRQ wiring depends on the clock configuration so parse them first */ + ret =3D max313xx_irq_init(dev, client->name); + if (ret) + return ret; + + if (max313xx->chip->ram_size) { + max313xx_nvmem_cfg.size =3D max313xx->chip->ram_size; + max313xx_nvmem_cfg.priv =3D max313xx; + + ret =3D devm_rtc_nvmem_register(max313xx->rtc, &max313xx_nvmem_cfg); + if (ret) + dev_warn(dev, "cannot register rtc nvmem\n"); + } + + if (max313xx->chip->temp_reg) { + hwmon =3D devm_hwmon_device_register_with_info(dev, client->name, + max313xx, + &max313xx_chip_info, + NULL); + if (IS_ERR(hwmon)) + dev_warn(dev, "cannot register hwmon device: %li\n", + PTR_ERR(hwmon)); + } + + return max313xx_trickle_charger_setup(dev); +} + +static const struct of_device_id max313xx_of_id[] =3D { + { .compatible =3D "adi,max31328", .data =3D &chip[ID_MAX31328] }, + { .compatible =3D "adi,max31329", .data =3D &chip[ID_MAX31329] }, + { .compatible =3D "adi,max31331", .data =3D &chip[ID_MAX31331] }, + { .compatible =3D "adi,max31334", .data =3D &chip[ID_MAX31334] }, + { .compatible =3D "adi,max31341", .data =3D &chip[ID_MAX31341] }, + { .compatible =3D "adi,max31342", .data =3D &chip[ID_MAX31342] }, + { .compatible =3D "adi,max31343", .data =3D &chip[ID_MAX31343] }, + { } +}; +MODULE_DEVICE_TABLE(of, max313xx_of_id); + +static const struct i2c_device_id max313xx_id[] =3D { + { "max31328", (kernel_ulong_t)&chip[ID_MAX31328] }, + { "max31329", (kernel_ulong_t)&chip[ID_MAX31329] }, + { "max31331", (kernel_ulong_t)&chip[ID_MAX31331] }, + { "max31334", (kernel_ulong_t)&chip[ID_MAX31334] }, + { "max31341", (kernel_ulong_t)&chip[ID_MAX31341] }, + { "max31342", (kernel_ulong_t)&chip[ID_MAX31342] }, + { "max31343", (kernel_ulong_t)&chip[ID_MAX31343] }, + { } +}; +MODULE_DEVICE_TABLE(i2c, max313xx_id); + +static struct i2c_driver max313xx_driver =3D { + .driver =3D { + .name =3D "rtc-max313xx", + .of_match_table =3D max313xx_of_id, + }, + .probe =3D max313xx_probe, + .id_table =3D max313xx_id, +}; +module_i2c_driver(max313xx_driver); + +MODULE_DESCRIPTION("Analog Devices MAX313XX RTCs"); +MODULE_AUTHOR("Zeynep Arslanbenzer "); +MODULE_AUTHOR("Ibrahim Tilki "); +MODULE_SOFTDEP("pre: regmap-i2c"); +MODULE_LICENSE("GPL"); +MODULE_VERSION("1.0"); --=20 2.25.1 From nobody Wed Feb 11 10:24:18 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id C3207C76196 for ; Wed, 15 Mar 2023 16:18:31 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232226AbjCOQS3 (ORCPT ); Wed, 15 Mar 2023 12:18:29 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38352 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232069AbjCOQSE (ORCPT ); Wed, 15 Mar 2023 12:18:04 -0400 Received: from mx0a-00128a01.pphosted.com (mx0a-00128a01.pphosted.com [148.163.135.77]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E88D77DFB1; Wed, 15 Mar 2023 09:17:46 -0700 (PDT) Received: from pps.filterd (m0167089.ppops.net [127.0.0.1]) by mx0a-00128a01.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 32FDiIOr015719; Wed, 15 Mar 2023 12:17:21 -0400 Received: from nwd2mta3.analog.com ([137.71.173.56]) by mx0a-00128a01.pphosted.com (PPS) with ESMTPS id 3pb2bbd54v-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 15 Mar 2023 12:17:20 -0400 Received: from ASHBMBX8.ad.analog.com (ASHBMBX8.ad.analog.com [10.64.17.5]) by nwd2mta3.analog.com (8.14.7/8.14.7) with ESMTP id 32FGHJw8016905 (version=TLSv1/SSLv3 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=FAIL); Wed, 15 Mar 2023 12:17:19 -0400 Received: from ASHBCASHYB4.ad.analog.com (10.64.17.132) by ASHBMBX8.ad.analog.com (10.64.17.5) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.986.14; Wed, 15 Mar 2023 12:17:18 -0400 Received: from ASHBMBX9.ad.analog.com (10.64.17.10) by ASHBCASHYB4.ad.analog.com (10.64.17.132) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.986.14; Wed, 15 Mar 2023 12:17:18 -0400 Received: from zeus.spd.analog.com (10.66.68.11) by ashbmbx9.ad.analog.com (10.64.17.10) with Microsoft SMTP Server id 15.2.986.14 via Frontend Transport; Wed, 15 Mar 2023 12:17:18 -0400 Received: from IST-LT-39247.ad.analog.com (IST-LT-39247.ad.analog.com [10.25.16.17]) by zeus.spd.analog.com (8.15.1/8.15.1) with ESMTP id 32FGGj0n027526; Wed, 15 Mar 2023 12:17:08 -0400 From: Ibrahim Tilki To: , , , , , CC: Ibrahim Tilki , , , , , Zeynep Arslanbenzer Subject: [PATCH v4 2/2] dt-bindings: rtc: add max313xx RTCs Date: Wed, 15 Mar 2023 19:16:26 +0300 Message-ID: <20230315161626.247-3-Ibrahim.Tilki@analog.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230315161626.247-1-Ibrahim.Tilki@analog.com> References: <20230315161626.247-1-Ibrahim.Tilki@analog.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-ADIRuleOP-NewSCL: Rule Triggered X-Proofpoint-GUID: ajmBAC6NQgQI2h1XSC97ElfmHiZkUFqj X-Proofpoint-ORIG-GUID: ajmBAC6NQgQI2h1XSC97ElfmHiZkUFqj X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.942,Hydra:6.0.573,FMLib:17.11.170.22 definitions=2023-03-15_08,2023-03-15_01,2023-02-09_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 bulkscore=0 priorityscore=1501 adultscore=0 mlxlogscore=999 impostorscore=0 spamscore=0 malwarescore=0 lowpriorityscore=0 clxscore=1015 phishscore=0 suspectscore=0 mlxscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2302240000 definitions=main-2303150137 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Devicetree binding documentation for Analog Devices MAX313XX RTCs Signed-off-by: Ibrahim Tilki Signed-off-by: Zeynep Arslanbenzer --- .../devicetree/bindings/rtc/adi,max313xx.yaml | 142 ++++++++++++++++++ 1 file changed, 142 insertions(+) create mode 100644 Documentation/devicetree/bindings/rtc/adi,max313xx.yaml diff --git a/Documentation/devicetree/bindings/rtc/adi,max313xx.yaml b/Docu= mentation/devicetree/bindings/rtc/adi,max313xx.yaml new file mode 100644 index 000000000..bed6d0bc4 --- /dev/null +++ b/Documentation/devicetree/bindings/rtc/adi,max313xx.yaml @@ -0,0 +1,142 @@ +# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause) +# Copyright 2022 Analog Devices Inc. +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/rtc/adi,max313xx.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Analog Devices MAX313XX series I2C RTCs + +maintainers: + - Ibrahim Tilki + - Zeynep Arslanbenzer + +description: Analog Devices MAX313XX series I2C RTCs. + +properties: + compatible: + enum: + - adi,max31328 + - adi,max31329 + - adi,max31331 + - adi,max31334 + - adi,max31341 + - adi,max31342 + - adi,max31343 + + reg: + description: I2C address of the RTC + items: + - enum: [0x68, 0x69] + + interrupts: + description: | + Alarm1 interrupt line of the RTC. Some of the RTCs have two interrupt + lines and alarm1 interrupt muxing depends on the clockin/clockout + configuration. + maxItems: 1 + + "#clock-cells": + description: | + RTC can be used as a clock source through its clock output pin when + supplied. + const: 0 + + clocks: + description: | + RTC uses this clock for clock input when supplied. Clock has to prov= ide + one of these four frequencies: 1Hz, 50Hz, 60Hz or 32.768kHz. + maxItems: 1 + + aux-voltage-chargeable: true + + trickle-resistor-ohms: + description: Enables trickle charger with specified resistor value. + enum: [3000, 6000, 11000] + + adi,trickle-diode-enable: + description: Charge the auxiliary voltage with a diode. + type: boolean + +additionalProperties: false + +allOf: + - $ref: rtc.yaml# + - if: + properties: + compatible: + contains: + enum: + - adi,max31328 + - adi,max31342 + + then: + properties: + aux-voltage-chargeable: false + trickle-resistor-ohms: false + + - if: + properties: + compatible: + contains: + enum: + - adi,max31328 + - adi,max31331 + - adi,max31334 + - adi,max31343 + + then: + properties: + clocks: false + + - if: + properties: + compatible: + contains: + enum: + - adi,max31341 + - adi,max31342 + + then: + properties: + reg: + items: + - const: 0x69 + + else: + properties: + reg: + items: + - const: 0x68 + +required: + - compatible + - reg + +examples: + - | + #include + i2c { + #address-cells =3D <1>; + #size-cells =3D <0>; + + rtc@68 { + reg =3D <0x68>; + compatible =3D "adi,max31329"; + clocks =3D <&clkin>; + interrupt-parent =3D <&gpio>; + interrupts =3D <26 IRQ_TYPE_EDGE_FALLING>; + }; + }; + - | + #include + i2c { + #address-cells =3D <1>; + #size-cells =3D <0>; + + rtc@68 { + reg =3D <0x68>; + compatible =3D "adi,max31331"; + #clock-cells =3D <0>; + }; + }; --=20 2.25.1