Received: by 2002:ad5:474a:0:0:0:0:0 with SMTP id i10csp1691463imu; Sat, 26 Jan 2019 08:30:59 -0800 (PST) X-Google-Smtp-Source: ALg8bN6q0Mah7zScWLOzjL7AmTjUWFjJ12wpsf7x2nQOJistMBS5fKYEJHJ+NA0zNyvxhGha3yse X-Received: by 2002:a17:902:a83:: with SMTP id 3mr14665449plp.276.1548520259118; Sat, 26 Jan 2019 08:30:59 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1548520259; cv=none; d=google.com; s=arc-20160816; b=EjO+9XSRsSzrNdWZD5efZwtsIsH+1V5hGdqaavX0fNuOo7B4zdK9Eph3TMtsLRHttf wf7sbdXwYMRv3v3fhbIrTtvsXb8RWN896f4Af/mfclh/cGQmt7YZa8dCzEOaQ3Vn3Cwx 6BRf/z3QjChI0edQYbSo1gt2WsSi7D3kr+Evvm+RXliFgfiHY9HYeTpTW/r58Ci9Q1ra lRqzXIBbmigkxS/W6SdfuWoPhCWQTUD192dWFtPWy50Lh9IxC4dvliIFX/mM+UGDjhJq wmlS6SXfKz7iDtRmQyMR7Vv4aGLOqbvVMr2wy9EBy2f299lTTsPnUm+DAb42TGWB2qJ2 SA6Q== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:content-transfer-encoding :content-language:in-reply-to:mime-version:user-agent:date :message-id:from:references:cc:to:subject:dkim-signature; bh=fFa/0BWhN7gscoZhoLEWj0tkxbSLeP2wYD7UzyuqCWU=; b=ojayHbMSr5zlCmJhh1xjhXRAED0JzmTtKjd//Qp8I2Qg5e0WdCbtSzZuXjU7z2jgb6 kkiUemCsfEi/dK99ZE48nPNMvcaUr795+Cqvz/1+fqHgXh2g8KjsO0dKeWBRnl5K57n9 MzMB7KSpeD2uTUJFimyUgReLPmwdCrz/tyWXeE6RIsNV2i6+ei7NCjtHqzNPedTzbwAP /0ctYUStKGuOS6aryrFazBPv2Y/mdeg6vota02IoQcrQdS3MEhm4caxme9WtZ0F7IZgn vW43X2jbJgWdG5dZWyLctgA/1vhpsW1lKo3DXIWcYXBDXHowrmc6bxP3etXEMmfoZL5O axUg== ARC-Authentication-Results: i=1; mx.google.com; dkim=fail header.i=@gmail.com header.s=20161025 header.b=dIrV2me0; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id b8si15418307plx.383.2019.01.26.08.30.43; Sat, 26 Jan 2019 08:30:59 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=fail header.i=@gmail.com header.s=20161025 header.b=dIrV2me0; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726264AbfAZQab (ORCPT + 99 others); Sat, 26 Jan 2019 11:30:31 -0500 Received: from mail-pg1-f193.google.com ([209.85.215.193]:42416 "EHLO mail-pg1-f193.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726038AbfAZQaa (ORCPT ); Sat, 26 Jan 2019 11:30:30 -0500 Received: by mail-pg1-f193.google.com with SMTP id d72so5406826pga.9; Sat, 26 Jan 2019 08:30:29 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:subject:to:cc:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-language:content-transfer-encoding; bh=fFa/0BWhN7gscoZhoLEWj0tkxbSLeP2wYD7UzyuqCWU=; b=dIrV2me0giwHSwcSUx+mqOuRrCKNpnIRBD/Goa3cvej7CmKl+jkbMq6z5b2W6RFneG vLklnPuVJYnwY/LcYM2cSK293VO7kfP4NH1JiO6NhQNmRXtsj98WLndt+sGLCwks/UTi bTmNoHbKvpSHRkfDtnoqWNo9TXH1kxOH7i1hWupSZ7Ye8RHToJyHMOvPWhneO/5LyqOW naTGjUXu1DsSTD9Vc8Ccd947GFTcaoGngsAI4ub7PXpbHcAbvDSWSzEgttCOfGaApJhX eY8Jomt4H/TF+GPnZSVobutbhvT3kQdFliybicCSwbjbtPqDq9zVoFqWCq3MvfD/mT3S kCDg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:subject:to:cc:references:from:message-id :date:user-agent:mime-version:in-reply-to:content-language :content-transfer-encoding; bh=fFa/0BWhN7gscoZhoLEWj0tkxbSLeP2wYD7UzyuqCWU=; b=JSd5L7a0EEdvpGiFN84hIXWh1/3XZ3+8poItrGCbuNyz/odD4JkKnua3nanTui5IDZ TGbsTYT1iel2RYwnIaXnCwGKrp6RtMFT8s8wTssuO4FvC3lHKsoYrAT39qoChG+RX8fk 4zC6WoeobnK98tleiIMbf0CvW/kcxH/0zYU3Kdg/oGag7GDrxAh3cy/QnZtmY6h+4jG7 f4Smmhe0gzsCq3FIy+tCuai37eE9cxLmOclWi/7q31hKe+Xk0hJDmUz9zOjMRcN+bIxC ov+Sr62fJ5lMwqfP/i1lhH+hS/fkxHmrzct/w1WzxZq1QMyiKJPUJL2QO5ZXV38MsoHN EeDg== X-Gm-Message-State: AJcUuke6t+6hsIsfSagJg0AfWCuu8iU6bnrvOUT6ihGch7pwjpZZjFaV 0kaYTh7AWYxqeRN1IBG9wKJcvk+M X-Received: by 2002:a63:f141:: with SMTP id o1mr14056626pgk.134.1548520228331; Sat, 26 Jan 2019 08:30:28 -0800 (PST) Received: from server.roeck-us.net ([2600:1700:e321:62f0:329c:23ff:fee3:9d7c]) by smtp.gmail.com with ESMTPSA id j9sm32982481pfi.86.2019.01.26.08.30.25 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Sat, 26 Jan 2019 08:30:27 -0800 (PST) Subject: Re: [RFC PATCH v2 08/10] rtc: bd70528: Initial support for ROHM bd70528 RTC To: Matti Vaittinen , mazziesaccount@gmail.com Cc: heikki.haikola@fi.rohmeurope.com, mikko.mutanen@fi.rohmeurope.com, lee.jones@linaro.org, robh+dt@kernel.org, mark.rutland@arm.com, broonie@kernel.org, gregkh@linuxfoundation.org, rafael@kernel.org, mturquette@baylibre.com, sboyd@kernel.org, linus.walleij@linaro.org, bgolaszewski@baylibre.com, sre@kernel.org, lgirdwood@gmail.com, a.zummo@towertech.it, alexandre.belloni@bootlin.com, wim@linux-watchdog.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-clk@vger.kernel.org, linux-gpio@vger.kernel.org, linux-pm@vger.kernel.org, linux-rtc@vger.kernel.org, linux-watchdog@vger.kernel.org References: <20190125110536.GA29321@localhost.localdomain> From: Guenter Roeck Message-ID: <35bbc5b9-5f8c-ec80-3eaa-bb2c0e2812c9@roeck-us.net> Date: Sat, 26 Jan 2019 08:30:24 -0800 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.2.1 MIME-Version: 1.0 In-Reply-To: <20190125110536.GA29321@localhost.localdomain> Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 7bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 1/25/19 3:05 AM, Matti Vaittinen wrote: > Support RTC block in ROHM bd70528 power management IC. Support > getting and setting the time and date as well as arming an alarm > which can also be used to wake the PMIC from standby state. > > HW supports wake interrupt only for the next 24 hours (sec, minute > and hour information only) so we limit also the alarm interrupt to > this 24 hours for the sake of consistency. > > Signed-off-by: Matti Vaittinen > --- > drivers/rtc/Kconfig | 8 + > drivers/rtc/Makefile | 1 + > drivers/rtc/rtc-bd70528.c | 451 ++++++++++++++++++++++++++++++++++++++++++++++ > 3 files changed, 460 insertions(+) > create mode 100644 drivers/rtc/rtc-bd70528.c > > diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig > index 225b0b8516f3..df6211cbd83f 100644 > --- a/drivers/rtc/Kconfig > +++ b/drivers/rtc/Kconfig > @@ -487,6 +487,14 @@ config RTC_DRV_M41T80_WDT > help > If you say Y here you will get support for the > watchdog timer in the ST M41T60 and M41T80 RTC chips series. > +config RTC_DRV_BD70528 > + tristate "ROHM BD70528 PMIC RTC" > + help > + If you say Y here you will get support for the RTC > + on ROHM BD70528 Power Management IC. > + > + This driver can also be built as a module. If so, the module > + will be called rtc-bd70528. > > config RTC_DRV_BQ32K > tristate "TI BQ32000" > diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile > index df022d820bee..740b13840913 100644 > --- a/drivers/rtc/Makefile > +++ b/drivers/rtc/Makefile > @@ -36,6 +36,7 @@ obj-$(CONFIG_RTC_DRV_ASM9260) += rtc-asm9260.o > obj-$(CONFIG_RTC_DRV_AT91RM9200)+= rtc-at91rm9200.o > obj-$(CONFIG_RTC_DRV_AT91SAM9) += rtc-at91sam9.o > obj-$(CONFIG_RTC_DRV_AU1XXX) += rtc-au1xxx.o > +obj-$(CONFIG_RTC_DRV_BD70528) += rtc-bd70528.o > obj-$(CONFIG_RTC_DRV_BQ32K) += rtc-bq32k.o > obj-$(CONFIG_RTC_DRV_BQ4802) += rtc-bq4802.o > obj-$(CONFIG_RTC_DRV_BRCMSTB) += rtc-brcmstb-waketimer.o > diff --git a/drivers/rtc/rtc-bd70528.c b/drivers/rtc/rtc-bd70528.c > new file mode 100644 > index 000000000000..250fb218c784 > --- /dev/null > +++ b/drivers/rtc/rtc-bd70528.c > @@ -0,0 +1,451 @@ > +// SPDX-License-Identifier: GPL-2.0-or-later > +// > +// Copyright (C) 2018 ROHM Semiconductors > +// > +// RTC driver for ROHM BD70528 PMIC > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +/* > + * We read regs RTC_SEC => RTC_YEAR > + * this struct is ordered according to chip registers. > + * Keep it u8 only to avoid padding issues. > + */ > +struct bd70528_rtc_day { > + u8 sec; > + u8 min; > + u8 hour; > +}; > + > +struct bd70528_rtc_data { > + struct bd70528_rtc_day time; > + u8 week; > + u8 day; > + u8 month; > + u8 year; > +}; > + > +struct bd70528_rtc_wake { > + struct bd70528_rtc_day time; > + u8 ctrl; > +}; > + > +struct bd70528_rtc_alm { > + struct bd70528_rtc_data data; > + u8 alm_mask; > + u8 alm_repeat; > +}; At least some of the above are directly associated with chip registers. I don't think this will work for all architectures without explicit packed attribute. > + > +struct bd70528_rtc { > + struct bd70528 *mfd; > + struct device *dev; > +}; > + > +static int bd70528_set_wake(struct bd70528 *bd70528, > + int enable, int *old_state) > +{ > + int ret; > + unsigned int ctrl_reg; > + > + ret = regmap_read(bd70528->chip.regmap, BD70528_REG_WAKE_EN, &ctrl_reg); > + if (ret) > + return ret; > + > + if (old_state) { > + if (ctrl_reg & BD70528_MASK_WAKE_EN) > + *old_state |= BD70528_WAKE_STATE_BIT; > + else > + *old_state &= ~BD70528_WAKE_STATE_BIT; > + > + if ((!enable) == (!(*old_state & BD70528_WAKE_STATE_BIT))) > + return 0; I think if (enable == !!(*old_state & BD70528_WAKE_STATE_BIT)) would be much better readable. Even if not, there are way too many () in the above conditional. > + } > + > + if (enable) > + ctrl_reg |= BD70528_MASK_WAKE_EN; > + else > + ctrl_reg &= ~BD70528_MASK_WAKE_EN; > + > + return regmap_write(bd70528->chip.regmap, BD70528_REG_WAKE_EN, > + ctrl_reg); > +} > + > +static int bd70528_set_elapsed_tmr(struct bd70528 *bd70528, > + int enable, int *old_state) > +{ > + int ret; > + unsigned int ctrl_reg; > + > + /* > + * TBD > + * What is the purpose of elapsed timer ? > + * Is the timeout registers counting down, or is the disable - re-enable > + * going to restart the elapsed-time counting? If counting is restarted > + * the timeout should be decreased by the amount of time that has > + * elapsed since starting the timer. Maybe we should store the monotonic > + * clock value when timer is started so that if RTC is set while timer > + * is armed we could do the compensation. This is a hack if RTC/system > + * clk are drifting. OTOH, RTC controlled via I2C is in any case > + * inaccurate... > + */ > + ret = regmap_read(bd70528->chip.regmap, BD70528_REG_ELAPSED_TIMER_EN, > + &ctrl_reg); > + if (ret) > + return ret; > + > + if (old_state) { > + if (ctrl_reg & BD70528_MASK_ELAPSED_TIMER_EN) > + *old_state |= BD70528_ELAPSED_STATE_BIT; > + else > + *old_state &= ~BD70528_ELAPSED_STATE_BIT; > + > + if ((!enable) == (!(*old_state & BD70528_ELAPSED_STATE_BIT))) > + return 0; > + } > + > + if (enable) > + ctrl_reg |= BD70528_MASK_ELAPSED_TIMER_EN; > + else > + ctrl_reg &= ~BD70528_MASK_ELAPSED_TIMER_EN; > + > + return regmap_write(bd70528->chip.regmap, BD70528_REG_ELAPSED_TIMER_EN, > + ctrl_reg); > +} > + > +static int bd70528_set_rtc_based_timers(struct bd70528_rtc *r, int new_state, > + int *old_state) > +{ > + int ret; > + > + ret = r->mfd->wdt_set(r->mfd, new_state & BD70528_WDT_STATE_BIT, > + old_state); > + if (ret) { > + dev_err(r->dev, > + "Failed to disable WDG for RTC setting (%d)\n", ret); > + return ret; > + } > + ret = bd70528_set_elapsed_tmr(r->mfd, > + new_state & BD70528_ELAPSED_STATE_BIT, > + old_state); > + if (ret) { > + dev_err(r->dev, > + "Failed to disable 'elapsed timer' for RTC setting\n"); > + return ret; > + } > + ret = bd70528_set_wake(r->mfd, new_state & BD70528_WAKE_STATE_BIT, > + old_state); > + if (ret) { > + dev_err(r->dev, > + "Failed to disable 'wake timer' for RTC setting\n"); > + return ret; > + } > + > + return ret; > +} > + > +static int bd70528_re_enable_rtc_based_timers(struct bd70528_rtc *r, > + int old_state) > +{ > + int ret; > + > + ret = bd70528_set_rtc_based_timers(r, old_state, NULL); > + mutex_unlock(&r->mfd->rtc_timer_lock); > + > + return ret; > +} > + > +static int bd70528_disable_rtc_based_timers(struct bd70528_rtc *r, > + int *old_state) > +{ > + mutex_lock(&r->mfd->rtc_timer_lock); > + > + return bd70528_set_rtc_based_timers(r, 0, old_state); > +} > + > +static inline void tmday2rtc(struct rtc_time *t, struct bd70528_rtc_day *d) > +{ > + d->sec &= ~BD70528_MASK_RTC_SEC; > + d->min &= ~BD70528_MASK_RTC_MINUTE; > + d->hour &= ~BD70528_MASK_RTC_HOUR; > + d->sec |= bin2bcd(t->tm_sec); > + d->min |= bin2bcd(t->tm_min); > + d->hour |= bin2bcd(t->tm_hour); > +} > + > +static inline void tm2rtc(struct rtc_time *t, struct bd70528_rtc_data *r) > +{ > + r->day &= ~BD70528_MASK_RTC_DAY; > + r->week &= ~BD70528_MASK_RTC_WEEK; > + r->month &= ~BD70528_MASK_RTC_MONTH; > + /* > + * PM and 24H bits are not used by Wake - thus we clear them > + * here and not in tmday2rtc() which is also used by wake. > + */ > + r->time.hour &= ~(BD70528_MASK_RTC_HOUR_PM | BD70528_MASK_RTC_HOUR_24H); > + > + tmday2rtc(t, &r->time); > + /* > + * We do always set time in 24H mode. > + */ > + r->time.hour |= BD70528_MASK_RTC_HOUR_24H; > + r->day |= bin2bcd(t->tm_mday); > + r->week |= bin2bcd(t->tm_wday); > + r->month |= bin2bcd(t->tm_mon + 1); > + r->year = bin2bcd(t->tm_year-100); > +} > + > +static inline void rtc2tm(struct bd70528_rtc_data *r, struct rtc_time *t) > +{ > + t->tm_sec = bcd2bin(r->time.sec & BD70528_MASK_RTC_SEC); > + t->tm_min = bcd2bin(r->time.min & BD70528_MASK_RTC_MINUTE); > + t->tm_hour = bcd2bin(r->time.hour & BD70528_MASK_RTC_HOUR); > + /* > + * If RTC is in 12H mode, then bit BD70528_MASK_RTC_HOUR_PM > + * is not BCD value but tells whether it is AM or PM > + */ > + if (!(r->time.hour & BD70528_MASK_RTC_HOUR_24H)) { > + t->tm_hour %= 12; > + if (r->time.hour & BD70528_MASK_RTC_HOUR_PM) > + t->tm_hour += 12; > + } > + t->tm_mday = bcd2bin(r->day & BD70528_MASK_RTC_DAY); > + t->tm_mon = bcd2bin(r->month & BD70528_MASK_RTC_MONTH) - 1; > + t->tm_year = 100 + bcd2bin(r->year & BD70528_MASK_RTC_YEAR); > + t->tm_wday = bcd2bin(r->week & BD70528_MASK_RTC_WEEK); > +} > + > +static int bd70528_set_alarm(struct device *dev, struct rtc_wkalrm *a) > +{ > + struct bd70528_rtc_wake wake; > + struct bd70528_rtc_alm alm; > + int ret; > + struct bd70528_rtc *r = dev_get_drvdata(dev); > + struct bd70528 *bd70528 = r->mfd; > + > + ret = regmap_bulk_read(bd70528->chip.regmap, BD70528_REG_RTC_WAKE_START, > + &wake, sizeof(wake)); > + if (ret) { > + dev_err(dev, "Failed to read wake regs\n"); > + return ret; > + } > + > + ret = regmap_bulk_read(bd70528->chip.regmap, BD70528_REG_RTC_ALM_START, > + &alm, sizeof(alm)); > + if (ret) { > + dev_err(dev, "Failed to read alarm regs\n"); > + return ret; > + } > + > + tm2rtc(&a->time, &alm.data); > + tmday2rtc(&a->time, &wake.time); > + > + if (a->enabled) { > + alm.alm_mask &= ~BD70528_MASK_ALM_EN; > + wake.ctrl |= BD70528_MASK_WAKE_EN; > + } else { > + alm.alm_mask |= BD70528_MASK_ALM_EN; > + wake.ctrl &= ~BD70528_MASK_WAKE_EN; > + } > + > + ret = regmap_bulk_write(bd70528->chip.regmap, > + BD70528_REG_RTC_WAKE_START, &wake, > + sizeof(wake)); > + if (ret) { > + dev_err(dev, "Failed to set wake time\n"); > + return ret; > + } > + ret = regmap_bulk_write(bd70528->chip.regmap, BD70528_REG_RTC_ALM_START, > + &alm, sizeof(alm)); > + if (ret) > + dev_err(dev, "Failed to set alarm time\n"); > + > + return ret; > +} > + > +static int bd70528_read_alarm(struct device *dev, struct rtc_wkalrm *a) > +{ > + struct bd70528_rtc_alm alm; > + int ret; > + struct bd70528_rtc *r = dev_get_drvdata(dev); > + struct bd70528 *bd70528 = r->mfd; > + > + ret = regmap_bulk_read(bd70528->chip.regmap, BD70528_REG_RTC_ALM_START, > + &alm, sizeof(alm)); > + if (ret) { > + dev_err(dev, "Failed to read alarm regs\n"); > + return ret; > + } > + > + rtc2tm(&alm.data, &a->time); > + a->time.tm_mday = -1; > + a->time.tm_mon = -1; > + a->time.tm_year = -1; > + if (alm.alm_mask & BD70528_MASK_ALM_EN) > + a->enabled = 0; > + else > + a->enabled = 1; > + Without conditional: a->enabled = !(alm.alm_mask & BD70528_MASK_ALM_EN); > + a->pending = 0; > + > + return 0; > +} > + > +static int bd70528_set_time(struct device *dev, struct rtc_time *t) > +{ > + int ret, old_states; > + struct bd70528_rtc_data rtc_data; > + struct bd70528_rtc *r = dev_get_drvdata(dev); > + struct bd70528 *bd70528 = r->mfd; > + > + ret = bd70528_disable_rtc_based_timers(r, &old_states); > + AFAICS the disable/enable functions are only called once. Since they also apply set / clear a mutex, I find that a bit confusing. I think it would be better to fold the code into this function. If anything, I could imagine something like mutex_lock(); ret = bd70528_set_time_locked(); mutex_unlock() to simplify error handling. > + ret = regmap_bulk_read(bd70528->chip.regmap, > + BD70528_REG_RTC_START, &rtc_data, > + sizeof(rtc_data)); > + > + tm2rtc(t, &rtc_data); > + > + ret = regmap_bulk_write(bd70528->chip.regmap, > + BD70528_REG_RTC_START, &rtc_data, > + sizeof(rtc_data)); > + > + ret = bd70528_re_enable_rtc_based_timers(r, old_states); > + Kind of off that all the error returns are ignored here. > + return 0; > +} > +static int bd70528_get_time(struct device *dev, struct rtc_time *t) > +{ > + struct bd70528_rtc *r = dev_get_drvdata(dev); > + struct bd70528 *bd70528 = r->mfd; > + struct bd70528_rtc_data rtc_data; > + int ret; > + > + /* read the RTC date and time registers all at once */ > + ret = regmap_bulk_read(bd70528->chip.regmap, > + BD70528_REG_RTC_START, &rtc_data, > + sizeof(rtc_data)); > + if (ret) { > + dev_err(dev, "Failed to read RTC time (err %d)\n", ret); > + return ret; > + } > + > + rtc2tm(&rtc_data, t); > + > + return 0; > +} > + > +static const struct rtc_class_ops bd70528_rtc_ops = { > + .read_time = bd70528_get_time, > + .set_time = bd70528_set_time, > + .read_alarm = bd70528_read_alarm, > + .set_alarm = bd70528_set_alarm, > +}; > + > +static irqreturn_t alm_hndlr(int irq, void *data) > +{ > + struct rtc_device *rtc = data; > + > + rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF | RTC_PF); > + return IRQ_HANDLED; > +} > + > +static int bd70528_probe(struct platform_device *pdev) > +{ > + struct bd70528_rtc *bd_rtc; > + struct bd70528 *mfd; > + int ret; > + struct rtc_device *rtc; > + int irq; > + unsigned int hr; > + > + mfd = dev_get_drvdata(pdev->dev.parent); > + if (!mfd) { > + dev_err(&pdev->dev, "No MFD driver data\n"); > + return -EINVAL; > + } > + bd_rtc = devm_kzalloc(&pdev->dev, sizeof(*bd_rtc), GFP_KERNEL); > + if (!bd_rtc) > + return -ENOMEM; > + > + bd_rtc->mfd = mfd; > + bd_rtc->dev = &pdev->dev; > + > + irq = platform_get_irq_byname(pdev, "bd70528-rtc-alm"); > + > + if (irq < 0) { > + dev_err(&pdev->dev, "Failed to get irq\n"); > + return irq; > + } > + > + platform_set_drvdata(pdev, bd_rtc); > + > + ret = regmap_read(mfd->chip.regmap, BD70528_REG_RTC_HOUR, &hr); > + > + if (ret) { > + dev_err(&pdev->dev, "Failed to reag RTC clock\n"); > + return ret; > + } > + > + if (!(hr & BD70528_MASK_RTC_HOUR_24H)) { > + struct rtc_time t; > + > + ret = bd70528_get_time(&pdev->dev, &t); > + if (ret) > + return ret; > + > + ret = bd70528_set_time(&pdev->dev, &t); > + if (ret) > + return ret; > + } > + > + if (ret) { > + dev_err(&pdev->dev, "Setting 24H clock for RTC failed\n"); > + return ret; > + } > + > + device_set_wakeup_capable(&pdev->dev, true); > + device_wakeup_enable(&pdev->dev); > + rtc = devm_rtc_device_register(&pdev->dev, "bd70528-rtc", > + &bd70528_rtc_ops, THIS_MODULE); > + if (IS_ERR(rtc)) { > + dev_err(&pdev->dev, "Registering RTC failed\n"); > + return PTR_ERR(rtc); > + } > + > + ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, &alm_hndlr, > + IRQF_ONESHOT, "bd70528-rtc", rtc); > + > + /* > + * BD70528 irq controller is not touching the main mask register. > + * So enable the RTC block interrupts at main level. We can just > + * leave them enabled as irq-controller should disable irqs > + * from sub-registers when IRQ is disabled or freed. > + */ > + ret = regmap_update_bits(mfd->chip.regmap, > + BD70528_REG_INT_MAIN_MASK, > + BD70528_INT_RTC_MASK, 0); > + > + if (ret) > + dev_err(&pdev->dev, "Failed to enable RTC interrupts\n"); > + > + return ret; > +} > + > +static struct platform_driver bd70528_rtc = { > + .driver = { > + .name = "bd70528-rtc" > + }, > + .probe = bd70528_probe, > +}; > + > +module_platform_driver(bd70528_rtc); > + > +MODULE_AUTHOR("Matti Vaittinen "); > +MODULE_DESCRIPTION("BD70528 RTC driver"); > +MODULE_LICENSE("GPL"); >