add new system file

hc

2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c

 kernel/drivers/rtc/rtc-omap.c
..
..
@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: GPL-2.0+
1
2
 /*
2
3
  * TI OMAP Real Time Clock interface for Linux
3
4
  *
..
..
@@ -6,14 +7,8 @@
6
7
  *
7
8
  * Copyright (C) 2006 David Brownell (new RTC framework)
8
9
  * Copyright (C) 2014 Johan Hovold <johan@kernel.org>
9
- *
10
- * This program is free software; you can redistribute it and/or
11
- * modify it under the terms of the GNU General Public License
12
- * as published by the Free Software Foundation; either version
13
- * 2 of the License, or (at your option) any later version.
14
10
  */
15
11
 
16
-#include <dt-bindings/gpio/gpio.h>
17
12
 #include <linux/bcd.h>
18
13
 #include <linux/clk.h>
19
14
 #include <linux/delay.h>
..
..
@@ -30,6 +25,7 @@
30
25
 #include <linux/platform_device.h>
31
26
 #include <linux/pm_runtime.h>
32
27
 #include <linux/rtc.h>
28
+#include <linux/rtc/rtc-omap.h>
33
29
 
34
30
 /*
35
31
  * The OMAP RTC is a year/month/day/hours/minutes/seconds BCD clock
..
..
@@ -271,7 +267,7 @@
271
267
 }
272
268
 
273
269
 /* this hardware doesn't support "don't care" alarm fields */
274
-static int tm2bcd(struct rtc_time *tm)
270
+static void tm2bcd(struct rtc_time *tm)
275
271
 {
276
272
 	tm->tm_sec = bin2bcd(tm->tm_sec);
277
273
 	tm->tm_min = bin2bcd(tm->tm_min);
..
..
@@ -279,13 +275,7 @@
279
275
 	tm->tm_mday = bin2bcd(tm->tm_mday);
280
276
 
281
277
 	tm->tm_mon = bin2bcd(tm->tm_mon + 1);
282
-
283
-	/* epoch == 1900 */
284
-	if (tm->tm_year < 100 || tm->tm_year > 199)
285
-		return -EINVAL;
286
278
 	tm->tm_year = bin2bcd(tm->tm_year - 100);
287
-
288
-	return 0;
289
279
 }
290
280
 
291
281
 static void bcd2tm(struct rtc_time *tm)
