/* * The Spreadtrum RTC controller has 3 groups registers, including time, normal * alarm and auxiliary alarm. The time group registers are used to set RTC time, * the normal alarm registers are used to set normal alarm, and the auxiliary * alarm registers are used to set auxiliary alarm. Both alarm event and * auxiliary alarm event can wake up system from deep sleep, but only alarm * event can power up system from power down status.
*/ enum sprd_rtc_reg_types {
SPRD_RTC_TIME,
SPRD_RTC_ALARM,
SPRD_RTC_AUX_ALARM,
};
ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_SPG_VALUE, &val); if (ret) return ret;
val &= ~SPRD_RTC_ALMLOCK_MASK; if (lock)
val |= SPRD_RTC_ALM_LOCK; else
val |= SPRD_RTC_ALM_UNLOCK | SPRD_RTC_POWEROFF_ALM_FLAG;
ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_SPG_UPD, val); if (ret) return ret;
/* wait until the SPG value is updated successfully */
ret = regmap_read_poll_timeout(rtc->regmap,
rtc->base + SPRD_RTC_INT_RAW_STS, val,
(val & SPRD_RTC_SPG_UPD_EN),
SPRD_RTC_POLL_DELAY_US,
SPRD_RTC_POLL_TIMEOUT); if (ret) {
dev_err(rtc->dev, "failed to update SPG value:%d\n", ret); return ret;
}
/* convert seconds to RTC time format */
day = div_s64_rem(secs, 86400, &rem);
hour = rem / 3600;
rem -= hour * 3600;
min = rem / 60;
sec = rem - min * 60;
ret = regmap_write(rtc->regmap, rtc->base + sec_reg, sec); if (ret) return ret;
ret = regmap_write(rtc->regmap, rtc->base + min_reg, min); if (ret) return ret;
ret = regmap_write(rtc->regmap, rtc->base + hour_reg, hour); if (ret) return ret;
ret = regmap_write(rtc->regmap, rtc->base + day_reg, day); if (ret) return ret;
if (type == SPRD_RTC_AUX_ALARM) return 0;
/* * Since the time and normal alarm registers are put in always-power-on * region supplied by VDDRTC, then these registers changing time will * be very long, about 125ms. Thus here we should wait until all * values are updated successfully.
*/
ret = regmap_read_poll_timeout(rtc->regmap,
rtc->base + SPRD_RTC_INT_RAW_STS, val,
((val & sts_mask) == sts_mask),
SPRD_RTC_POLL_DELAY_US,
SPRD_RTC_POLL_TIMEOUT); if (ret < 0) {
dev_err(rtc->dev, "set time/alarm values timeout\n"); return ret;
}
/* clear the auxiliary alarm interrupt status */
ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,
SPRD_RTC_AUXALM_EN); if (ret) return ret;
ret = sprd_rtc_set_secs(rtc, SPRD_RTC_AUX_ALARM, secs); if (ret) return ret;
if (alrm->enabled) {
ret = regmap_update_bits(rtc->regmap,
rtc->base + SPRD_RTC_INT_EN,
SPRD_RTC_AUXALM_EN,
SPRD_RTC_AUXALM_EN);
} else {
ret = regmap_update_bits(rtc->regmap,
rtc->base + SPRD_RTC_INT_EN,
SPRD_RTC_AUXALM_EN, 0);
}
ret = sprd_rtc_set_secs(rtc, SPRD_RTC_TIME, secs); if (ret) return ret;
if (!rtc->valid) { /* Clear RTC power status firstly */
ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_PWR_CTRL,
SPRD_RTC_POWER_STS_CLEAR); if (ret) return ret;
/* * Set RTC power status to indicate now RTC has valid time * values.
*/
ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_PWR_CTRL,
SPRD_RTC_POWER_STS_VALID); if (ret) return ret;
/* * The RTC core checks to see if there is an alarm already set in RTC * hardware, and we always read the normal alarm at this time.
*/
ret = sprd_rtc_get_secs(rtc, SPRD_RTC_ALARM, &secs); if (ret) return ret;
rtc_time64_to_tm(secs, &alrm->time);
ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_INT_EN, &val); if (ret) return ret;
alrm->enabled = !!(val & SPRD_RTC_ALARM_EN);
ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_INT_RAW_STS, &val); if (ret) return ret;
/* * We have 2 groups alarms: normal alarm and auxiliary alarm. Since * both normal alarm event and auxiliary alarm event can wake up system * from deep sleep, but only alarm event can power up system from power * down status. Moreover we do not need to poll about 125ms when * updating auxiliary alarm registers. Thus we usually set auxiliary * alarm when wake up system from deep sleep, and for other scenarios, * we should set normal alarm with polling status. * * So here we check if the alarm time is set by aie_timer, if yes, we * should set normal alarm, if not, we should set auxiliary alarm which * means it is just a wake event.
*/ if (!rtc->rtc->aie_timer.enabled || rtc_tm_sub(&aie_time, &alrm->time)) return sprd_rtc_set_aux_alarm(dev, alrm);
/* clear the alarm interrupt status firstly */
ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,
SPRD_RTC_ALARM_EN); if (ret) return ret;
ret = sprd_rtc_set_secs(rtc, SPRD_RTC_ALARM, secs); if (ret) return ret;
if (alrm->enabled) {
ret = regmap_update_bits(rtc->regmap,
rtc->base + SPRD_RTC_INT_EN,
SPRD_RTC_ALARM_EN,
SPRD_RTC_ALARM_EN); if (ret) return ret;
/* unlock the alarm to enable the alarm function. */
ret = sprd_rtc_lock_alarm(rtc, false);
} else {
regmap_update_bits(rtc->regmap,
rtc->base + SPRD_RTC_INT_EN,
SPRD_RTC_ALARM_EN, 0);
/* * Lock the alarm function in case fake alarm event will power * up systems.
*/
ret = sprd_rtc_lock_alarm(rtc, true);
}
staticint sprd_rtc_check_power_down(struct sprd_rtc *rtc)
{
u32 val; int ret;
ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_PWR_STS, &val); if (ret) return ret;
/* * If the RTC power status value is SPRD_RTC_POWER_RESET_VALUE, which * means the RTC has been powered down, so the RTC time values are * invalid.
*/
rtc->valid = val != SPRD_RTC_POWER_RESET_VALUE; return 0;
}
staticint sprd_rtc_check_alarm_int(struct sprd_rtc *rtc)
{
u32 val; int ret;
ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_SPG_VALUE, &val); if (ret) return ret;
/* * The SPRD_RTC_INT_EN register is not put in always-power-on region * supplied by VDDRTC, so we should check if we need enable the alarm * interrupt when system booting. * * If we have set SPRD_RTC_POWEROFF_ALM_FLAG which is saved in * always-power-on region, that means we have set one alarm last time, * so we should enable the alarm interrupt to help RTC core to see if * there is an alarm already set in RTC hardware.
*/ if (!(val & SPRD_RTC_POWEROFF_ALM_FLAG)) return 0;
/* check if we need set the alarm interrupt */
ret = sprd_rtc_check_alarm_int(rtc); if (ret) {
dev_err(&pdev->dev, "failed to check RTC alarm interrupt\n"); return ret;
}
/* check if RTC time values are valid */
ret = sprd_rtc_check_power_down(rtc); if (ret) {
dev_err(&pdev->dev, "failed to check RTC time values\n"); return ret;
}
ret = devm_request_threaded_irq(&pdev->dev, rtc->irq, NULL,
sprd_rtc_handler,
IRQF_ONESHOT | IRQF_EARLY_RESUME,
pdev->name, rtc); if (ret < 0) {
dev_err(&pdev->dev, "failed to request RTC irq\n"); return ret;
}
device_init_wakeup(&pdev->dev, true);
rtc->rtc->ops = &sprd_rtc_ops;
rtc->rtc->range_min = 0;
rtc->rtc->range_max = 5662310399LL;
ret = devm_rtc_register_device(rtc->rtc); if (ret) {
device_init_wakeup(&pdev->dev, false); return ret;
}
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
