History

Merge tag 'rtc-7.2' of git://git.kernel.org/pub/scm/linux/kernel/git/abelloni/linux

Pull RTC updates from Alexandre Belloni: "Most of the work and improvements are for features of the m41t93. The ds1307 also gets support for OSF (Oscillator Stop Flag) for new variants. The pcap driver is being removed as the Motorola EZX support was removed a while ago. Subsystem: - add rtc_read_next_alarm() to read next expiring timer Drivers: - ds1307: handle OSF for ds1337/ds1339/ds3231, add clock provider for ds1307, fix wday for rx8130 - m41t93: DT support, alarm, clock provider, watchdog support - mv: add suspend/resume support for wakeup - pcap: remove driver - renesas-rtca3: many fixes" * tag 'rtc-7.2' of git://git.kernel.org/pub/scm/linux/kernel/git/abelloni/linux: (36 commits) rtc: ds1307: update reference to removed CONFIG_RTC_DRV_DS1307_HWMON platform/x86: amd-pmc: Fix S0i3 wakeup with alarmtimer rtc: s35390a: fix typo in comment rtc: cmos: unregister HPET IRQ handler on probe failure rtc: ds1307: Fix off-by-one issue with wday for rx8130 dt-bindings: rtc: ds1307: Add epson,rx8901 rtc: bq32000: add delay between RTC reads rtc: m41t93: Add watchdog support rtc: m41t93: Add square wave clock provider support rtc: m41t93: Add alarm support rtc: m41t93: migrate to regmap api for register access rtc: m41t93: add device tree support dt-bindings: rtc: Add ST m41t93 rtc: ds1307: add support for clock provider in ds1307 rtc: mv: add suspend/resume support for wakeup rtc: aspeed: add AST2700 compatible dt-bindings: rtc: add ASPEED AST2700 compatible rtc: interface: fix typos in rtc_handle_legacy_irq() documentation rtc: msc313: fix NULL deref in shared IRQ handler at probe rtc: remove unused pcap driver ...

Linus Torvalds committed 4 months ago

Commit da7ca042 parents 6ca693e 3c8f28561 files · +961 −441Browse files

Unified · Split

61 files
  1. Documentation/devicetree/bindings/rtc/epson,rx6110.txt +0 −39
  2. Documentation/devicetree/bindings/rtc/epson,rx6110.yaml +68 −0
  3. Documentation/devicetree/bindings/rtc/rtc-ds1307.yaml +1 −0
  4. Documentation/devicetree/bindings/rtc/st,m41t93.yaml +50 −0
  5. Documentation/devicetree/bindings/rtc/trivial-rtc.yaml +2 −0
  6. drivers/platform/x86/amd/pmc/pmc.c +6 −3
  7. drivers/rtc/Kconfig +0 −7
  8. drivers/rtc/Makefile +0 −1
  9. drivers/rtc/interface.c +42 −2
  10. drivers/rtc/rtc-88pm886.c +1 −1
  11. drivers/rtc/rtc-ab-b5ze-s3.c +1 −1
  12. drivers/rtc/rtc-ab-eoz9.c +1 −1
  13. drivers/rtc/rtc-ab8500.c +3 −5
  14. drivers/rtc/rtc-abx80x.c +12 −11
  15. drivers/rtc/rtc-aspeed.c +1 −0
  16. drivers/rtc/rtc-bd70528.c +4 −4
  17. drivers/rtc/rtc-bq32k.c +10 −1
  18. drivers/rtc/rtc-cmos.c +6 −0
  19. drivers/rtc/rtc-cros-ec.c +2 −2
  20. drivers/rtc/rtc-ds1307.c +174 −33
  21. drivers/rtc/rtc-ds1374.c +1 −1
  22. drivers/rtc/rtc-ds1672.c +1 −1
  23. drivers/rtc/rtc-ds3232.c +1 −1
  24. drivers/rtc/rtc-em3027.c +1 −1
  25. drivers/rtc/rtc-fm3130.c +1 −1
  26. drivers/rtc/rtc-hym8563.c +2 −2
  27. drivers/rtc/rtc-isl12022.c +1 −1
  28. drivers/rtc/rtc-isl12026.c +2 −2
  29. drivers/rtc/rtc-isl1208.c +19 −6
  30. drivers/rtc/rtc-m41t80.c +11 −11
  31. drivers/rtc/rtc-m41t93.c +436 −52
  32. drivers/rtc/rtc-max31335.c +2 −2
  33. drivers/rtc/rtc-max6900.c +1 −1
  34. drivers/rtc/rtc-max77686.c +5 −5
  35. drivers/rtc/rtc-max8997.c +2 −2
  36. drivers/rtc/rtc-max8998.c +2 −2
  37. drivers/rtc/rtc-mpfs.c +1 −1
  38. drivers/rtc/rtc-msc313.c +2 −2
  39. drivers/rtc/rtc-mv.c +23 −0
  40. drivers/rtc/rtc-nct3018y.c +1 −1
  41. drivers/rtc/rtc-pcap.c +0 −179
  42. drivers/rtc/rtc-pcf2127.c +4 −4
  43. drivers/rtc/rtc-pcf85063.c +6 −6
  44. drivers/rtc/rtc-pcf8523.c +1 −1
  45. drivers/rtc/rtc-pcf8563.c +3 −3
  46. drivers/rtc/rtc-pcf8583.c +1 −1
  47. drivers/rtc/rtc-renesas-rtca3.c +15 −11
  48. drivers/rtc/rtc-rs5c372.c +6 −6
  49. drivers/rtc/rtc-rv3029c2.c +2 −2
  50. drivers/rtc/rtc-rv8803.c +4 −4
  51. drivers/rtc/rtc-rx6110.c +1 −1
  52. drivers/rtc/rtc-rx8010.c +1 −1
  53. drivers/rtc/rtc-rx8025.c +2 −2
  54. drivers/rtc/rtc-rx8581.c +1 −1
  55. drivers/rtc/rtc-s35390a.c +2 −2
  56. drivers/rtc/rtc-s5m.c +6 −6
  57. drivers/rtc/rtc-sd2405al.c +1 −1
  58. drivers/rtc/rtc-sd3078.c +1 −1
  59. drivers/rtc/rtc-tps6594.c +2 −2
  60. drivers/rtc/rtc-x1205.c +1 −1
  61. include/linux/rtc.h +2 −0