..
..
@@ -328,8 +318,7 @@
328
318
 {
329
319
 	struct omap_rtc *rtc = dev_get_drvdata(dev);
330
320
 
331
-	if (tm2bcd(tm) < 0)
332
-		return -EINVAL;
321
+	tm2bcd(tm);
333
322
 
334
323
 	local_irq_disable();
335
324
 	rtc_wait_not_busy(rtc);
..
..
@@ -378,8 +367,7 @@
378
367
 	struct omap_rtc *rtc = dev_get_drvdata(dev);
379
368
 	u8 reg, irqwake_reg = 0;
380
369
 
381
-	if (tm2bcd(&alm->time) < 0)
382
-		return -EINVAL;
370
+	tm2bcd(&alm->time);
383
371
 
384
372
 	local_irq_disable();
385
373
 	rtc_wait_not_busy(rtc);
..
..
@@ -415,25 +403,17 @@
415
403
 
416
404
 static struct omap_rtc *omap_rtc_power_off_rtc;
417
405
 
418
-/*
419
- * omap_rtc_poweroff: RTC-controlled power off
420
- *
421
- * The RTC can be used to control an external PMIC via the pmic_power_en pin,
422
- * which can be configured to transition to OFF on ALARM2 events.
423
- *
424
- * Notes:
425
- * The two-second alarm offset is the shortest offset possible as the alarm
426
- * registers must be set before the next timer update and the offset
427
- * calculation is too heavy for everything to be done within a single access
428
- * period (~15 us).
429
- *
430
- * Called with local interrupts disabled.
406
+/**
407
+ * omap_rtc_power_off_program: Set the pmic power off sequence. The RTC
408
+ * generates pmic_pwr_enable control, which can be used to control an external
409
+ * PMIC.
431
410
  */
432
-static void omap_rtc_power_off(void)
411
+int omap_rtc_power_off_program(struct device *dev)
433
412
 {
434
413
 	struct omap_rtc *rtc = omap_rtc_power_off_rtc;
435
414
 	struct rtc_time tm;
436
415
 	unsigned long now;
416
+	int seconds;
437
417
 	u32 val;
438
418
 
439
419
 	rtc->type->unlock(rtc);
..
..
@@ -441,17 +421,18 @@
441
421
 	val = rtc_readl(rtc, OMAP_RTC_PMIC_REG);
442
422
 	rtc_writel(rtc, OMAP_RTC_PMIC_REG, val | OMAP_RTC_PMIC_POWER_EN_EN);
443
423
 
444
-	/* set alarm two seconds from now */
445
-	omap_rtc_read_time_raw(rtc, &tm);
446
-	bcd2tm(&tm);
447
-	rtc_tm_to_time(&tm, &now);
448
-	rtc_time_to_tm(now + 2, &tm);
424
+again:
425
+	/* Clear any existing ALARM2 event */
426
+	rtc_writel(rtc, OMAP_RTC_STATUS_REG, OMAP_RTC_STATUS_ALARM2);
449
427
 
450
-	if (tm2bcd(&tm) < 0) {
451
-		dev_err(&rtc->rtc->dev, "power off failed\n");
452
-		rtc->type->lock(rtc);
453
-		return;
454
-	}
428
+	/* set alarm one second from now */
429
+	omap_rtc_read_time_raw(rtc, &tm);
430
+	seconds = tm.tm_sec;
431
+	bcd2tm(&tm);
432
+	now = rtc_tm_to_time64(&tm);
433
+	rtc_time64_to_tm(now + 1, &tm);
434
+
435
+	tm2bcd(&tm);
455
436
 
456
437
 	rtc_wait_not_busy(rtc);
457
438
 
..
..
@@ -470,14 +451,55 @@
470
451
 	val = rtc_read(rtc, OMAP_RTC_INTERRUPTS_REG);
471
452
 	rtc_writel(rtc, OMAP_RTC_INTERRUPTS_REG,
472
453
 			val | OMAP_RTC_INTERRUPTS_IT_ALARM2);
454
+
455
+	/* Retry in case roll over happened before alarm was armed. */
456
+	if (rtc_read(rtc, OMAP_RTC_SECONDS_REG) != seconds) {
457
+		val = rtc_read(rtc, OMAP_RTC_STATUS_REG);
458
+		if (!(val & OMAP_RTC_STATUS_ALARM2))
459
+			goto again;
460
+	}
461
+
473
462
 	rtc->type->lock(rtc);
474
463
 
464
+	return 0;
465
+}
466
+EXPORT_SYMBOL(omap_rtc_power_off_program);
467
+
468
+/*
469
+ * omap_rtc_poweroff: RTC-controlled power off
470
+ *
471
+ * The RTC can be used to control an external PMIC via the pmic_power_en pin,
472
+ * which can be configured to transition to OFF on ALARM2 events.
473
+ *
474
+ * Notes:
475
+ * The one-second alarm offset is the shortest offset possible as the alarm
476
+ * registers must be set before the next timer update and the offset
477
+ * calculation is too heavy for everything to be done within a single access
478
+ * period (~15 us).
479
+ *
480
+ * Called with local interrupts disabled.
481
+ */
482
+static void omap_rtc_power_off(void)
483
+{
484
+	struct rtc_device *rtc = omap_rtc_power_off_rtc->rtc;
485
+	u32 val;
486
+
487
+	omap_rtc_power_off_program(rtc->dev.parent);
488
+
489
+	/* Set PMIC power enable and EXT_WAKEUP in case PB power on is used */
490
+	omap_rtc_power_off_rtc->type->unlock(omap_rtc_power_off_rtc);
491
+	val = rtc_readl(omap_rtc_power_off_rtc, OMAP_RTC_PMIC_REG);
492
+	val |= OMAP_RTC_PMIC_POWER_EN_EN | OMAP_RTC_PMIC_EXT_WKUP_POL(0) |
493
+			OMAP_RTC_PMIC_EXT_WKUP_EN(0);
494
+	rtc_writel(omap_rtc_power_off_rtc, OMAP_RTC_PMIC_REG, val);
495
+	omap_rtc_power_off_rtc->type->lock(omap_rtc_power_off_rtc);
496
+
475
497
 	/*
476
-	 * Wait for alarm to trigger (within two seconds) and external PMIC to
498
+	 * Wait for alarm to trigger (within one second) and external PMIC to
477
499
 	 * power off the system. Add a 500 ms margin for external latencies
478
500
 	 * (e.g. debounce circuits).
479
501
 	 */
480
-	mdelay(2500);
502
+	mdelay(1500);
481
503
 }
482
504
 
483
505
 static const struct rtc_class_ops omap_rtc_ops = {
..
..
@@ -594,7 +616,7 @@
594
616
 		break;
595
617
 	default:
596
618
 		return -ENOTSUPP;
597
-	};
619
+	}
598
620
 
599
621
 	*config = pinconf_to_config_packed(param, arg);
600
622
 
..
..
@@ -705,7 +727,6 @@
705
727
 static int omap_rtc_probe(struct platform_device *pdev)
706
728
 {
707
729
 	struct omap_rtc	*rtc;
708
-	struct resource	*res;
709
730
 	u8 reg, mask, new_ctrl;
710
731
 	const struct platform_device_id *id_entry;
711
732
 	const struct of_device_id *of_id;
..
..
@@ -719,8 +740,7 @@
719
740
 	if (of_id) {
720
741
 		rtc->type = of_id->data;
721
742
 		rtc->is_pmic_controller = rtc->type->has_pmic_mode &&
722
-				of_property_read_bool(pdev->dev.of_node,
723
-						"system-power-controller");
743
+			of_device_is_system_power_controller(pdev->dev.of_node);
724
744
 	} else {
725
745
 		id_entry = platform_get_device_id(pdev);
726
746
 		rtc->type = (void *)id_entry->driver_data;
..
..
@@ -743,8 +763,7 @@
743
763
 	if (!IS_ERR(rtc->clk))
744
764
 		clk_prepare_enable(rtc->clk);
745
765
 
746
-	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
747
-	rtc->base = devm_ioremap_resource(&pdev->dev, res);
766
+	rtc->base = devm_platform_ioremap_resource(pdev, 0);
748
767
 	if (IS_ERR(rtc->base)) {
749
768
 		clk_disable_unprepare(rtc->clk);
750
769
 		return PTR_ERR(rtc->base);
..
..
@@ -841,6 +860,8 @@
841
860
 	}
842
861
 
843
862
 	rtc->rtc->ops = &omap_rtc_ops;
863
+	rtc->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
864
+	rtc->rtc->range_max = RTC_TIMESTAMP_END_2099;
844
865
 	omap_rtc_nvmem_config.priv = rtc;
845
866
 
846
867
 	/* handle periodic and alarm irqs */