From: Rosen Penev Date: Sun, 9 Sep 2018 04:23:57 +0000 (-0700) Subject: mvebu: Replace RTC initialization patch with upstreamed version X-Git-Url: http://git.lede-project.org./?a=commitdiff_plain;h=6a2ee91267a09fd77dee70cf3b0ba8b9b905476f;p=openwrt%2Fstaging%2Fnoltari.git mvebu: Replace RTC initialization patch with upstreamed version While we're at it, rename the patches to their proper git format-patch name. Tested on a Turris Omnia. Signed-off-by: Rosen Penev --- diff --git a/target/linux/mvebu/patches-4.14/420-rtc-armada38x-add-support-for-trimming-the-RTC.patch b/target/linux/mvebu/patches-4.14/420-rtc-armada38x-add-support-for-trimming-the-RTC.patch new file mode 100644 index 0000000000..2974a69760 --- /dev/null +++ b/target/linux/mvebu/patches-4.14/420-rtc-armada38x-add-support-for-trimming-the-RTC.patch @@ -0,0 +1,143 @@ +commit f94ffbc2c2a4128c4412bb483d0807722dfb682b +Author: Russell King +Date: Fri Sep 29 11:23:31 2017 +0100 + + rtc: armada38x: add support for trimming the RTC + + Add support for trimming the RTC using the offset mechanism. This RTC + supports two modes: low update mode and high update mode. Low update + mode has finer precision than high update mode, so we use the low mode + where possible. + + Signed-off-by: Russell King + Signed-off-by: Alexandre Belloni + +--- a/drivers/rtc/rtc-armada38x.c ++++ b/drivers/rtc/rtc-armada38x.c +@@ -28,6 +28,8 @@ + #define RTC_IRQ_AL_EN BIT(0) + #define RTC_IRQ_FREQ_EN BIT(1) + #define RTC_IRQ_FREQ_1HZ BIT(2) ++#define RTC_CCR 0x18 ++#define RTC_CCR_MODE BIT(15) + + #define RTC_TIME 0xC + #define RTC_ALARM1 0x10 +@@ -343,18 +345,117 @@ static irqreturn_t armada38x_rtc_alarm_i + return IRQ_HANDLED; + } + ++/* ++ * The information given in the Armada 388 functional spec is complex. ++ * They give two different formulas for calculating the offset value, ++ * but when considering "Offset" as an 8-bit signed integer, they both ++ * reduce down to (we shall rename "Offset" as "val" here): ++ * ++ * val = (f_ideal / f_measured - 1) / resolution where f_ideal = 32768 ++ * ++ * Converting to time, f = 1/t: ++ * val = (t_measured / t_ideal - 1) / resolution where t_ideal = 1/32768 ++ * ++ * => t_measured / t_ideal = val * resolution + 1 ++ * ++ * "offset" in the RTC interface is defined as: ++ * t = t0 * (1 + offset * 1e-9) ++ * where t is the desired period, t0 is the measured period with a zero ++ * offset, which is t_measured above. With t0 = t_measured and t = t_ideal, ++ * offset = (t_ideal / t_measured - 1) / 1e-9 ++ * ++ * => t_ideal / t_measured = offset * 1e-9 + 1 ++ * ++ * so: ++ * ++ * offset * 1e-9 + 1 = 1 / (val * resolution + 1) ++ * ++ * We want "resolution" to be an integer, so resolution = R * 1e-9, giving ++ * offset = 1e18 / (val * R + 1e9) - 1e9 ++ * val = (1e18 / (offset + 1e9) - 1e9) / R ++ * with a common transformation: ++ * f(x) = 1e18 / (x + 1e9) - 1e9 ++ * offset = f(val * R) ++ * val = f(offset) / R ++ * ++ * Armada 38x supports two modes, fine mode (954ppb) and coarse mode (3815ppb). ++ */ ++static long armada38x_ppb_convert(long ppb) ++{ ++ long div = ppb + 1000000000L; ++ ++ return div_s64(1000000000000000000LL + div / 2, div) - 1000000000L; ++} ++ ++static int armada38x_rtc_read_offset(struct device *dev, long *offset) ++{ ++ struct armada38x_rtc *rtc = dev_get_drvdata(dev); ++ unsigned long ccr, flags; ++ long ppb_cor; ++ ++ spin_lock_irqsave(&rtc->lock, flags); ++ ccr = rtc->data->read_rtc_reg(rtc, RTC_CCR); ++ spin_unlock_irqrestore(&rtc->lock, flags); ++ ++ ppb_cor = (ccr & RTC_CCR_MODE ? 3815 : 954) * (s8)ccr; ++ /* ppb_cor + 1000000000L can never be zero */ ++ *offset = armada38x_ppb_convert(ppb_cor); ++ ++ return 0; ++} ++ ++static int armada38x_rtc_set_offset(struct device *dev, long offset) ++{ ++ struct armada38x_rtc *rtc = dev_get_drvdata(dev); ++ unsigned long ccr = 0; ++ long ppb_cor, off; ++ ++ /* ++ * The maximum ppb_cor is -128 * 3815 .. 127 * 3815, but we ++ * need to clamp the input. This equates to -484270 .. 488558. ++ * Not only is this to stop out of range "off" but also to ++ * avoid the division by zero in armada38x_ppb_convert(). ++ */ ++ offset = clamp(offset, -484270L, 488558L); ++ ++ ppb_cor = armada38x_ppb_convert(offset); ++ ++ /* ++ * Use low update mode where possible, which gives a better ++ * resolution of correction. ++ */ ++ off = DIV_ROUND_CLOSEST(ppb_cor, 954); ++ if (off > 127 || off < -128) { ++ ccr = RTC_CCR_MODE; ++ off = DIV_ROUND_CLOSEST(ppb_cor, 3815); ++ } ++ ++ /* ++ * Armada 388 requires a bit pattern in bits 14..8 depending on ++ * the sign bit: { 0, ~S, S, S, S, S, S } ++ */ ++ ccr |= (off & 0x3fff) ^ 0x2000; ++ rtc_delayed_write(ccr, rtc, RTC_CCR); ++ ++ return 0; ++} ++ + static const struct rtc_class_ops armada38x_rtc_ops = { + .read_time = armada38x_rtc_read_time, + .set_time = armada38x_rtc_set_time, + .read_alarm = armada38x_rtc_read_alarm, + .set_alarm = armada38x_rtc_set_alarm, + .alarm_irq_enable = armada38x_rtc_alarm_irq_enable, ++ .read_offset = armada38x_rtc_read_offset, ++ .set_offset = armada38x_rtc_set_offset, + }; + + static const struct rtc_class_ops armada38x_rtc_ops_noirq = { + .read_time = armada38x_rtc_read_time, + .set_time = armada38x_rtc_set_time, + .read_alarm = armada38x_rtc_read_alarm, ++ .read_offset = armada38x_rtc_read_offset, ++ .set_offset = armada38x_rtc_set_offset, + }; + + static const struct armada38x_rtc_data armada38x_data = { diff --git a/target/linux/mvebu/patches-4.14/420-rtc-trimming-support.patch b/target/linux/mvebu/patches-4.14/420-rtc-trimming-support.patch deleted file mode 100644 index 2974a69760..0000000000 --- a/target/linux/mvebu/patches-4.14/420-rtc-trimming-support.patch +++ /dev/null @@ -1,143 +0,0 @@ -commit f94ffbc2c2a4128c4412bb483d0807722dfb682b -Author: Russell King -Date: Fri Sep 29 11:23:31 2017 +0100 - - rtc: armada38x: add support for trimming the RTC - - Add support for trimming the RTC using the offset mechanism. This RTC - supports two modes: low update mode and high update mode. Low update - mode has finer precision than high update mode, so we use the low mode - where possible. - - Signed-off-by: Russell King - Signed-off-by: Alexandre Belloni - ---- a/drivers/rtc/rtc-armada38x.c -+++ b/drivers/rtc/rtc-armada38x.c -@@ -28,6 +28,8 @@ - #define RTC_IRQ_AL_EN BIT(0) - #define RTC_IRQ_FREQ_EN BIT(1) - #define RTC_IRQ_FREQ_1HZ BIT(2) -+#define RTC_CCR 0x18 -+#define RTC_CCR_MODE BIT(15) - - #define RTC_TIME 0xC - #define RTC_ALARM1 0x10 -@@ -343,18 +345,117 @@ static irqreturn_t armada38x_rtc_alarm_i - return IRQ_HANDLED; - } - -+/* -+ * The information given in the Armada 388 functional spec is complex. -+ * They give two different formulas for calculating the offset value, -+ * but when considering "Offset" as an 8-bit signed integer, they both -+ * reduce down to (we shall rename "Offset" as "val" here): -+ * -+ * val = (f_ideal / f_measured - 1) / resolution where f_ideal = 32768 -+ * -+ * Converting to time, f = 1/t: -+ * val = (t_measured / t_ideal - 1) / resolution where t_ideal = 1/32768 -+ * -+ * => t_measured / t_ideal = val * resolution + 1 -+ * -+ * "offset" in the RTC interface is defined as: -+ * t = t0 * (1 + offset * 1e-9) -+ * where t is the desired period, t0 is the measured period with a zero -+ * offset, which is t_measured above. With t0 = t_measured and t = t_ideal, -+ * offset = (t_ideal / t_measured - 1) / 1e-9 -+ * -+ * => t_ideal / t_measured = offset * 1e-9 + 1 -+ * -+ * so: -+ * -+ * offset * 1e-9 + 1 = 1 / (val * resolution + 1) -+ * -+ * We want "resolution" to be an integer, so resolution = R * 1e-9, giving -+ * offset = 1e18 / (val * R + 1e9) - 1e9 -+ * val = (1e18 / (offset + 1e9) - 1e9) / R -+ * with a common transformation: -+ * f(x) = 1e18 / (x + 1e9) - 1e9 -+ * offset = f(val * R) -+ * val = f(offset) / R -+ * -+ * Armada 38x supports two modes, fine mode (954ppb) and coarse mode (3815ppb). -+ */ -+static long armada38x_ppb_convert(long ppb) -+{ -+ long div = ppb + 1000000000L; -+ -+ return div_s64(1000000000000000000LL + div / 2, div) - 1000000000L; -+} -+ -+static int armada38x_rtc_read_offset(struct device *dev, long *offset) -+{ -+ struct armada38x_rtc *rtc = dev_get_drvdata(dev); -+ unsigned long ccr, flags; -+ long ppb_cor; -+ -+ spin_lock_irqsave(&rtc->lock, flags); -+ ccr = rtc->data->read_rtc_reg(rtc, RTC_CCR); -+ spin_unlock_irqrestore(&rtc->lock, flags); -+ -+ ppb_cor = (ccr & RTC_CCR_MODE ? 3815 : 954) * (s8)ccr; -+ /* ppb_cor + 1000000000L can never be zero */ -+ *offset = armada38x_ppb_convert(ppb_cor); -+ -+ return 0; -+} -+ -+static int armada38x_rtc_set_offset(struct device *dev, long offset) -+{ -+ struct armada38x_rtc *rtc = dev_get_drvdata(dev); -+ unsigned long ccr = 0; -+ long ppb_cor, off; -+ -+ /* -+ * The maximum ppb_cor is -128 * 3815 .. 127 * 3815, but we -+ * need to clamp the input. This equates to -484270 .. 488558. -+ * Not only is this to stop out of range "off" but also to -+ * avoid the division by zero in armada38x_ppb_convert(). -+ */ -+ offset = clamp(offset, -484270L, 488558L); -+ -+ ppb_cor = armada38x_ppb_convert(offset); -+ -+ /* -+ * Use low update mode where possible, which gives a better -+ * resolution of correction. -+ */ -+ off = DIV_ROUND_CLOSEST(ppb_cor, 954); -+ if (off > 127 || off < -128) { -+ ccr = RTC_CCR_MODE; -+ off = DIV_ROUND_CLOSEST(ppb_cor, 3815); -+ } -+ -+ /* -+ * Armada 388 requires a bit pattern in bits 14..8 depending on -+ * the sign bit: { 0, ~S, S, S, S, S, S } -+ */ -+ ccr |= (off & 0x3fff) ^ 0x2000; -+ rtc_delayed_write(ccr, rtc, RTC_CCR); -+ -+ return 0; -+} -+ - static const struct rtc_class_ops armada38x_rtc_ops = { - .read_time = armada38x_rtc_read_time, - .set_time = armada38x_rtc_set_time, - .read_alarm = armada38x_rtc_read_alarm, - .set_alarm = armada38x_rtc_set_alarm, - .alarm_irq_enable = armada38x_rtc_alarm_irq_enable, -+ .read_offset = armada38x_rtc_read_offset, -+ .set_offset = armada38x_rtc_set_offset, - }; - - static const struct rtc_class_ops armada38x_rtc_ops_noirq = { - .read_time = armada38x_rtc_read_time, - .set_time = armada38x_rtc_set_time, - .read_alarm = armada38x_rtc_read_alarm, -+ .read_offset = armada38x_rtc_read_offset, -+ .set_offset = armada38x_rtc_set_offset, - }; - - static const struct armada38x_rtc_data armada38x_data = { diff --git a/target/linux/mvebu/patches-4.14/421-rtc-armada38x-reset-after-rtc-power-loss.patch b/target/linux/mvebu/patches-4.14/421-rtc-armada38x-reset-after-rtc-power-loss.patch new file mode 100644 index 0000000000..e9291c456f --- /dev/null +++ b/target/linux/mvebu/patches-4.14/421-rtc-armada38x-reset-after-rtc-power-loss.patch @@ -0,0 +1,78 @@ +From 1a990fefb641398fb580a0ea0be99b0ff27cbb9b Mon Sep 17 00:00:00 2001 +From: Baruch Siach +Date: Thu, 21 Jun 2018 20:40:23 +0300 +Subject: [PATCH] rtc: armada38x: reset after rtc power loss + +When the RTC block looses power it needs a reset sequence to make it +usable again. Otherwise, writes to the time register have no effect. + +This reset sequence combines information from the mvebu_rtc driver in +the Marvell provided U-Boot, and the SolidRun provided U-Boot repo. + +Tested on the Armada 388 based SolidRun Clearfog Base. + +Signed-off-by: Baruch Siach +Acked-by: Gregory CLEMENT +Signed-off-by: Alexandre Belloni +--- + drivers/rtc/rtc-armada38x.c | 23 +++++++++++++++++++++++ + 1 file changed, 23 insertions(+) + +diff --git a/drivers/rtc/rtc-armada38x.c b/drivers/rtc/rtc-armada38x.c +index 1e4978c..bde53c8c 100644 +--- a/drivers/rtc/rtc-armada38x.c ++++ b/drivers/rtc/rtc-armada38x.c +@@ -30,6 +30,8 @@ + #define RTC_IRQ_FREQ_1HZ BIT(2) + #define RTC_CCR 0x18 + #define RTC_CCR_MODE BIT(15) ++#define RTC_CONF_TEST 0x1C ++#define RTC_NOMINAL_TIMING BIT(13) + + #define RTC_TIME 0xC + #define RTC_ALARM1 0x10 +@@ -75,6 +77,7 @@ struct armada38x_rtc { + void __iomem *regs_soc; + spinlock_t lock; + int irq; ++ bool initialized; + struct value_to_freq *val_to_freq; + struct armada38x_rtc_data *data; + }; +@@ -226,6 +229,23 @@ static int armada38x_rtc_read_time(struct device *dev, struct rtc_time *tm) + return 0; + } + ++static void armada38x_rtc_reset(struct armada38x_rtc *rtc) ++{ ++ u32 reg; ++ ++ reg = rtc->data->read_rtc_reg(rtc, RTC_CONF_TEST); ++ /* If bits [7:0] are non-zero, assume RTC was uninitialized */ ++ if (reg & 0xff) { ++ rtc_delayed_write(0, rtc, RTC_CONF_TEST); ++ msleep(500); /* Oscillator startup time */ ++ rtc_delayed_write(0, rtc, RTC_TIME); ++ rtc_delayed_write(SOC_RTC_ALARM1 | SOC_RTC_ALARM2, rtc, ++ RTC_STATUS); ++ rtc_delayed_write(RTC_NOMINAL_TIMING, rtc, RTC_CCR); ++ } ++ rtc->initialized = true; ++} ++ + static int armada38x_rtc_set_time(struct device *dev, struct rtc_time *tm) + { + struct armada38x_rtc *rtc = dev_get_drvdata(dev); +@@ -237,6 +257,9 @@ static int armada38x_rtc_set_time(struct device *dev, struct rtc_time *tm) + if (ret) + goto out; + ++ if (!rtc->initialized) ++ armada38x_rtc_reset(rtc); ++ + spin_lock_irqsave(&rtc->lock, flags); + rtc_delayed_write(time, rtc, RTC_TIME); + spin_unlock_irqrestore(&rtc->lock, flags); +-- +2.7.4 + diff --git a/target/linux/mvebu/patches-4.14/421-rtc-initialize.patch b/target/linux/mvebu/patches-4.14/421-rtc-initialize.patch deleted file mode 100644 index 47a5acc70d..0000000000 --- a/target/linux/mvebu/patches-4.14/421-rtc-initialize.patch +++ /dev/null @@ -1,74 +0,0 @@ -Some boards like the Turris Omnia have an RTC chip that does not get -initialized. Initializing the RTC at the driver level helps get rid of -bootloader hacks that write special register values. - ---- a/drivers/rtc/rtc-armada38x.c -+++ b/drivers/rtc/rtc-armada38x.c -@@ -30,6 +30,9 @@ - #define RTC_IRQ_FREQ_1HZ BIT(2) - #define RTC_CCR 0x18 - #define RTC_CCR_MODE BIT(15) -+#define RTC_CCR_NORMAL_PPB 0x2000 -+#define RTC_TEST_CONF 0x1c -+#define RTC_TEST_CONF_MASK 0xff - - #define RTC_TIME 0xC - #define RTC_ALARM1 0x10 -@@ -91,6 +94,7 @@ struct armada38x_rtc_data { - void (*clear_isr)(struct armada38x_rtc *rtc); - void (*unmask_interrupt)(struct armada38x_rtc *rtc); - u32 alarm; -+ void (*init_rtc)(struct armada38x_rtc *rtc); - }; - - /* -@@ -202,6 +206,23 @@ static void armada38x_unmask_interrupt(s - writel(val | SOC_RTC_ALARM1_MASK, rtc->regs_soc + SOC_RTC_INTERRUPT); - } - -+static void armada38x_rtc_init(struct armada38x_rtc *rtc) -+{ -+ u32 reg; -+ -+ /* Test RTC test configuration register bits [7:0] */ -+ reg = readl(rtc->regs + RTC_TEST_CONF); -+ /* If bits [7:0] are non-zero, assume RTC was uninitialized */ -+ if (reg & RTC_TEST_CONF_MASK) { -+ rtc_delayed_write(0, rtc, RTC_TEST_CONF); -+ rtc_delayed_write(0, rtc, RTC_TIME); -+ rtc_delayed_write((RTC_STATUS_ALARM1 | RTC_STATUS_ALARM2), -+ rtc, RTC_STATUS); -+ rtc_delayed_write(RTC_CCR_NORMAL_PPB, rtc, RTC_CCR); -+ } -+ return; -+} -+ - static void armada8k_clear_isr(struct armada38x_rtc *rtc) - { - writel(RTC_8K_ALARM2, rtc->regs_soc + RTC_8K_ISR); -@@ -464,6 +485,7 @@ static const struct armada38x_rtc_data a - .clear_isr = armada38x_clear_isr, - .unmask_interrupt = armada38x_unmask_interrupt, - .alarm = ALARM1, -+ .init_rtc = armada38x_rtc_init, - }; - - static const struct armada38x_rtc_data armada8k_data = { -@@ -558,6 +580,17 @@ static __init int armada38x_rtc_probe(st - dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret); - return ret; - } -+ -+ /* -+ * Try to detect if RTC is in uninitialized state. -+ * It is not definitive to know if the RTC is in an uninialized state or not, -+ * but the following call will read some bits in the RTC unit and guess if -+ * if it's in that state, and accordingly set it to sane default values. -+ */ -+ if (rtc->data->init_rtc) { -+ rtc->data->init_rtc(rtc); -+ } -+ - return 0; - } -