Documentation/devicetree/bindings/rtc/epson,rx6110.txt+0−39
@@ -1,39 +0,0 @@
1−Epson RX6110 Real Time Clock
2−============================
3−
4−The Epson RX6110 can be used with SPI or I2C busses. The kind of
5−bus depends on the SPISEL pin and can not be configured via software.
6−
7−I2C mode
8−--------
9−
10−Required properties:
11− - compatible: should be: "epson,rx6110"
12− - reg : the I2C address of the device for I2C
13−
14−Example:
15−
16− rtc: rtc@32 {
17− compatible = "epson,rx6110"
18− reg = <0x32>;
19− };
20−
21−SPI mode
22−--------
23−
24−Required properties:
25− - compatible: should be: "epson,rx6110"
26− - reg: chip select number
27− - spi-cs-high: RX6110 needs chipselect high
28− - spi-cpha: RX6110 works with SPI shifted clock phase
29− - spi-cpol: RX6110 works with SPI inverse clock polarity
30−
31−Example:
32−
33− rtc: rtc@3 {
34− compatible = "epson,rx6110"
35− reg = <3>
36− spi-cs-high;
37− spi-cpha;
38− spi-cpol;
39− };
Documentation/devicetree/bindings/rtc/epson,rx6110.yaml+68−0
@@ -0,0 +1,68 @@
1+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2+%YAML 1.2
3+---
4+$id: http://devicetree.org/schemas/rtc/epson,rx6110.yaml#
5+$schema: http://devicetree.org/meta-schemas/core.yaml#
6+
7+title: Epson RX6110 Real Time Clock
8+
9+description:
10+ The Epson RX6110 can be used with SPI or I2C busses. The kind of bus depends
11+ on the SPISEL pin and cannot be configured via software.
12+
13+maintainers:
14+ - Alexandre Belloni <alexandre.belloni@bootlin.com>
15+
16+allOf:
17+ - $ref: rtc.yaml#
18+ - $ref: /schemas/spi/spi-peripheral-props.yaml#
19+
20+properties:
21+ compatible:
22+ const: epson,rx6110
23+
24+ reg:
25+ maxItems: 1
26+
27+ spi-cs-high: true
28+ spi-cpha: true
29+ spi-cpol: true
30+
31+required:
32+ - compatible
33+ - reg
34+
35+dependencies:
36+ spi-cs-high: [ spi-cpha, spi-cpol ]
37+ spi-cpha: [ spi-cs-high, spi-cpol ]
38+ spi-cpol: [ spi-cs-high, spi-cpha ]
39+
40+unevaluatedProperties: false
41+
42+examples:
43+ # I2C mode
44+ - |
45+ i2c {
46+ #address-cells = <1>;
47+ #size-cells = <0>;
48+
49+ rtc@32 {
50+ compatible = "epson,rx6110";
51+ reg = <0x32>;
52+ };
53+ };
54+
55+ # SPI mode
56+ - |
57+ spi {
58+ #address-cells = <1>;
59+ #size-cells = <0>;
60+
61+ rtc@3 {
62+ compatible = "epson,rx6110";
63+ reg = <3>;
64+ spi-cs-high;
65+ spi-cpha;
66+ spi-cpol;
67+ };
68+ };
Documentation/devicetree/bindings/rtc/rtc-ds1307.yaml+1−0
@@ -31,6 +31,7 @@ properties: · 30 unmodified lines
3131 - epson,rx8025
3232 - isil,isl12057
3333 - epson,rx8130
34+ - epson,rx8901
3435
3536 - items:
3637 - enum:
Documentation/devicetree/bindings/rtc/st,m41t93.yaml+50−0
@@ -0,0 +1,50 @@
1+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2+%YAML 1.2
3+---
4+$id: http://devicetree.org/schemas/rtc/st,m41t93.yaml#
5+$schema: http://devicetree.org/meta-schemas/core.yaml#
6+
7+title: ST M41T93 RTC and compatible
8+
9+maintainers:
10+ - Akhilesh Patil <akhilesh@ee.iitb.ac.in>
11+
12+description:
13+ ST M41T93 is spi based Real Time Clock (RTC) with time, date,
14+ alarm, watchdog, square wave clock output, 8 bit timer and
15+ 7 bytes of user SRAM.
16+
17+properties:
18+ compatible:
19+ enum:
20+ - st,m41t93
21+
22+ reg:
23+ maxItems: 1
24+
25+ "#clock-cells":
26+ const: 0
27+
28+required:
29+ - compatible
30+ - reg
31+
32+allOf:
33+ - $ref: rtc.yaml
34+ - $ref: /schemas/spi/spi-peripheral-props.yaml#
35+
36+unevaluatedProperties: false
37+
38+examples:
39+ - |
40+ spi {
41+ #address-cells = <1>;
42+ #size-cells = <0>;
43+ rtc@0 {
44+ compatible = "st,m41t93";
45+ reg = <0>;
46+ #clock-cells = <0>;
47+ spi-max-frequency = <2000000>;
48+ };
49+ };
50+
Documentation/devicetree/bindings/rtc/trivial-rtc.yaml+2−0
@@ -30,6 +30,8 @@ properties: · 29 unmodified lines
3030 - aspeed,ast2500-rtc
3131 # ASPEED BMC ast2600 Real-time Clock
3232 - aspeed,ast2600-rtc
33+ # ASPEED BMC ast2700 Real-time Clock
34+ - aspeed,ast2700-rtc
3335 # Conexant Digicolor Real Time Clock Controller
3436 - cnxt,cx92755-rtc
3537 # I2C, 32-Bit Binary Counter Watchdog RTC with Trickle Charger and Reset Input/Output
drivers/platform/x86/amd/pmc/pmc.c+6−3
@@ -645,9 +645,12 @@ static int amd_pmc_verify_czn_rtc(struct amd_pmc_dev *pdev, u32 *arg) · 644 unmodified lines
645645 rtc_device = rtc_class_open("rtc0");
646646 if (!rtc_device)
647647 return 0;
648− rc = rtc_read_alarm(rtc_device, &alarm);
649− if (rc)
650− return rc;
648+ rc = rtc_read_next_alarm(rtc_device, &alarm);
649+ if (rc) {
650+ if (rc == -ENOENT)
651+ dev_dbg(pdev->dev, "no alarm pending\n");
652+ return rc == -ENOENT ? 0 : rc;
653+ }
651654 if (!alarm.enabled) {
652655 dev_dbg(pdev->dev, "alarm not enabled\n");
653656 return 0;
drivers/rtc/Kconfig+0−7
@@ -1763,13 +1763,6 @@ config RTC_DRV_STMP · 1762 unmodified lines
17631763 This driver can also be built as a module. If so, the module
17641764 will be called rtc-stmp3xxx.
17651765
1766−config RTC_DRV_PCAP
1767− tristate "PCAP RTC"
1768− depends on EZX_PCAP
1769− help
1770− If you say Y here you will get support for the RTC found on
1771− the PCAP2 ASIC used on some Motorola phones.
1772−
17731766 config RTC_DRV_MC13XXX
17741767 depends on MFD_MC13XXX
17751768 tristate "Freescale MC13xxx RTC"
drivers/rtc/Makefile+0−1
@@ -128,7 +128,6 @@ obj-$(CONFIG_RTC_DRV_OMAP) += rtc-omap.o · 127 unmodified lines
128128 obj-$(CONFIG_RTC_DRV_OPAL) += rtc-opal.o
129129 obj-$(CONFIG_RTC_DRV_OPTEE) += rtc-optee.o
130130 obj-$(CONFIG_RTC_DRV_PALMAS) += rtc-palmas.o
131−obj-$(CONFIG_RTC_DRV_PCAP) += rtc-pcap.o
132131 obj-$(CONFIG_RTC_DRV_PCF2123) += rtc-pcf2123.o
133132 obj-$(CONFIG_RTC_DRV_PCF2127) += rtc-pcf2127.o
134133 obj-$(CONFIG_RTC_DRV_PCF85063) += rtc-pcf85063.o
drivers/rtc/interface.c+42−2
@@ -384,6 +384,46 @@ done: · 383 unmodified lines
384384 return err;
385385 }
386386
387+/**
388+ * rtc_read_next_alarm - read the next expiring alarm
389+ * @rtc: RTC device
390+ * @alarm: storage for the alarm information
391+ *
392+ * Read the next expiring alarm from the RTC timerqueue. This returns
393+ * the alarm that will actually fire next, which may be different from
394+ * rtc_read_alarm() if multiple timers are queued (e.g., alarmtimer
395+ * and wakealarm sysfs both active).
396+ *
397+ * Returns: 0 on success, -ENOENT if no alarm is pending, or other error.
398+ */
399+int rtc_read_next_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
400+{
401+ struct timerqueue_node *next;
402+ int err;
403+
404+ if (!rtc || !alarm)
405+ return -EINVAL;
406+
407+ err = mutex_lock_interruptible(&rtc->ops_lock);
408+ if (err)
409+ return err;
410+
411+ next = timerqueue_getnext(&rtc->timerqueue);
412+ if (!next) {
413+ err = -ENOENT;
414+ goto unlock;
415+ }
416+
417+ memset(alarm, 0, sizeof(struct rtc_wkalrm));
418+ alarm->time = rtc_ktime_to_tm(next->expires);
419+ alarm->enabled = 1;
420+
421+unlock:
422+ mutex_unlock(&rtc->ops_lock);
423+ return err;
424+}
425+EXPORT_SYMBOL_GPL(rtc_read_next_alarm);
426+
387427 int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
388428 {
389429 int err;
@@ -635,8 +675,8 @@ EXPORT_SYMBOL_GPL(rtc_update_irq_enable); · 245 unmodified lines
635675 /**
636676 * rtc_handle_legacy_irq - AIE, UIE and PIE event hook
637677 * @rtc: pointer to the rtc device
638− * @num: number of occurence of the event
639− * @mode: type of the event, RTC_AF, RTC_UF of RTC_PF
678+ * @num: number of occurrence of the event
679+ * @mode: type of the event, RTC_AF, RTC_UF or RTC_PF
640680 *
641681 * This function is called when an AIE, UIE or PIE mode interrupt
642682 * has occurred (or been emulated).
drivers/rtc/rtc-88pm886.c+1−1
@@ -78,7 +78,7 @@ static int pm886_rtc_probe(struct platform_device *pdev) · 77 unmodified lines
7878 }
7979
8080 static const struct platform_device_id pm886_rtc_id_table[] = {
81− { "88pm886-rtc", },
81+ { .name = "88pm886-rtc" },
8282 { }
8383 };
8484 MODULE_DEVICE_TABLE(platform, pm886_rtc_id_table);
drivers/rtc/rtc-ab-b5ze-s3.c+1−1
@@ -933,7 +933,7 @@ MODULE_DEVICE_TABLE(of, abb5zes3_dt_match); · 932 unmodified lines
933933 #endif
934934
935935 static const struct i2c_device_id abb5zes3_id[] = {
936− { "abb5zes3" },
936+ { .name = "abb5zes3" },
937937 { }
938938 };
939939 MODULE_DEVICE_TABLE(i2c, abb5zes3_id);
drivers/rtc/rtc-ab-eoz9.c+1−1
@@ -546,7 +546,7 @@ MODULE_DEVICE_TABLE(of, abeoz9_dt_match); · 545 unmodified lines
546546 #endif
547547
548548 static const struct i2c_device_id abeoz9_id[] = {
549− { "abeoz9" },
549+ { .name = "abeoz9" },
550550 { }
551551 };
552552
drivers/rtc/rtc-ab8500.c+3−5
@@ -284,11 +284,10 @@ static ssize_t ab8500_sysfs_show_rtc_calibration(struct device *dev, · 283 unmodified lines
284284 retval = ab8500_rtc_get_calibration(dev, &calibration);
285285 if (retval < 0) {
286286 dev_err(dev, "Failed to read RTC calibration attribute\n");
287− sprintf(buf, "0\n");
288287 return retval;
289288 }
290289
291− return sprintf(buf, "%d\n", calibration);
290+ return sysfs_emit(buf, "%d\n", calibration);
292291 }
293292
294293 static DEVICE_ATTR(rtc_calibration, S_IRUGO | S_IWUSR,
@@ -324,14 +323,13 @@ static const struct rtc_class_ops ab8500_rtc_ops = { · 29 unmodified lines
324323 };
325324
326325 static const struct platform_device_id ab85xx_rtc_ids[] = {
327− { "ab8500-rtc", (kernel_ulong_t)&ab8500_rtc_ops, },
326+ { .name = "ab8500-rtc" },
328327 { /* sentinel */ }
329328 };
330329 MODULE_DEVICE_TABLE(platform, ab85xx_rtc_ids);
331330
332331 static int ab8500_rtc_probe(struct platform_device *pdev)
333332 {
334− const struct platform_device_id *platid = platform_get_device_id(pdev);
335333 int err;
336334 struct rtc_device *rtc;
337335 u8 rtc_ctrl;
@@ -367,7 +365,7 @@ static int ab8500_rtc_probe(struct platform_device *pdev) · 29 unmodified lines
367365 if (IS_ERR(rtc))
368366 return PTR_ERR(rtc);
369367
370− rtc->ops = (struct rtc_class_ops *)platid->driver_data;
368+ rtc->ops = &ab8500_rtc_ops;
371369
372370 err = devm_request_threaded_irq(&pdev->dev, irq, NULL,
373371 rtc_alarm_handler, IRQF_ONESHOT,
drivers/rtc/rtc-abx80x.c+12−11
@@ -545,7 +545,8 @@ static int abx80x_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) · 544 unmodified lines
545545
546546 status &= ~ABX8XX_STATUS_BLF;
547547
548− tmp = i2c_smbus_write_byte_data(client, ABX8XX_REG_STATUS, 0);
548+ tmp = i2c_smbus_write_byte_data(client, ABX8XX_REG_STATUS,
549+ status);
549550 if (tmp < 0)
550551 return tmp;
551552
@@ -752,16 +753,16 @@ static int abx80x_setup_nvmem(struct abx80x_priv *priv) · 200 unmodified lines
752753 }
753754
754755 static const struct i2c_device_id abx80x_id[] = {
755− { "abx80x", ABX80X },
756− { "ab0801", AB0801 },
757− { "ab0803", AB0803 },
758− { "ab0804", AB0804 },
759− { "ab0805", AB0805 },
760− { "ab1801", AB1801 },
761− { "ab1803", AB1803 },
762− { "ab1804", AB1804 },
763− { "ab1805", AB1805 },
764− { "rv1805", RV1805 },
756+ { .name = "abx80x", .driver_data = ABX80X },
757+ { .name = "ab0801", .driver_data = AB0801 },
758+ { .name = "ab0803", .driver_data = AB0803 },
759+ { .name = "ab0804", .driver_data = AB0804 },
760+ { .name = "ab0805", .driver_data = AB0805 },
761+ { .name = "ab1801", .driver_data = AB1801 },
762+ { .name = "ab1803", .driver_data = AB1803 },
763+ { .name = "ab1804", .driver_data = AB1804 },
764+ { .name = "ab1805", .driver_data = AB1805 },
765+ { .name = "rv1805", .driver_data = RV1805 },
765766 { }
766767 };
767768 MODULE_DEVICE_TABLE(i2c, abx80x_id);
drivers/rtc/rtc-aspeed.c+1−0
@@ -111,6 +111,7 @@ static const struct of_device_id aspeed_rtc_match[] = { · 110 unmodified lines
111111 { .compatible = "aspeed,ast2400-rtc", },
112112 { .compatible = "aspeed,ast2500-rtc", },
113113 { .compatible = "aspeed,ast2600-rtc", },
114+ { .compatible = "aspeed,ast2700-rtc", },
114115 {}
115116 };
116117 MODULE_DEVICE_TABLE(of, aspeed_rtc_match);
drivers/rtc/rtc-bd70528.c+4−4
@@ -341,10 +341,10 @@ static int bd70528_probe(struct platform_device *pdev) · 340 unmodified lines
341341 }
342342
343343 static const struct platform_device_id bd718x7_rtc_id[] = {
344− { "bd71828-rtc", ROHM_CHIP_TYPE_BD71828 },
345− { "bd71815-rtc", ROHM_CHIP_TYPE_BD71815 },
346− { "bd72720-rtc", ROHM_CHIP_TYPE_BD72720 },
347− { },
344+ { .name = "bd71828-rtc", .driver_data = ROHM_CHIP_TYPE_BD71828 },
345+ { .name = "bd71815-rtc", .driver_data = ROHM_CHIP_TYPE_BD71815 },
346+ { .name = "bd72720-rtc", .driver_data = ROHM_CHIP_TYPE_BD72720 },
347+ { }
348348 };
349349 MODULE_DEVICE_TABLE(platform, bd718x7_rtc_id);
350350
drivers/rtc/rtc-bq32k.c+10−1
@@ -16,6 +16,7 @@ · 15 unmodified lines
1616 #include <linux/kstrtox.h>
1717 #include <linux/errno.h>
1818 #include <linux/bcd.h>
19+#include <linux/delay.h>
1920
2021 #define BQ32K_SECONDS 0x00 /* Seconds register address */
2122 #define BQ32K_SECONDS_MASK 0x7F /* Mask over seconds value */
@@ -89,9 +90,17 @@ static int bq32k_write(struct device *dev, void *data, uint8_t off, uint8_t len) · 67 unmodified lines
8990
9091 static int bq32k_rtc_read_time(struct device *dev, struct rtc_time *tm)
9192 {
93+ struct i2c_client *client = to_i2c_client(dev);
9294 struct bq32k_regs regs;
9395 int error;
9496
97+ /*
98+ * When the device doesn't have the interrupt connected, prevent
99+ * userpace from polling the RTC registers too frequently.
100+ */
101+ if (client->irq <= 0)
102+ usleep_range(2000, 2500);
103+
95104 error = bq32k_read(dev, &regs, 0, sizeof(regs));
96105 if (error)
97106 return error;
@@ -304,7 +313,7 @@ static void bq32k_remove(struct i2c_client *client) · 206 unmodified lines
304313 }
305314
306315 static const struct i2c_device_id bq32k_id[] = {
307− { "bq32000" },
316+ { .name = "bq32000" },
308317 { }
309318 };
310319 MODULE_DEVICE_TABLE(i2c, bq32k_id);
drivers/rtc/rtc-cmos.c+6−0
@@ -934,6 +934,7 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq) · 933 unmodified lines
934934 unsigned char rtc_control;
935935 unsigned address_space;
936936 u32 flags = 0;
937+ bool hpet_registered = false;
937938 struct nvmem_config nvmem_cfg = {
938939 .name = "cmos_nvram",
939940 .word_size = 1,
@@ -1091,6 +1092,7 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq) · 151 unmodified lines
10911092 " failed in rtc_init().");
10921093 goto cleanup1;
10931094 }
1095+ hpet_registered = true;
10941096 } else
10951097 rtc_cmos_int_handler = cmos_interrupt;
10961098
@@ -1140,6 +1142,10 @@ cleanup2: · 43 unmodified lines
11401142 if (is_valid_irq(rtc_irq))
11411143 free_irq(rtc_irq, cmos_rtc.rtc);
11421144 cleanup1:
1145+ if (hpet_registered) {
1146+ hpet_mask_rtc_irq_bit(RTC_IRQMASK);
1147+ hpet_unregister_irq_handler(cmos_interrupt);
1148+ }
11431149 cmos_rtc.dev = NULL;
11441150 cleanup0:
11451151 if (RTC_IOMAPPED)
drivers/rtc/rtc-cros-ec.c+2−2
@@ -388,8 +388,8 @@ static void cros_ec_rtc_remove(struct platform_device *pdev) · 387 unmodified lines
388388 }
389389
390390 static const struct platform_device_id cros_ec_rtc_id[] = {
391− { DRV_NAME, 0 },
392− {}
391+ { .name = DRV_NAME },
392+ { }
393393 };
394394 MODULE_DEVICE_TABLE(platform, cros_ec_rtc_id);
395395
drivers/rtc/rtc-ds1307.c+174−33
@@ -269,6 +269,16 @@ static int ds1307_get_time(struct device *dev, struct rtc_time *t) · 268 unmodified lines
269269 if (tmp & DS1338_BIT_OSF)
270270 return -EINVAL;
271271 break;
272+ case ds_1337:
273+ case ds_1339:
274+ case ds_1341:
275+ case ds_3231:
276+ ret = regmap_read(ds1307->regmap, DS1337_REG_STATUS, &tmp);
277+ if (ret)
278+ return ret;
279+ if (tmp & DS1337_BIT_OSF)
280+ return -EINVAL;
281+ break;
272282 case ds_1340:
273283 if (tmp & DS1340_BIT_nEOSC)
274284 return -EINVAL;
@@ -279,13 +289,6 @@ static int ds1307_get_time(struct device *dev, struct rtc_time *t) · 4 unmodified lines
279289 if (tmp & DS1340_BIT_OSF)
280290 return -EINVAL;
281291 break;
282− case ds_1341:
283− ret = regmap_read(ds1307->regmap, DS1337_REG_STATUS, &tmp);
284− if (ret)
285− return ret;
286− if (tmp & DS1337_BIT_OSF)
287− return -EINVAL;
288− break;
289292 case ds_1388:
290293 ret = regmap_read(ds1307->regmap, DS1388_REG_FLAG, &tmp);
291294 if (ret)
@@ -308,7 +311,7 @@ static int ds1307_get_time(struct device *dev, struct rtc_time *t) · 16 unmodified lines
308311 t->tm_hour = bcd2bin(tmp);
309312 /* rx8130 is bit position, not BCD */
310313 if (ds1307->type == rx_8130)
311− t->tm_wday = fls(regs[DS1307_REG_WDAY] & 0x7f);
314+ t->tm_wday = fls(regs[DS1307_REG_WDAY] & 0x7f) - 1;
312315 else
313316 t->tm_wday = bcd2bin(regs[DS1307_REG_WDAY] & 0x07) - 1;
314317 t->tm_mday = bcd2bin(regs[DS1307_REG_MDAY] & 0x3f);
@@ -380,14 +383,17 @@ static int ds1307_set_time(struct device *dev, struct rtc_time *t) · 65 unmodified lines
380383 regmap_update_bits(ds1307->regmap, DS1307_REG_CONTROL,
381384 DS1338_BIT_OSF, 0);
382385 break;
383− case ds_1340:
384− regmap_update_bits(ds1307->regmap, DS1340_REG_FLAG,
385− DS1340_BIT_OSF, 0);
386− break;
386+ case ds_1337:
387+ case ds_1339:
387388 case ds_1341:
389+ case ds_3231:
388390 regmap_update_bits(ds1307->regmap, DS1337_REG_STATUS,
389391 DS1337_BIT_OSF, 0);
390392 break;
393+ case ds_1340:
394+ regmap_update_bits(ds1307->regmap, DS1340_REG_FLAG,
395+ DS1340_BIT_OSF, 0);
396+ break;
391397 case ds_1388:
392398 regmap_update_bits(ds1307->regmap, DS1388_REG_FLAG,
393399 DS1388_BIT_OSF, 0);
@@ -1063,24 +1069,24 @@ static const struct chip_desc chips[last_ds_type] = { · 669 unmodified lines
10631069 };
10641070
10651071 static const struct i2c_device_id ds1307_id[] = {
1066− { "ds1307", ds_1307 },
1067− { "ds1308", ds_1308 },
1068− { "ds1337", ds_1337 },
1069− { "ds1338", ds_1338 },
1070− { "ds1339", ds_1339 },
1071− { "ds1388", ds_1388 },
1072− { "ds1340", ds_1340 },
1073− { "ds1341", ds_1341 },
1074− { "ds3231", ds_3231 },
1075− { "m41t0", m41t0 },
1076− { "m41t00", m41t00 },
1077− { "m41t11", m41t11 },
1078− { "mcp7940x", mcp794xx },
1079− { "mcp7941x", mcp794xx },
1080− { "pt7c4338", ds_1307 },
1081− { "rx8025", rx_8025 },
1082− { "isl12057", ds_1337 },
1083− { "rx8130", rx_8130 },
1072+ { .name = "ds1307", .driver_data = ds_1307 },
1073+ { .name = "ds1308", .driver_data = ds_1308 },
1074+ { .name = "ds1337", .driver_data = ds_1337 },
1075+ { .name = "ds1338", .driver_data = ds_1338 },
1076+ { .name = "ds1339", .driver_data = ds_1339 },
1077+ { .name = "ds1388", .driver_data = ds_1388 },
1078+ { .name = "ds1340", .driver_data = ds_1340 },
1079+ { .name = "ds1341", .driver_data = ds_1341 },
1080+ { .name = "ds3231", .driver_data = ds_3231 },
1081+ { .name = "m41t0", .driver_data = m41t0 },
1082+ { .name = "m41t00", .driver_data = m41t00 },
1083+ { .name = "m41t11", .driver_data = m41t11 },
1084+ { .name = "mcp7940x", .driver_data = mcp794xx },
1085+ { .name = "mcp7941x", .driver_data = mcp794xx },
1086+ { .name = "pt7c4338", .driver_data = ds_1307 },
1087+ { .name = "rx8025", .driver_data = rx_8025 },
1088+ { .name = "isl12057", .driver_data = ds_1337 },
1089+ { .name = "rx8130", .driver_data = rx_8130 },
10841090 { }
10851091 };
10861092 MODULE_DEVICE_TABLE(i2c, ds1307_id);
@@ -1409,7 +1415,7 @@ static void ds1307_hwmon_register(struct ds1307 *ds1307) · 322 unmodified lines
14091415 {
14101416 }
14111417
1412−#endif /* CONFIG_RTC_DRV_DS1307_HWMON */
1418+#endif /* IS_REACHABLE(CONFIG_HWMON) */
14131419
14141420 /*----------------------------------------------------------------------*/
14151421
@@ -1658,18 +1664,153 @@ static int ds3231_clks_register(struct ds1307 *ds1307) · 242 unmodified lines
16581664 return 0;
16591665 }
16601666
1667+/* ds1307 RTC clock output support */
1668+static unsigned long ds1307_clk_rates[] = {
1669+ 1,
1670+ 4096,
1671+ 8192,
1672+ 32768,
1673+};
1674+
1675+static unsigned long ds1307_clk_sqw_recalc_rate(struct clk_hw *hw,
1676+ unsigned long parent_rate)
1677+{
1678+ int ret;
1679+ unsigned int rate_id;
1680+ struct ds1307 *ds1307 = clk_sqw_to_ds1307(hw);
1681+
1682+ ret = regmap_read(ds1307->regmap, DS1307_REG_CONTROL, &rate_id);
1683+ if (ret)
1684+ return ret;
1685+
1686+ rate_id &= (DS1307_BIT_RS1 | DS1307_BIT_RS0);
1687+
1688+ return ds1307_clk_rates[rate_id];
1689+}
1690+
1691+static int ds1307_clk_sqw_determine_rate(struct clk_hw *hw,
1692+ struct clk_rate_request *req)
1693+{
1694+ int i;
1695+
1696+ for (i = 0; i < ARRAY_SIZE(ds1307_clk_rates); i++) {
1697+ if (req->rate <= ds1307_clk_rates[i]) {
1698+ req->rate = ds1307_clk_rates[i];
1699+ return 0;
1700+ }
1701+ }
1702+
1703+ /* Default rate 1Hz */
1704+ req->rate = ds1307_clk_rates[0];
1705+
1706+ return 0;
1707+}
1708+
1709+static int ds1307_clk_sqw_set_rate(struct clk_hw *hw, unsigned long rate,
1710+ unsigned long parent_rate)
1711+{
1712+ int id, ret;
1713+ struct ds1307 *ds1307 = clk_sqw_to_ds1307(hw);
1714+
1715+ for (id = 0; id < ARRAY_SIZE(ds1307_clk_rates); id++) {
1716+ if (ds1307_clk_rates[id] == rate)
1717+ break;
1718+ }
1719+
1720+ if (id >= ARRAY_SIZE(ds1307_clk_rates))
1721+ return -EINVAL;
1722+
1723+ ret = regmap_update_bits(ds1307->regmap, DS1307_REG_CONTROL,
1724+ DS1307_BIT_RS0 | DS1307_BIT_RS1, id);
1725+
1726+ return ret;
1727+}
1728+
1729+static int ds1307_clk_sqw_prepare(struct clk_hw *hw)
1730+{
1731+ int ret;
1732+ struct ds1307 *ds1307 = clk_sqw_to_ds1307(hw);
1733+
1734+ ret = regmap_update_bits(ds1307->regmap, DS1307_REG_CONTROL,
1735+ DS1307_BIT_SQWE, DS1307_BIT_SQWE);
1736+
1737+ return ret;
1738+}
1739+
1740+static void ds1307_clk_sqw_unprepare(struct clk_hw *hw)
1741+{
1742+ struct ds1307 *ds1307 = clk_sqw_to_ds1307(hw);
1743+
1744+ regmap_update_bits(ds1307->regmap, DS1307_REG_CONTROL,
1745+ DS1307_BIT_SQWE, ~DS1307_BIT_SQWE);
1746+}
1747+
1748+static int ds1307_clk_sqw_is_prepared(struct clk_hw *hw)
1749+{
1750+ int ret;
1751+ struct ds1307 *ds1307 = clk_sqw_to_ds1307(hw);
1752+ unsigned int status;
1753+
1754+ ret = regmap_read(ds1307->regmap, DS1307_REG_CONTROL, &status);
1755+ if (ret)
1756+ return ret;
1757+
1758+ return !!(status & DS1307_BIT_SQWE);
1759+}
1760+
1761+static const struct clk_ops ds1307_clk_sqw_ops = {
1762+ .prepare = ds1307_clk_sqw_prepare,
1763+ .unprepare = ds1307_clk_sqw_unprepare,
1764+ .is_prepared = ds1307_clk_sqw_is_prepared,
1765+ .recalc_rate = ds1307_clk_sqw_recalc_rate,
1766+ .set_rate = ds1307_clk_sqw_set_rate,
1767+ .determine_rate = ds1307_clk_sqw_determine_rate,
1768+};
1769+
1770+static int rtc_ds1307_clks_register(struct ds1307 *ds1307)
1771+{
1772+ struct device_node *node = ds1307->dev->of_node;
1773+ struct clk *clk;
1774+ struct clk_init_data init = {0};
1775+
1776+ init.name = "ds1307_clk_sqw";
1777+ init.ops = &ds1307_clk_sqw_ops;
1778+
1779+ ds1307->clks[0].init = &init;
1780+
1781+ /* Register the clock with CCF */
1782+ clk = devm_clk_register(ds1307->dev, &ds1307->clks[0]);
1783+ if (IS_ERR(clk))
1784+ return PTR_ERR(clk);
1785+
1786+ if (node)
1787+ of_clk_add_provider(node, of_clk_src_simple_get, clk);
1788+
1789+ return 0;
1790+}
1791+
16611792 static void ds1307_clks_register(struct ds1307 *ds1307)
16621793 {
16631794 int ret;
16641795
1665− if (ds1307->type != ds_3231)
1796+ switch (ds1307->type) {
1797+ case ds_3231:
1798+ ret = ds3231_clks_register(ds1307);
1799+ break;
1800+
1801+ case ds_1307:
1802+ ret = rtc_ds1307_clks_register(ds1307);
1803+ break;
1804+
1805+ default:
16661806 return;
1807+ }
16671808
1668− ret = ds3231_clks_register(ds1307);
16691809 if (ret) {
16701810 dev_warn(ds1307->dev, "unable to register clock device %d\n",
16711811 ret);
16721812 }
1813+
16731814 }
16741815
16751816 #else
drivers/rtc/rtc-ds1374.c+1−1
@@ -52,7 +52,7 @@ · 51 unmodified lines
5252 #define DS1374_REG_TCR 0x09 /* Trickle Charge */
5353
5454 static const struct i2c_device_id ds1374_id[] = {
55− { "ds1374" },
55+ { .name = "ds1374" },
5656 { }
5757 };
5858 MODULE_DEVICE_TABLE(i2c, ds1374_id);
drivers/rtc/rtc-ds1672.c+1−1
@@ -133,7 +133,7 @@ static int ds1672_probe(struct i2c_client *client) · 132 unmodified lines
133133 }
134134
135135 static const struct i2c_device_id ds1672_id[] = {
136− { "ds1672" },
136+ { .name = "ds1672" },
137137 { }
138138 };
139139 MODULE_DEVICE_TABLE(i2c, ds1672_id);
drivers/rtc/rtc-ds3232.c+1−1
@@ -566,7 +566,7 @@ static int ds3232_i2c_probe(struct i2c_client *client) · 565 unmodified lines
566566 }
567567
568568 static const struct i2c_device_id ds3232_id[] = {
569− { "ds3232" },
569+ { .name = "ds3232" },
570570 { }
571571 };
572572 MODULE_DEVICE_TABLE(i2c, ds3232_id);
drivers/rtc/rtc-em3027.c+1−1
@@ -129,7 +129,7 @@ static int em3027_probe(struct i2c_client *client) · 128 unmodified lines
129129 }
130130
131131 static const struct i2c_device_id em3027_id[] = {
132− { "em3027" },
132+ { .name = "em3027" },
133133 { }
134134 };
135135 MODULE_DEVICE_TABLE(i2c, em3027_id);
drivers/rtc/rtc-fm3130.c+1−1
@@ -53,7 +53,7 @@ struct fm3130 { · 52 unmodified lines
5353 int data_valid;
5454 };
5555 static const struct i2c_device_id fm3130_id[] = {
56− { "fm3130" },
56+ { .name = "fm3130" },
5757 { }
5858 };
5959 MODULE_DEVICE_TABLE(i2c, fm3130_id);
drivers/rtc/rtc-hym8563.c+2−2
@@ -564,8 +564,8 @@ static int hym8563_probe(struct i2c_client *client) · 563 unmodified lines
564564 }
565565
566566 static const struct i2c_device_id hym8563_id[] = {
567− { "hym8563" },
568− {}
567+ { .name = "hym8563" },
568+ { }
569569 };
570570 MODULE_DEVICE_TABLE(i2c, hym8563_id);
571571
drivers/rtc/rtc-isl12022.c+1−1
@@ -604,7 +604,7 @@ static const struct of_device_id isl12022_dt_match[] = { · 603 unmodified lines
604604 MODULE_DEVICE_TABLE(of, isl12022_dt_match);
605605
606606 static const struct i2c_device_id isl12022_id[] = {
607− { "isl12022" },
607+ { .name = "isl12022" },
608608 { }
609609 };
610610 MODULE_DEVICE_TABLE(i2c, isl12022_id);
drivers/rtc/rtc-isl12026.c+2−2
@@ -485,8 +485,8 @@ static const struct of_device_id isl12026_dt_match[] = { · 484 unmodified lines
485485 MODULE_DEVICE_TABLE(of, isl12026_dt_match);
486486
487487 static const struct i2c_device_id isl12026_id[] = {
488− { "isl12026" },
489− { },
488+ { .name = "isl12026" },
489+ { }
490490 };
491491 MODULE_DEVICE_TABLE(i2c, isl12026_id);
492492
drivers/rtc/rtc-isl1208.c+19−6
@@ -110,11 +110,11 @@ static const struct isl1208_config config_raa215300_a0 = { · 109 unmodified lines
110110 };
111111
112112 static const struct i2c_device_id isl1208_id[] = {
113− { "isl1208", .driver_data = (kernel_ulong_t)&config_isl1208 },
114− { "isl1209", .driver_data = (kernel_ulong_t)&config_isl1209 },
115− { "isl1218", .driver_data = (kernel_ulong_t)&config_isl1218 },
116− { "isl1219", .driver_data = (kernel_ulong_t)&config_isl1219 },
117− { "raa215300_a0", .driver_data = (kernel_ulong_t)&config_raa215300_a0 },
113+ { .name = "isl1208", .driver_data = (kernel_ulong_t)&config_isl1208 },
114+ { .name = "isl1209", .driver_data = (kernel_ulong_t)&config_isl1209 },
115+ { .name = "isl1218", .driver_data = (kernel_ulong_t)&config_isl1218 },
116+ { .name = "isl1219", .driver_data = (kernel_ulong_t)&config_isl1219 },
117+ { .name = "raa215300_a0", .driver_data = (kernel_ulong_t)&config_raa215300_a0 },
118118 { }
119119 };
120120 MODULE_DEVICE_TABLE(i2c, isl1208_id);
@@ -822,6 +822,11 @@ static const struct nvmem_config isl1208_nvmem_config = { · 701 unmodified lines
822822 .reg_write = isl1208_nvmem_write,
823823 };
824824
825+static void isl1208_disable_irq_wake_action(void *data)
826+{
827+ disable_irq_wake((unsigned long)data);
828+}
829+
825830 static int isl1208_setup_irq(struct i2c_client *client, int irq)
826831 {
827832 int rc = devm_request_threaded_irq(&client->dev, irq, NULL,
@@ -831,7 +836,15 @@ static int isl1208_setup_irq(struct i2c_client *client, int irq) · 3 unmodified lines
831836 client);
832837 if (!rc) {
833838 device_init_wakeup(&client->dev, true);
834− enable_irq_wake(irq);
839+ rc = enable_irq_wake(irq);
840+ if (rc)
841+ return rc;
842+
843+ rc = devm_add_action_or_reset(&client->dev,
844+ isl1208_disable_irq_wake_action,
845+ (void *)(unsigned long)irq);
846+ if (rc)
847+ return rc;
835848 } else {
836849 dev_err(&client->dev,
837850 "Unable to request irq %d, no alarm support\n",
drivers/rtc/rtc-m41t80.c+11−11
@@ -71,17 +71,17 @@ · 70 unmodified lines
7171 #define M41T80_FEATURE_SQ_ALT BIT(4) /* RSx bits are in reg 4 */
7272
7373 static const struct i2c_device_id m41t80_id[] = {
74− { "m41t62", M41T80_FEATURE_SQ | M41T80_FEATURE_SQ_ALT },
75− { "m41t65", M41T80_FEATURE_WD },
76− { "m41t80", M41T80_FEATURE_SQ },
77− { "m41t81", M41T80_FEATURE_HT | M41T80_FEATURE_SQ},
78− { "m41t81s", M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
79− { "m41t82", M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
80− { "m41t83", M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
81− { "m41st84", M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
82− { "m41st85", M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
83− { "m41st87", M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
84− { "rv4162", M41T80_FEATURE_SQ | M41T80_FEATURE_WD | M41T80_FEATURE_SQ_ALT },
74+ { .name = "m41t62", .driver_data = M41T80_FEATURE_SQ | M41T80_FEATURE_SQ_ALT },
75+ { .name = "m41t65", .driver_data = M41T80_FEATURE_WD },
76+ { .name = "m41t80", .driver_data = M41T80_FEATURE_SQ },
77+ { .name = "m41t81", .driver_data = M41T80_FEATURE_HT | M41T80_FEATURE_SQ},
78+ { .name = "m41t81s", .driver_data = M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
79+ { .name = "m41t82", .driver_data = M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
80+ { .name = "m41t83", .driver_data = M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
81+ { .name = "m41st84", .driver_data = M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
82+ { .name = "m41st85", .driver_data = M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
83+ { .name = "m41st87", .driver_data = M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
84+ { .name = "rv4162", .driver_data = M41T80_FEATURE_SQ | M41T80_FEATURE_WD | M41T80_FEATURE_SQ_ALT },
8585 { }
8686 };
8787 MODULE_DEVICE_TABLE(i2c, m41t80_id);
drivers/rtc/rtc-m41t93.c+436−52
@@ -12,6 +12,9 @@ · 11 unmodified lines
1212 #include <linux/platform_device.h>
1313 #include <linux/rtc.h>
1414 #include <linux/spi/spi.h>
15+#include <linux/regmap.h>
16+#include <linux/clk-provider.h>
17+#include <linux/watchdog.h>
1518
1619 #define M41T93_REG_SSEC 0
1720 #define M41T93_REG_ST_SEC 1
@@ -21,7 +24,23 @@ · 3 unmodified lines
2124 #define M41T93_REG_DAY 5
2225 #define M41T93_REG_MON 6
2326 #define M41T93_REG_YEAR 7
24−
27+#define M41T93_REG_AL1_MONTH 0xa
28+#define M41T93_REG_AL1_DATE 0xb
29+#define M41T93_REG_AL1_HOUR 0xc
30+#define M41T93_REG_AL1_MIN 0xd
31+#define M41T93_REG_AL1_SEC 0xe
32+#define M41T93_BIT_A1IE BIT(7)
33+#define M41T93_BIT_ABE BIT(5)
34+#define M41T93_FLAG_AF1 BIT(6)
35+#define M41T93_SRAM_BASE 0x19
36+#define M41T93_REG_SQW 0x13
37+#define M41T93_SQW_RS_MASK 0xf0
38+#define M41T93_SQW_RS_SHIFT 4
39+#define M41T93_BIT_SQWE BIT(6)
40+#define M41T93_REG_WATCHDOG 0x9
41+#define M41T93_WDT_RB_MASK 0x3
42+#define M41T93_WDT_BMB_MASK 0x7c
43+#define M41T93_WDT_BMB_SHIFT 2
2544
2645 #define M41T93_REG_ALM_HOUR_HT 0xc
2746 #define M41T93_REG_FLAGS 0xf
@@ -31,23 +50,23 @@ · 3 unmodified lines
3150 #define M41T93_FLAG_BL (1 << 4)
3251 #define M41T93_FLAG_HT (1 << 6)
3352
34−static inline int m41t93_set_reg(struct spi_device *spi, u8 addr, u8 data)
35−{
36− u8 buf[2];
37−
38− /* MSB must be '1' to write */
39− buf[0] = addr | 0x80;
40− buf[1] = data;
41−
42− return spi_write(spi, buf, sizeof(buf));
43−}
53+struct m41t93_data {
54+ struct rtc_device *rtc;
55+ struct regmap *regmap;
56+#ifdef CONFIG_COMMON_CLK
57+ struct clk_hw clks;
58+#endif
59+#ifdef CONFIG_WATCHDOG
60+ struct watchdog_device wdd;
61+#endif
62+};
4463
4564 static int m41t93_set_time(struct device *dev, struct rtc_time *tm)
4665 {
47− struct spi_device *spi = to_spi_device(dev);
48− int tmp;
49− u8 buf[9] = {0x80}; /* write cmd + 8 data bytes */
50− u8 * const data = &buf[1]; /* ptr to first data byte */
66+ struct m41t93_data *m41t93 = dev_get_drvdata(dev);
67+ int tmp, ret;
68+ u8 buf[8] = {0}; /* 8 data bytes */
69+ u8 * const data = &buf[0]; /* ptr to first data byte */
5170
5271 dev_dbg(dev, "%s secs=%d, mins=%d, "
5372 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
@@ -56,31 +75,31 @@ static int m41t93_set_time(struct device *dev, struct rtc_time *tm) · 2 unmodified lines
5675 tm->tm_mon, tm->tm_year, tm->tm_wday);
5776
5877 if (tm->tm_year < 100) {
59− dev_warn(&spi->dev, "unsupported date (before 2000-01-01).\n");
78+ dev_warn(dev, "unsupported date (before 2000-01-01).\n");
6079 return -EINVAL;
6180 }
6281
63− tmp = spi_w8r8(spi, M41T93_REG_FLAGS);
64− if (tmp < 0)
65− return tmp;
82+ ret = regmap_read(m41t93->regmap, M41T93_REG_FLAGS, &tmp);
83+ if (ret < 0)
84+ return ret;
6685
6786 if (tmp & M41T93_FLAG_OF) {
68− dev_warn(&spi->dev, "OF bit is set, resetting.\n");
69− m41t93_set_reg(spi, M41T93_REG_FLAGS, tmp & ~M41T93_FLAG_OF);
87+ dev_warn(dev, "OF bit is set, resetting.\n");
88+ regmap_write(m41t93->regmap, M41T93_REG_FLAGS, tmp & ~M41T93_FLAG_OF);
7089
71− tmp = spi_w8r8(spi, M41T93_REG_FLAGS);
72− if (tmp < 0) {
73− return tmp;
90+ ret = regmap_read(m41t93->regmap, M41T93_REG_FLAGS, &tmp);
91+ if (ret < 0) {
92+ return ret;
7493 } else if (tmp & M41T93_FLAG_OF) {
7594 /* OF cannot be immediately reset: oscillator has to be
7695 * restarted. */
7796 u8 reset_osc = buf[M41T93_REG_ST_SEC] | M41T93_FLAG_ST;
7897
79− dev_warn(&spi->dev,
98+ dev_warn(dev,
8099 "OF bit is still set, kickstarting clock.\n");
81− m41t93_set_reg(spi, M41T93_REG_ST_SEC, reset_osc);
100+ regmap_write(m41t93->regmap, M41T93_REG_ST_SEC, reset_osc);
82101 reset_osc &= ~M41T93_FLAG_ST;
83− m41t93_set_reg(spi, M41T93_REG_ST_SEC, reset_osc);
102+ regmap_write(m41t93->regmap, M41T93_REG_ST_SEC, reset_osc);
84103 }
85104 }
86105
@@ -94,14 +113,13 @@ static int m41t93_set_time(struct device *dev, struct rtc_time *tm) · 7 unmodified lines
94113 data[M41T93_REG_MON] = bin2bcd(tm->tm_mon + 1);
95114 data[M41T93_REG_YEAR] = bin2bcd(tm->tm_year % 100);
96115
97− return spi_write(spi, buf, sizeof(buf));
116+ return regmap_bulk_write(m41t93->regmap, M41T93_REG_SSEC, buf, sizeof(buf));
98117 }
99118
100119
101120 static int m41t93_get_time(struct device *dev, struct rtc_time *tm)
102121 {
103− struct spi_device *spi = to_spi_device(dev);
104− const u8 start_addr = 0;
122+ struct m41t93_data *m41t93 = dev_get_drvdata(dev);
105123 u8 buf[8];
106124 int century_after_1900;
107125 int tmp;
@@ -113,32 +131,32 @@ static int m41t93_get_time(struct device *dev, struct rtc_time *tm) · 5 unmodified lines
113131 case after poweron. Time is valid after resetting HT bit.
114132 2. oscillator fail bit (OF) is set: time is invalid.
115133 */
116− tmp = spi_w8r8(spi, M41T93_REG_ALM_HOUR_HT);
117− if (tmp < 0)
118− return tmp;
134+ ret = regmap_read(m41t93->regmap, M41T93_REG_ALM_HOUR_HT, &tmp);
135+ if (ret < 0)
136+ return ret;
119137
120138 if (tmp & M41T93_FLAG_HT) {
121− dev_dbg(&spi->dev, "HT bit is set, reenable clock update.\n");
122− m41t93_set_reg(spi, M41T93_REG_ALM_HOUR_HT,
123− tmp & ~M41T93_FLAG_HT);
139+ dev_dbg(dev, "HT bit is set, reenable clock update.\n");
140+ regmap_write(m41t93->regmap, M41T93_REG_ALM_HOUR_HT,
141+ tmp & ~M41T93_FLAG_HT);
124142 }
125143
126− tmp = spi_w8r8(spi, M41T93_REG_FLAGS);
127− if (tmp < 0)
128− return tmp;
144+ ret = regmap_read(m41t93->regmap, M41T93_REG_FLAGS, &tmp);
145+ if (ret < 0)
146+ return ret;
129147
130148 if (tmp & M41T93_FLAG_OF) {
131149 ret = -EINVAL;
132− dev_warn(&spi->dev, "OF bit is set, write time to restart.\n");
150+ dev_warn(dev, "OF bit is set, write time to restart.\n");
133151 }
134152
135153 if (tmp & M41T93_FLAG_BL)
136− dev_warn(&spi->dev, "BL bit is set, replace battery.\n");
154+ dev_warn(dev, "BL bit is set, replace battery.\n");
137155
138156 /* read actual time/date */
139− tmp = spi_write_then_read(spi, &start_addr, 1, buf, sizeof(buf));
140− if (tmp < 0)
141− return tmp;
157+ ret = regmap_bulk_read(m41t93->regmap, M41T93_REG_SSEC, buf, sizeof(buf));
158+ if (ret < 0)
159+ return ret;
142160
143161 tm->tm_sec = bcd2bin(buf[M41T93_REG_ST_SEC]);
144162 tm->tm_min = bcd2bin(buf[M41T93_REG_MIN]);
@@ -159,41 +177,407 @@ static int m41t93_get_time(struct device *dev, struct rtc_time *tm) · 14 unmodified lines
159177 return ret;
160178 }
161179
180+static int m41t93_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
181+{
182+ struct m41t93_data *m41t93 = dev_get_drvdata(dev);
183+ int ret;
184+ unsigned int val;
185+ u8 alarm_vals[5] = {0};
186+
187+ ret = regmap_bulk_write(m41t93->regmap, M41T93_REG_AL1_DATE, alarm_vals, 4);
188+ if (ret)
189+ return ret;
190+
191+ /* Set alarm values */
192+ alarm_vals[0] = bin2bcd(alrm->time.tm_mon + 1) & 0x1f;
193+ alarm_vals[1] = bin2bcd(alrm->time.tm_mday) & 0x3f;
194+ alarm_vals[2] = bin2bcd(alrm->time.tm_hour) & 0x3f;
195+ alarm_vals[3] = bin2bcd(alrm->time.tm_min) & 0x7f;
196+ alarm_vals[4] = bin2bcd(alrm->time.tm_sec) & 0x7f;
197+
198+ if (alrm->enabled) {
199+ /* Enable alarm IRQ generation */
200+ alarm_vals[0] |= M41T93_BIT_A1IE | M41T93_BIT_ABE;
201+ }
202+
203+ /* Preserve SQWE bit */
204+ ret = regmap_read(m41t93->regmap, M41T93_REG_AL1_MONTH, &val);
205+ if (ret)
206+ return ret;
207+
208+ alarm_vals[0] |= val & 0x40;
209+
210+ ret = regmap_bulk_write(m41t93->regmap, M41T93_REG_AL1_MONTH,
211+ alarm_vals, sizeof(alarm_vals));
212+ if (ret)
213+ return ret;
214+
215+ /* Device address pointer is now at FLAG register, move it to other location
216+ * to finish setting alarm, as recommended by the datasheet.
217+ * We do read of AL1_MONTH register to achieve this.
218+ */
219+ ret = regmap_read(m41t93->regmap, M41T93_REG_AL1_MONTH, &val);
220+ if (ret)
221+ return ret;
222+
223+ if (bcd2bin(val & 0x1f) == (alrm->time.tm_mon & 0x1f))
224+ dev_notice(dev, "Alarm set successfully\n");
225+
226+ return 0;
227+}
228+
229+static int m41t93_get_alarm(struct device *dev, struct rtc_wkalrm *alrm)
230+{
231+ struct m41t93_data *m41t93 = dev_get_drvdata(dev);
232+ int ret;
233+ unsigned int val;
234+ u8 alarm_vals[5] = {0};
235+
236+ ret = regmap_bulk_read(m41t93->regmap, M41T93_REG_AL1_MONTH,
237+ alarm_vals, sizeof(alarm_vals));
238+ if (ret)
239+ return ret;
240+
241+ alrm->time.tm_mon = bcd2bin(alarm_vals[0] & 0x1f) - 1;
242+ alrm->time.tm_mday = bcd2bin(alarm_vals[1] & 0x3f);
243+ alrm->time.tm_hour = bcd2bin(alarm_vals[2] & 0x3f);
244+ alrm->time.tm_min = bcd2bin(alarm_vals[3] & 0x7f);
245+ alrm->time.tm_sec = bcd2bin(alarm_vals[4] & 0x7f);
246+
247+ alrm->enabled = !!(alarm_vals[0] & M41T93_BIT_A1IE);
248+
249+ ret = regmap_read(m41t93->regmap, M41T93_REG_FLAGS, &val);
250+ if (ret)
251+ return ret;
252+
253+ alrm->pending = (val & M41T93_FLAG_AF1) && alrm->enabled;
254+
255+ return 0;
256+}
257+
258+static int m41t93_alarm_irq_enable(struct device *dev, unsigned int enabled)
259+{
260+ struct m41t93_data *m41t93 = dev_get_drvdata(dev);
261+ unsigned int val;
262+ int ret;
263+
264+ val = enabled ? M41T93_BIT_A1IE | M41T93_BIT_ABE : 0;
265+
266+ ret = regmap_update_bits(m41t93->regmap, M41T93_REG_AL1_MONTH,
267+ M41T93_BIT_A1IE | M41T93_BIT_ABE, val);
268+ if (ret)
269+ return ret;
270+
271+ return 0;
272+}
273+
162274
163275 static const struct rtc_class_ops m41t93_rtc_ops = {
164276 .read_time = m41t93_get_time,
165277 .set_time = m41t93_set_time,
278+ .set_alarm = m41t93_set_alarm,
279+ .read_alarm = m41t93_get_alarm,
280+ .alarm_irq_enable = m41t93_alarm_irq_enable,
281+};
282+
283+#ifdef CONFIG_COMMON_CLK
284+#define clk_sqw_to_m41t93_data(clk) \
285+ container_of(clk, struct m41t93_data, clks)
286+
287+/* m41t93 RTC clock output support */
288+static unsigned long m41t93_clk_rates[] = {
289+ 0,
290+ 32768, /* RS3:RS0 = 0b0001 */
291+ 8192,
292+ 4096,
293+ 2048,
294+ 1024,
295+ 512,
296+ 256,
297+ 128,
298+ 64,
299+ 32,
300+ 16,
301+ 8,
302+ 4,
303+ 2,
304+ 1, /* RS3:RS0 = 0b1111 */
305+};
306+
307+static unsigned long m41t93_clk_sqw_recalc_rate(struct clk_hw *hw,
308+ unsigned long parent_rate)
309+{
310+ int ret;
311+ unsigned int rate_id;
312+ struct m41t93_data *m41t93 = clk_sqw_to_m41t93_data(hw);
313+
314+ ret = regmap_read(m41t93->regmap, M41T93_REG_SQW, &rate_id);
315+ if (ret)
316+ return ret;
317+
318+ rate_id &= M41T93_SQW_RS_MASK;
319+ rate_id >>= M41T93_SQW_RS_SHIFT;
320+
321+ return m41t93_clk_rates[rate_id];
322+}
323+
324+static int m41t93_clk_sqw_determine_rate(struct clk_hw *hw,
325+ struct clk_rate_request *req)
326+{
327+ int i;
328+
329+ for (i = 1; i < ARRAY_SIZE(m41t93_clk_rates); i++) {
330+ if (req->rate >= m41t93_clk_rates[i]) {
331+ req->rate = m41t93_clk_rates[i];
332+ return 0;
333+ }
334+ }
335+
336+ return 0;
337+}
338+
339+static int m41t93_clk_sqw_set_rate(struct clk_hw *hw, unsigned long rate,
340+ unsigned long parent_rate)
341+{
342+ int id, ret;
343+ struct m41t93_data *m41t93 = clk_sqw_to_m41t93_data(hw);
344+
345+ for (id = 0; id < ARRAY_SIZE(m41t93_clk_rates); id++) {
346+ if (m41t93_clk_rates[id] == rate)
347+ break;
348+ }
349+
350+ if (id >= ARRAY_SIZE(m41t93_clk_rates))
351+ return -EINVAL;
352+
353+ ret = regmap_update_bits(m41t93->regmap, M41T93_REG_SQW,
354+ M41T93_SQW_RS_MASK, id << M41T93_SQW_RS_SHIFT);
355+
356+ return ret;
357+}
358+
359+static int m41t93_clk_sqw_prepare(struct clk_hw *hw)
360+{
361+ int ret;
362+ struct m41t93_data *m41t93 = clk_sqw_to_m41t93_data(hw);
363+
364+ ret = regmap_update_bits(m41t93->regmap, M41T93_REG_AL1_MONTH,
365+ M41T93_BIT_SQWE, M41T93_BIT_SQWE);
366+
367+ return ret;
368+}
369+
370+static void m41t93_clk_sqw_unprepare(struct clk_hw *hw)
371+{
372+ struct m41t93_data *m41t93 = clk_sqw_to_m41t93_data(hw);
373+
374+ regmap_update_bits(m41t93->regmap, M41T93_REG_AL1_MONTH,
375+ M41T93_BIT_SQWE, 0);
376+}
377+
378+static int m41t93_clk_sqw_is_prepared(struct clk_hw *hw)
379+{
380+ int ret;
381+ struct m41t93_data *m41t93 = clk_sqw_to_m41t93_data(hw);
382+ unsigned int status;
383+
384+ ret = regmap_read(m41t93->regmap, M41T93_REG_AL1_MONTH, &status);
385+ if (ret)
386+ return ret;
387+
388+ return !!(status & M41T93_BIT_SQWE);
389+}
390+
391+static const struct clk_ops m41t93_clk_sqw_ops = {
392+ .prepare = m41t93_clk_sqw_prepare,
393+ .unprepare = m41t93_clk_sqw_unprepare,
394+ .is_prepared = m41t93_clk_sqw_is_prepared,
395+ .recalc_rate = m41t93_clk_sqw_recalc_rate,
396+ .set_rate = m41t93_clk_sqw_set_rate,
397+ .determine_rate = m41t93_clk_sqw_determine_rate,
398+};
399+
400+static int rtc_m41t93_clks_register(struct device *dev, struct m41t93_data *m41t93)
401+{
402+ struct device_node *node = dev->of_node;
403+ struct clk *clk;
404+ struct clk_init_data init = {0};
405+
406+ init.name = "m41t93_clk_sqw";
407+ init.ops = &m41t93_clk_sqw_ops;
408+
409+ m41t93->clks.init = &init;
410+
411+ /* Register the clock with CCF */
412+ clk = devm_clk_register(dev, &m41t93->clks);
413+ if (IS_ERR(clk))
414+ return PTR_ERR(clk);
415+
416+ if (node)
417+ of_clk_add_provider(node, of_clk_src_simple_get, clk);
418+
419+ return 0;
420+}
421+#endif
422+
423+#ifdef CONFIG_WATCHDOG
424+static int m41t93_wdt_ping(struct watchdog_device *wdd)
425+{
426+ u8 resolution, mult;
427+ u8 val = 0;
428+ int ret;
429+ struct m41t93_data *m41t93 = watchdog_get_drvdata(wdd);
430+
431+ /* Resolution supported by hardware
432+ * 0b00 : 1/16 seconds
433+ * 0b01 : 1/4 second
434+ * 0b10 : 1 second
435+ * 0b11 : 4 seconds
436+ */
437+ resolution = 0x2; /* hardcode resolution to 1s */
438+ mult = wdd->timeout;
439+ val = resolution | (mult << M41T93_WDT_BMB_SHIFT & M41T93_WDT_BMB_MASK);
440+
441+ ret = regmap_write_bits(m41t93->regmap, M41T93_REG_WATCHDOG,
442+ M41T93_WDT_RB_MASK | M41T93_WDT_BMB_MASK, val);
443+
444+ return ret;
445+}
446+
447+static int m41t93_wdt_start(struct watchdog_device *wdd)
448+{
449+ return m41t93_wdt_ping(wdd);
450+}
451+
452+static int m41t93_wdt_stop(struct watchdog_device *wdd)
453+{
454+ struct m41t93_data *m41t93 = watchdog_get_drvdata(wdd);
455+
456+ /* Write 0 to watchdog register */
457+ return regmap_write_bits(m41t93->regmap, M41T93_REG_WATCHDOG,
458+ M41T93_WDT_RB_MASK | M41T93_WDT_BMB_MASK, 0);
459+}
460+
461+static int m41t93_wdt_set_timeout(struct watchdog_device *wdd,
462+ unsigned int new_timeout)
463+{
464+ wdd->timeout = new_timeout;
465+
466+ return 0;
467+}
468+
469+static const struct watchdog_info m41t93_wdt_info = {
470+ .identity = "m41t93 rtc Watchdog",
471+ .options = WDIOF_ALARMONLY | WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
472+};
473+
474+static const struct watchdog_ops m41t93_watchdog_ops = {
475+ .owner = THIS_MODULE,
476+ .start = m41t93_wdt_start,
477+ .stop = m41t93_wdt_stop,
478+ .ping = m41t93_wdt_ping,
479+ .set_timeout = m41t93_wdt_set_timeout,
166480 };
167481
482+static int m41t93_watchdog_register(struct device *dev, struct m41t93_data *m41t93)
483+{
484+ int ret;
485+
486+ m41t93->wdd.parent = dev;
487+ m41t93->wdd.info = &m41t93_wdt_info;
488+ m41t93->wdd.ops = &m41t93_watchdog_ops;
489+ m41t93->wdd.min_timeout = 0;
490+ m41t93->wdd.max_timeout = 10;
491+ m41t93->wdd.timeout = 3; /* Default timeout is 3 sec */
492+ m41t93->wdd.status = WATCHDOG_NOWAYOUT_INIT_STATUS;
493+
494+ watchdog_set_drvdata(&m41t93->wdd, m41t93);
495+
496+ ret = devm_watchdog_register_device(dev, &m41t93->wdd);
497+ if (ret) {
498+ dev_warn(dev, "Failed to register watchdog\n");
499+ return ret;
500+ }
501+
502+ /* Disable watchdog at start */
503+ ret = m41t93_wdt_stop(&m41t93->wdd);
504+
505+ return ret;
506+}
507+#endif
508+
168509 static struct spi_driver m41t93_driver;
169510
511+static const struct regmap_config regmap_config = {
512+ .reg_bits = 8,
513+ .val_bits = 8,
514+ .read_flag_mask = 0x00,
515+ .write_flag_mask = 0x80,
516+ .zero_flag_mask = true,
517+};
518+
170519 static int m41t93_probe(struct spi_device *spi)
171520 {
172− struct rtc_device *rtc;
173− int res;
521+ int res, ret;
522+ struct m41t93_data *m41t93;
174523
175524 spi->bits_per_word = 8;
176525 spi_setup(spi);
177526
178− res = spi_w8r8(spi, M41T93_REG_WDAY);
527+ m41t93 = devm_kzalloc(&spi->dev, sizeof(struct m41t93_data), GFP_KERNEL);
528+
529+ if (!m41t93)
530+ return -ENOMEM;
531+
532+ /* Set up regmap to access device registers*/
533+ m41t93->regmap = devm_regmap_init_spi(spi, &regmap_config);
534+ if (IS_ERR(m41t93->regmap)) {
535+ dev_err(&spi->dev, "regmap init failure\n");
536+ return PTR_ERR(m41t93->regmap);
537+ }
538+
539+ ret = regmap_read(m41t93->regmap, M41T93_REG_WDAY, &res);
540+ if (ret < 0) {
541+ dev_err(&spi->dev, "IO error\n");
542+ return -EIO;
543+ }
544+
179545 if (res < 0 || (res & 0xf8) != 0) {
180546 dev_err(&spi->dev, "not found 0x%x.\n", res);
181547 return -ENODEV;
182548 }
183549
184− rtc = devm_rtc_device_register(&spi->dev, m41t93_driver.driver.name,
185− &m41t93_rtc_ops, THIS_MODULE);
186− if (IS_ERR(rtc))
187− return PTR_ERR(rtc);
550+ spi_set_drvdata(spi, m41t93);
551+
552+ m41t93->rtc = devm_rtc_device_register(&spi->dev, m41t93_driver.driver.name,
553+ &m41t93_rtc_ops, THIS_MODULE);
554+ if (IS_ERR(m41t93->rtc))
555+ return PTR_ERR(m41t93->rtc);
188556
189− spi_set_drvdata(spi, rtc);
557+#ifdef CONFIG_COMMON_CLK
558+ ret = rtc_m41t93_clks_register(&spi->dev, m41t93);
559+ if (ret)
560+ dev_warn(&spi->dev, "Unable to register clock\n");
561+#endif
562+#ifdef CONFIG_WATCHDOG
563+ ret = m41t93_watchdog_register(&spi->dev, m41t93);
564+ if (ret)
565+ dev_warn(&spi->dev, "Unable to register watchdog\n");
566+#endif
190567
191568 return 0;
192569 }
193570
571+static const struct of_device_id m41t93_dt_match[] = {
572+ { .compatible = "st,m41t93" },
573+ { }
574+};
575+MODULE_DEVICE_TABLE(of, m41t93_dt_match);
576+
194577 static struct spi_driver m41t93_driver = {
195578 .driver = {
196579 .name = "rtc-m41t93",
580+ .of_match_table = m41t93_dt_match,
197581 },
198582 .probe = m41t93_probe,
199583 };
drivers/rtc/rtc-max31335.c+2−2
@@ -745,8 +745,8 @@ static int max31335_probe(struct i2c_client *client) · 744 unmodified lines
745745 }
746746
747747 static const struct i2c_device_id max31335_id[] = {
748− { "max31331", (kernel_ulong_t)&chip[ID_MAX31331] },
749− { "max31335", (kernel_ulong_t)&chip[ID_MAX31335] },
748+ { .name = "max31331", .driver_data = (kernel_ulong_t)&chip[ID_MAX31331] },
749+ { .name = "max31335", .driver_data = (kernel_ulong_t)&chip[ID_MAX31335] },
750750 { }
751751 };
752752
drivers/rtc/rtc-max6900.c+1−1
@@ -215,7 +215,7 @@ static int max6900_probe(struct i2c_client *client) · 214 unmodified lines
215215 }
216216
217217 static const struct i2c_device_id max6900_id[] = {
218− { "max6900" },
218+ { .name = "max6900" },
219219 { }
220220 };
221221 MODULE_DEVICE_TABLE(i2c, max6900_id);
drivers/rtc/rtc-max77686.c+5−5
@@ -866,11 +866,11 @@ static SIMPLE_DEV_PM_OPS(max77686_rtc_pm_ops, · 865 unmodified lines
866866 max77686_rtc_suspend, max77686_rtc_resume);
867867
868868 static const struct platform_device_id rtc_id[] = {
869− { "max77686-rtc", .driver_data = (kernel_ulong_t)&max77686_drv_data, },
870− { "max77802-rtc", .driver_data = (kernel_ulong_t)&max77802_drv_data, },
871− { "max77620-rtc", .driver_data = (kernel_ulong_t)&max77620_drv_data, },
872− { "max77714-rtc", .driver_data = (kernel_ulong_t)&max77714_drv_data, },
873− {},
869+ { .name = "max77686-rtc", .driver_data = (kernel_ulong_t)&max77686_drv_data },
870+ { .name = "max77802-rtc", .driver_data = (kernel_ulong_t)&max77802_drv_data },
871+ { .name = "max77620-rtc", .driver_data = (kernel_ulong_t)&max77620_drv_data },
872+ { .name = "max77714-rtc", .driver_data = (kernel_ulong_t)&max77714_drv_data },
873+ { }
874874 };
875875 MODULE_DEVICE_TABLE(platform, rtc_id);
876876
drivers/rtc/rtc-max8997.c+2−2
@@ -512,8 +512,8 @@ static void max8997_rtc_shutdown(struct platform_device *pdev) · 511 unmodified lines
512512 }
513513
514514 static const struct platform_device_id rtc_id[] = {
515− { "max8997-rtc", 0 },
516− {},
515+ { .name = "max8997-rtc" },
516+ { }
517517 };
518518 MODULE_DEVICE_TABLE(platform, rtc_id);
519519
drivers/rtc/rtc-max8998.c+2−2
@@ -299,8 +299,8 @@ no_irq: · 298 unmodified lines
299299 }
300300
301301 static const struct platform_device_id max8998_rtc_id[] = {
302− { "max8998-rtc", TYPE_MAX8998 },
303− { "lp3974-rtc", TYPE_LP3974 },
302+ { .name = "max8998-rtc", .driver_data = TYPE_MAX8998 },
303+ { .name = "lp3974-rtc", .driver_data = TYPE_LP3974 },
304304 { }
305305 };
306306 MODULE_DEVICE_TABLE(platform, max8998_rtc_id);
drivers/rtc/rtc-mpfs.c+1−1
@@ -112,7 +112,7 @@ static int mpfs_rtc_settime(struct device *dev, struct rtc_time *tm) · 111 unmodified lines
112112 ctrl |= CONTROL_UPLOAD_BIT;
113113 writel(ctrl, rtcdev->base + CONTROL_REG);
114114
115− ret = read_poll_timeout(readl, prog, prog & CONTROL_UPLOAD_BIT, 0, UPLOAD_TIMEOUT_US,
115+ ret = read_poll_timeout(readl, prog, !(prog & CONTROL_UPLOAD_BIT), 0, UPLOAD_TIMEOUT_US,
116116 false, rtcdev->base + CONTROL_REG);
117117 if (ret) {
118118 dev_err(dev, "timed out uploading time to rtc");
drivers/rtc/rtc-msc313.c+2−2
@@ -160,7 +160,7 @@ static const struct rtc_class_ops msc313_rtc_ops = { · 159 unmodified lines
160160
161161 static irqreturn_t msc313_rtc_interrupt(s32 irq, void *dev_id)
162162 {
163− struct msc313_rtc *priv = dev_get_drvdata(dev_id);
163+ struct msc313_rtc *priv = dev_id;
164164 u16 reg;
165165
166166 reg = readw(priv->rtc_base + REG_RTC_STATUS_INT);
@@ -206,7 +206,7 @@ static int msc313_rtc_probe(struct platform_device *pdev) · 39 unmodified lines
206206 priv->rtc_dev->range_max = U32_MAX;
207207
208208 ret = devm_request_irq(dev, irq, msc313_rtc_interrupt, IRQF_SHARED,
209− dev_name(&pdev->dev), &pdev->dev);
209+ dev_name(&pdev->dev), priv);
210210 if (ret) {
211211 dev_err(dev, "Could not request IRQ\n");
212212 return ret;
drivers/rtc/rtc-mv.c+23−0
@@ -301,6 +301,28 @@ static const struct of_device_id rtc_mv_of_match_table[] = { · 300 unmodified lines
301301 MODULE_DEVICE_TABLE(of, rtc_mv_of_match_table);
302302 #endif
303303
304+#ifdef CONFIG_PM_SLEEP
305+static int mv_rtc_suspend(struct device *dev)
306+{
307+ struct rtc_plat_data *pdata = dev_get_drvdata(dev);
308+
309+ if (device_may_wakeup(dev) && pdata->irq >= 0)
310+ enable_irq_wake(pdata->irq);
311+ return 0;
312+}
313+
314+static int mv_rtc_resume(struct device *dev)
315+{
316+ struct rtc_plat_data *pdata = dev_get_drvdata(dev);
317+
318+ if (device_may_wakeup(dev) && pdata->irq >= 0)
319+ disable_irq_wake(pdata->irq);
320+ return 0;
321+}
322+#endif
323+
324+static SIMPLE_DEV_PM_OPS(mv_rtc_pm_ops, mv_rtc_suspend, mv_rtc_resume);
325+
304326 /*
305327 * mv_rtc_remove() lives in .exit.text. For drivers registered via
306328 * module_platform_driver_probe() this is ok because they cannot get unbound at
@@ -312,6 +334,7 @@ static struct platform_driver mv_rtc_driver __refdata = { · 5 unmodified lines
312334 .driver = {
313335 .name = "rtc-mv",
314336 .of_match_table = of_match_ptr(rtc_mv_of_match_table),
337+ .pm = &mv_rtc_pm_ops,
315338 },
316339 };
317340
drivers/rtc/rtc-nct3018y.c+1−1
@@ -572,7 +572,7 @@ static int nct3018y_probe(struct i2c_client *client) · 571 unmodified lines
572572 }
573573
574574 static const struct i2c_device_id nct3018y_id[] = {
575− { "nct3018y" },
575+ { .name = "nct3018y" },
576576 { }
577577 };
578578 MODULE_DEVICE_TABLE(i2c, nct3018y_id);
drivers/rtc/rtc-pcap.c+0−179
@@ -1,179 +0,0 @@
1−// SPDX-License-Identifier: GPL-2.0
2−/*
3− * pcap rtc code for Motorola EZX phones
4− *
5− * Copyright (c) 2008 guiming zhuo <gmzhuo@gmail.com>
6− * Copyright (c) 2009 Daniel Ribeiro <drwyrm@gmail.com>
7− *
8− * Based on Motorola's rtc.c Copyright (c) 2003-2005 Motorola
9− */
10−
11−#include <linux/kernel.h>
12−#include <linux/module.h>
13−#include <linux/init.h>
14−#include <linux/mfd/ezx-pcap.h>
15−#include <linux/rtc.h>
16−#include <linux/slab.h>
17−#include <linux/platform_device.h>
18−
19−struct pcap_rtc {
20− struct pcap_chip *pcap;
21− struct rtc_device *rtc;
22−};
23−
24−static irqreturn_t pcap_rtc_irq(int irq, void *_pcap_rtc)
25−{
26− struct pcap_rtc *pcap_rtc = _pcap_rtc;
27− unsigned long rtc_events;
28−
29− if (irq == pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_1HZ))
30− rtc_events = RTC_IRQF | RTC_UF;
31− else if (irq == pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_TODA))
32− rtc_events = RTC_IRQF | RTC_AF;
33− else
34− rtc_events = 0;
35−
36− rtc_update_irq(pcap_rtc->rtc, 1, rtc_events);
37− return IRQ_HANDLED;
38−}
39−
40−static int pcap_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
41−{
42− struct pcap_rtc *pcap_rtc = dev_get_drvdata(dev);
43− struct rtc_time *tm = &alrm->time;
44− unsigned long secs;
45− u32 tod; /* time of day, seconds since midnight */
46− u32 days; /* days since 1/1/1970 */
47−
48− ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_TODA, &tod);
49− secs = tod & PCAP_RTC_TOD_MASK;
50−
51− ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_DAYA, &days);
52− secs += (days & PCAP_RTC_DAY_MASK) * SEC_PER_DAY;
53−
54− rtc_time64_to_tm(secs, tm);
55−
56− return 0;
57−}
58−
59−static int pcap_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
60−{
61− struct pcap_rtc *pcap_rtc = dev_get_drvdata(dev);
62− unsigned long secs = rtc_tm_to_time64(&alrm->time);
63− u32 tod, days;
64−
65− tod = secs % SEC_PER_DAY;
66− ezx_pcap_write(pcap_rtc->pcap, PCAP_REG_RTC_TODA, tod);
67−
68− days = secs / SEC_PER_DAY;
69− ezx_pcap_write(pcap_rtc->pcap, PCAP_REG_RTC_DAYA, days);
70−
71− return 0;
72−}
73−
74−static int pcap_rtc_read_time(struct device *dev, struct rtc_time *tm)
75−{
76− struct pcap_rtc *pcap_rtc = dev_get_drvdata(dev);
77− unsigned long secs;
78− u32 tod, days;
79−
80− ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_TOD, &tod);
81− secs = tod & PCAP_RTC_TOD_MASK;
82−
83− ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_DAY, &days);
84− secs += (days & PCAP_RTC_DAY_MASK) * SEC_PER_DAY;
85−
86− rtc_time64_to_tm(secs, tm);
87−
88− return 0;
89−}
90−
91−static int pcap_rtc_set_time(struct device *dev, struct rtc_time *tm)
92−{
93− struct pcap_rtc *pcap_rtc = dev_get_drvdata(dev);
94− unsigned long secs = rtc_tm_to_time64(tm);
95− u32 tod, days;
96−
97− tod = secs % SEC_PER_DAY;
98− ezx_pcap_write(pcap_rtc->pcap, PCAP_REG_RTC_TOD, tod);
99−
100− days = secs / SEC_PER_DAY;
101− ezx_pcap_write(pcap_rtc->pcap, PCAP_REG_RTC_DAY, days);
102−
103− return 0;
104−}
105−
106−static int pcap_rtc_irq_enable(struct device *dev, int pirq, unsigned int en)
107−{
108− struct pcap_rtc *pcap_rtc = dev_get_drvdata(dev);
109−
110− if (en)
111− enable_irq(pcap_to_irq(pcap_rtc->pcap, pirq));
112− else
113− disable_irq(pcap_to_irq(pcap_rtc->pcap, pirq));
114−
115− return 0;
116−}
117−
118−static int pcap_rtc_alarm_irq_enable(struct device *dev, unsigned int en)
119−{
120− return pcap_rtc_irq_enable(dev, PCAP_IRQ_TODA, en);
121−}
122−
123−static const struct rtc_class_ops pcap_rtc_ops = {
124− .read_time = pcap_rtc_read_time,
125− .set_time = pcap_rtc_set_time,
126− .read_alarm = pcap_rtc_read_alarm,
127− .set_alarm = pcap_rtc_set_alarm,
128− .alarm_irq_enable = pcap_rtc_alarm_irq_enable,
129−};
130−
131−static int __init pcap_rtc_probe(struct platform_device *pdev)
132−{
133− struct pcap_rtc *pcap_rtc;
134− int timer_irq, alarm_irq;
135− int err = -ENOMEM;
136−
137− pcap_rtc = devm_kzalloc(&pdev->dev, sizeof(struct pcap_rtc),
138− GFP_KERNEL);
139− if (!pcap_rtc)
140− return err;
141−
142− pcap_rtc->pcap = dev_get_drvdata(pdev->dev.parent);
143−
144− platform_set_drvdata(pdev, pcap_rtc);
145−
146− pcap_rtc->rtc = devm_rtc_allocate_device(&pdev->dev);
147− if (IS_ERR(pcap_rtc->rtc))
148− return PTR_ERR(pcap_rtc->rtc);
149−
150− pcap_rtc->rtc->ops = &pcap_rtc_ops;
151− pcap_rtc->rtc->range_max = (1 << 14) * 86400ULL - 1;
152−
153− timer_irq = pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_1HZ);
154− alarm_irq = pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_TODA);
155−
156− err = devm_request_irq(&pdev->dev, timer_irq, pcap_rtc_irq, 0,
157− "RTC Timer", pcap_rtc);
158− if (err)
159− return err;
160−
161− err = devm_request_irq(&pdev->dev, alarm_irq, pcap_rtc_irq, 0,
162− "RTC Alarm", pcap_rtc);
163− if (err)
164− return err;
165−
166− return devm_rtc_register_device(pcap_rtc->rtc);
167−}
168−
169−static struct platform_driver pcap_rtc_driver = {
170− .driver = {
171− .name = "pcap-rtc",
172− },
173−};
174−
175−module_platform_driver_probe(pcap_rtc_driver, pcap_rtc_probe);
176−
177−MODULE_DESCRIPTION("Motorola pcap rtc driver");
178−MODULE_AUTHOR("guiming zhuo <gmzhuo@gmail.com>");
179−MODULE_LICENSE("GPL");
drivers/rtc/rtc-pcf2127.c+4−4
@@ -1449,10 +1449,10 @@ static const struct regmap_bus pcf2127_i2c_regmap = { · 1448 unmodified lines
14491449 static struct i2c_driver pcf2127_i2c_driver;
14501450
14511451 static const struct i2c_device_id pcf2127_i2c_id[] = {
1452− { "pcf2127", (kernel_ulong_t)&pcf21xx_cfg[PCF2127] },
1453− { "pcf2129", (kernel_ulong_t)&pcf21xx_cfg[PCF2129] },
1454− { "pca2129", (kernel_ulong_t)&pcf21xx_cfg[PCF2129] },
1455− { "pcf2131", (kernel_ulong_t)&pcf21xx_cfg[PCF2131] },
1452+ { .name = "pcf2127", .driver_data = (kernel_ulong_t)&pcf21xx_cfg[PCF2127] },
1453+ { .name = "pcf2129", .driver_data = (kernel_ulong_t)&pcf21xx_cfg[PCF2129] },
1454+ { .name = "pca2129", .driver_data = (kernel_ulong_t)&pcf21xx_cfg[PCF2129] },
1455+ { .name = "pcf2131", .driver_data = (kernel_ulong_t)&pcf21xx_cfg[PCF2131] },
14561456 { }
14571457 };
14581458 MODULE_DEVICE_TABLE(i2c, pcf2127_i2c_id);
drivers/rtc/rtc-pcf85063.c+6−6
@@ -665,12 +665,12 @@ static const struct pcf85063_config config_rv8263 = { · 664 unmodified lines
665665 };
666666
667667 static const struct i2c_device_id pcf85063_ids[] = {
668− { "pca85073a", .driver_data = (kernel_ulong_t)&config_pcf85063a },
669− { "pcf85063", .driver_data = (kernel_ulong_t)&config_pcf85063 },
670− { "pcf85063tp", .driver_data = (kernel_ulong_t)&config_pcf85063tp },
671− { "pcf85063a", .driver_data = (kernel_ulong_t)&config_pcf85063a },
672− { "rv8263", .driver_data = (kernel_ulong_t)&config_rv8263 },
673− {}
668+ { .name = "pca85073a", .driver_data = (kernel_ulong_t)&config_pcf85063a },
669+ { .name = "pcf85063", .driver_data = (kernel_ulong_t)&config_pcf85063 },
670+ { .name = "pcf85063tp", .driver_data = (kernel_ulong_t)&config_pcf85063tp },
671+ { .name = "pcf85063a", .driver_data = (kernel_ulong_t)&config_pcf85063a },
672+ { .name = "rv8263", .driver_data = (kernel_ulong_t)&config_rv8263 },
673+ { }
674674 };
675675 MODULE_DEVICE_TABLE(i2c, pcf85063_ids);
676676
drivers/rtc/rtc-pcf8523.c+1−1
@@ -495,7 +495,7 @@ static int pcf8523_probe(struct i2c_client *client) · 494 unmodified lines
495495 }
496496
497497 static const struct i2c_device_id pcf8523_id[] = {
498− { "pcf8523" },
498+ { .name = "pcf8523" },
499499 { }
500500 };
501501 MODULE_DEVICE_TABLE(i2c, pcf8523_id);
drivers/rtc/rtc-pcf8563.c+3−3
@@ -557,9 +557,9 @@ static int pcf8563_probe(struct i2c_client *client) · 556 unmodified lines
557557 }
558558
559559 static const struct i2c_device_id pcf8563_id[] = {
560− { "pcf8563" },
561− { "rtc8564" },
562− { "pca8565" },
560+ { .name = "pcf8563" },
561+ { .name = "rtc8564" },
562+ { .name = "pca8565" },
563563 { }
564564 };
565565 MODULE_DEVICE_TABLE(i2c, pcf8563_id);
drivers/rtc/rtc-pcf8583.c+1−1
@@ -297,7 +297,7 @@ static int pcf8583_probe(struct i2c_client *client) · 296 unmodified lines
297297 }
298298
299299 static const struct i2c_device_id pcf8583_id[] = {
300− { "pcf8583" },
300+ { .name = "pcf8583" },
301301 { }
302302 };
303303 MODULE_DEVICE_TABLE(i2c, pcf8583_id);
drivers/rtc/rtc-renesas-rtca3.c+15−11
@@ -103,7 +103,7 @@ enum rtca3_alrm_set_step { · 102 unmodified lines
103103
104104 /**
105105 * struct rtca3_ppb_per_cycle - PPB per cycle
106− * @ten_sec: PPB per cycle in 10 seconds adjutment mode
106+ * @ten_sec: PPB per cycle in 10 seconds adjustment mode
107107 * @sixty_sec: PPB per cycle in 60 seconds adjustment mode
108108 */
109109 struct rtca3_ppb_per_cycle {
@@ -228,12 +228,19 @@ static void rtca3_prepare_cntalrm_regs_for_read(struct rtca3_priv *priv, bool cn · 118 unmodified lines
228228 }
229229 }
230230
231+static u32 rtca3_decode_year(u8 mask, u16 year)
232+{
233+ u8 y = FIELD_GET(mask, year);
234+ u32 century = bcd2bin((y == 0x99) ? 0x19 : 0x20);
235+
236+ return (century * 100 + bcd2bin(y)) - 1900;
237+}
238+
231239 static int rtca3_read_time(struct device *dev, struct rtc_time *tm)
232240 {
233241 struct rtca3_priv *priv = dev_get_drvdata(dev);
234242 u8 sec, min, hour, wday, mday, month, tmp;
235243 u8 trials = 0;
236− u32 year100;
237244 u16 year;
238245
239246 guard(spinlock_irqsave)(&priv->lock);
@@ -274,9 +281,7 @@ static int rtca3_read_time(struct device *dev, struct rtc_time *tm) · 34 unmodified lines
274281 tm->tm_wday = bcd2bin(FIELD_GET(RTCA3_RWKCNT_WK, wday));
275282 tm->tm_mday = bcd2bin(FIELD_GET(RTCA3_RDAYCNT_DAY, mday));
276283 tm->tm_mon = bcd2bin(FIELD_GET(RTCA3_RMONCNT_MONTH, month)) - 1;
277− year = FIELD_GET(RTCA3_RYRCNT_YEAR, year);
278− year100 = bcd2bin((year == 0x99) ? 0x19 : 0x20);
279− tm->tm_year = (year100 * 100 + bcd2bin(year)) - 1900;
284+ tm->tm_year = rtca3_decode_year(RTCA3_RYRCNT_YEAR, year);
280285
281286 return 0;
282287 }
@@ -354,7 +359,6 @@ static int rtca3_read_alarm(struct device *dev, struct rtc_wkalrm *wkalrm) · 71 unmodified lines
354359 struct rtca3_priv *priv = dev_get_drvdata(dev);
355360 u8 sec, min, hour, wday, mday, month;
356361 struct rtc_time *tm = &wkalrm->time;
357− u32 year100;
358362 u16 year;
359363
360364 guard(spinlock_irqsave)(&priv->lock);
@@ -373,9 +377,7 @@ static int rtca3_read_alarm(struct device *dev, struct rtc_wkalrm *wkalrm) · 12 unmodified lines
373377 tm->tm_wday = bcd2bin(FIELD_GET(RTCA3_RWKAR_DAYW, wday));
374378 tm->tm_mday = bcd2bin(FIELD_GET(RTCA3_RDAYAR_DATE, mday));
375379 tm->tm_mon = bcd2bin(FIELD_GET(RTCA3_RMONAR_MON, month)) - 1;
376− year = FIELD_GET(RTCA3_RYRAR_YR, year);
377− year100 = bcd2bin((year == 0x99) ? 0x19 : 0x20);
378− tm->tm_year = (year100 * 100 + bcd2bin(year)) - 1900;
380+ tm->tm_year = rtca3_decode_year(RTCA3_RYRAR_YR, year);
379381
380382 wkalrm->enabled = !!(readb(priv->base + RTCA3_RCR1) & RTCA3_RCR1_AIE);
381383
@@ -455,7 +457,7 @@ setup_failed: · 73 unmodified lines
455457 * specified timeout for setup.
456458 */
457459 writeb(rcr1 & ~RTCA3_RCR1_PIE, priv->base + RTCA3_RCR1);
458− readb_poll_timeout_atomic(priv->base + RTCA3_RCR1, tmp, !(tmp & ~RTCA3_RCR1_PIE),
460+ readb_poll_timeout_atomic(priv->base + RTCA3_RCR1, tmp, !(tmp & RTCA3_RCR1_PIE),
459461 10, RTCA3_DEFAULT_TIMEOUT_US);
460462 atomic_set(&priv->alrm_sstep, RTCA3_ALRM_SSTEP_DONE);
461463 }
@@ -634,6 +636,8 @@ static int rtca3_initial_setup(struct clk *clk, struct rtca3_priv *priv) · 172 unmodified lines
634636 writeb(0, priv->base + RTCA3_RADJ);
635637 ret = readb_poll_timeout(priv->base + RTCA3_RADJ, tmp, !tmp, 10,
636638 RTCA3_DEFAULT_TIMEOUT_US);
639+ if (ret)
640+ return ret;
637641
638642 /* Start the RTC and enable automatic time error adjustment. */
639643 mask = RTCA3_RCR2_START | RTCA3_RCR2_AADJE;
@@ -700,7 +704,7 @@ static void rtca3_action(void *data) · 60 unmodified lines
700704
701705 ret = reset_control_assert(priv->rstc);
702706 if (ret)
703− dev_err(dev, "Failed to de-assert reset!");
707+ dev_err(dev, "Failed to assert reset!");
704708
705709 ret = pm_runtime_put_sync(dev);
706710 if (ret < 0)
drivers/rtc/rtc-rs5c372.c+6−6
@@ -75,12 +75,12 @@ enum rtc_type { · 74 unmodified lines
7575 };
7676
7777 static const struct i2c_device_id rs5c372_id[] = {
78− { "r2025sd", rtc_r2025sd },
79− { "r2221tl", rtc_r2221tl },
80− { "rs5c372a", rtc_rs5c372a },
81− { "rs5c372b", rtc_rs5c372b },
82− { "rv5c386", rtc_rv5c386 },
83− { "rv5c387a", rtc_rv5c387a },
78+ { .name = "r2025sd", .driver_data = rtc_r2025sd },
79+ { .name = "r2221tl", .driver_data = rtc_r2221tl },
80+ { .name = "rs5c372a", .driver_data = rtc_rs5c372a },
81+ { .name = "rs5c372b", .driver_data = rtc_rs5c372b },
82+ { .name = "rv5c386", .driver_data = rtc_rv5c386 },
83+ { .name = "rv5c387a", .driver_data = rtc_rv5c387a },
8484 { }
8585 };
8686 MODULE_DEVICE_TABLE(i2c, rs5c372_id);
drivers/rtc/rtc-rv3029c2.c+2−2
@@ -807,8 +807,8 @@ static int rv3029_i2c_probe(struct i2c_client *client) · 806 unmodified lines
807807 }
808808
809809 static const struct i2c_device_id rv3029_id[] = {
810− { "rv3029" },
811− { "rv3029c2" },
810+ { .name = "rv3029" },
811+ { .name = "rv3029c2" },
812812 { }
813813 };
814814 MODULE_DEVICE_TABLE(i2c, rv3029_id);
drivers/rtc/rtc-rv8803.c+4−4
@@ -631,10 +631,10 @@ static int rv8803_suspend(struct device *dev) · 630 unmodified lines
631631 static DEFINE_SIMPLE_DEV_PM_OPS(rv8803_pm_ops, rv8803_suspend, rv8803_resume);
632632
633633 static const struct i2c_device_id rv8803_id[] = {
634− { "rv8803", rv_8803 },
635− { "rv8804", rx_8804 },
636− { "rx8803", rx_8803 },
637− { "rx8900", rx_8900 },
634+ { .name = "rv8803", .driver_data = rv_8803 },
635+ { .name = "rv8804", .driver_data = rx_8804 },
636+ { .name = "rx8803", .driver_data = rx_8803 },
637+ { .name = "rx8900", .driver_data = rx_8900 },
638638 { }
639639 };
640640 MODULE_DEVICE_TABLE(i2c, rv8803_id);
drivers/rtc/rtc-rx6110.c+1−1
@@ -449,7 +449,7 @@ static const struct acpi_device_id rx6110_i2c_acpi_match[] = { · 448 unmodified lines
449449 MODULE_DEVICE_TABLE(acpi, rx6110_i2c_acpi_match);
450450
451451 static const struct i2c_device_id rx6110_i2c_id[] = {
452− { "rx6110" },
452+ { .name = "rx6110" },
453453 { }
454454 };
455455 MODULE_DEVICE_TABLE(i2c, rx6110_i2c_id);
drivers/rtc/rtc-rx8010.c+1−1
@@ -50,7 +50,7 @@ · 49 unmodified lines
5050 #define RX8010_ALARM_AE BIT(7)
5151
5252 static const struct i2c_device_id rx8010_id[] = {
53− { "rx8010" },
53+ { .name = "rx8010" },
5454 { }
5555 };
5656 MODULE_DEVICE_TABLE(i2c, rx8010_id);
drivers/rtc/rtc-rx8025.c+2−2
@@ -71,8 +71,8 @@ enum rx_model { · 70 unmodified lines
7171 };
7272
7373 static const struct i2c_device_id rx8025_id[] = {
74− { "rx8025", model_rx_8025 },
75− { "rx8035", model_rx_8035 },
74+ { .name = "rx8025", .driver_data = model_rx_8025 },
75+ { .name = "rx8035", .driver_data = model_rx_8035 },
7676 { }
7777 };
7878 MODULE_DEVICE_TABLE(i2c, rx8025_id);
drivers/rtc/rtc-rx8581.c+1−1
@@ -294,7 +294,7 @@ static int rx8581_probe(struct i2c_client *client) · 293 unmodified lines
294294 }
295295
296296 static const struct i2c_device_id rx8581_id[] = {
297− { "rx8581" },
297+ { .name = "rx8581" },
298298 { }
299299 };
300300 MODULE_DEVICE_TABLE(i2c, rx8581_id);
drivers/rtc/rtc-s35390a.c+2−2
@@ -51,7 +51,7 @@ · 50 unmodified lines
5151 #define S35390A_INT2_MODE_PMIN (BIT(3) | BIT(2)) /* INT2FE | INT2ME */
5252
5353 static const struct i2c_device_id s35390a_id[] = {
54− { "s35390a" },
54+ { .name = "s35390a" },
5555 { }
5656 };
5757 MODULE_DEVICE_TABLE(i2c, s35390a_id);
@@ -297,7 +297,7 @@ static int s35390a_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm) · 239 unmodified lines
297297 else
298298 sts = S35390A_INT2_MODE_NOINTR;
299299
300− /* set interupt mode*/
300+ /* set interrupt mode*/
301301 err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts));
302302 if (err < 0)
303303 return err;
drivers/rtc/rtc-s5m.c+6−6
@@ -807,12 +807,12 @@ static int s5m_rtc_suspend(struct device *dev) · 806 unmodified lines
807807 static SIMPLE_DEV_PM_OPS(s5m_rtc_pm_ops, s5m_rtc_suspend, s5m_rtc_resume);
808808
809809 static const struct platform_device_id s5m_rtc_id[] = {
810− { "s5m-rtc", S5M8767X },
811− { "s2mpg10-rtc", S2MPG10 },
812− { "s2mps13-rtc", S2MPS13X },
813− { "s2mps14-rtc", S2MPS14X },
814− { "s2mps15-rtc", S2MPS15X },
815− { },
810+ { .name = "s5m-rtc", .driver_data = S5M8767X },
811+ { .name = "s2mpg10-rtc", .driver_data = S2MPG10 },
812+ { .name = "s2mps13-rtc", .driver_data = S2MPS13X },
813+ { .name = "s2mps14-rtc", .driver_data = S2MPS14X },
814+ { .name = "s2mps15-rtc", .driver_data = S2MPS15X },
815+ { }
816816 };
817817 MODULE_DEVICE_TABLE(platform, s5m_rtc_id);
818818
drivers/rtc/rtc-sd2405al.c+1−1
@@ -202,7 +202,7 @@ static int sd2405al_probe(struct i2c_client *client) · 201 unmodified lines
202202 }
203203
204204 static const struct i2c_device_id sd2405al_id[] = {
205− { "sd2405al" },
205+ { .name = "sd2405al" },
206206 { /* sentinel */ }
207207 };
208208 MODULE_DEVICE_TABLE(i2c, sd2405al_id);
drivers/rtc/rtc-sd3078.c+1−1
@@ -186,7 +186,7 @@ static int sd3078_probe(struct i2c_client *client) · 185 unmodified lines
186186 }
187187
188188 static const struct i2c_device_id sd3078_id[] = {
189− { "sd3078" },
189+ { .name = "sd3078" },
190190 { }
191191 };
192192 MODULE_DEVICE_TABLE(i2c, sd3078_id);
drivers/rtc/rtc-tps6594.c+2−2
@@ -485,8 +485,8 @@ static int tps6594_rtc_suspend(struct device *dev) · 484 unmodified lines
485485 static DEFINE_SIMPLE_DEV_PM_OPS(tps6594_rtc_pm_ops, tps6594_rtc_suspend, tps6594_rtc_resume);
486486
487487 static const struct platform_device_id tps6594_rtc_id_table[] = {
488− { "tps6594-rtc", },
489− {}
488+ { .name = "tps6594-rtc" },
489+ { }
490490 };
491491 MODULE_DEVICE_TABLE(platform, tps6594_rtc_id_table);
492492
drivers/rtc/rtc-x1205.c+1−1
@@ -663,7 +663,7 @@ static void x1205_remove(struct i2c_client *client) · 662 unmodified lines
663663 }
664664
665665 static const struct i2c_device_id x1205_id[] = {
666− { "x1205" },
666+ { .name = "x1205" },
667667 { }
668668 };
669669 MODULE_DEVICE_TABLE(i2c, x1205_id);
include/linux/rtc.h+2−0
@@ -190,6 +190,8 @@ extern int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm); · 189 unmodified lines
190190 int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm);
191191 extern int rtc_read_alarm(struct rtc_device *rtc,
192192 struct rtc_wkalrm *alrm);
193+extern int rtc_read_next_alarm(struct rtc_device *rtc,
194+ struct rtc_wkalrm *alrm);
193195 extern int rtc_set_alarm(struct rtc_device *rtc,
194196 struct rtc_wkalrm *alrm);
195197 extern int rtc_initialize_alarm(struct rtc_device *rtc,