write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/drivers/rtc/rtc-sirfsoc.c
..
..
@@ -1,9 +1,8 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
1
2
 /*
2
3
  * SiRFSoC Real Time Clock interface for Linux
3
4
  *
4
5
  * Copyright (c) 2013 Cambridge Silicon Radio Limited, a CSR plc group company.
5
- *
6
- * Licensed under GPLv2 or later.
7
6
  */
8
7
 
9
8
 #include <linux/module.h>
..
..
@@ -91,13 +90,13 @@
91
90
 	 */
92
91
 	/* if alarm is in next overflow cycle */
93
92
 	if (rtc_count > rtc_alarm)
94
-		rtc_time_to_tm((rtcdrv->overflow_rtc + 1)
95
-				<< (BITS_PER_LONG - RTC_SHIFT)
96
-				| rtc_alarm >> RTC_SHIFT, &(alrm->time));
93
+		rtc_time64_to_tm((rtcdrv->overflow_rtc + 1)
94
+				 << (BITS_PER_LONG - RTC_SHIFT)
95
+				 | rtc_alarm >> RTC_SHIFT, &alrm->time);
97
96
 	else
98
-		rtc_time_to_tm(rtcdrv->overflow_rtc
99
-				<< (BITS_PER_LONG - RTC_SHIFT)
100
-				| rtc_alarm >> RTC_SHIFT, &(alrm->time));
97
+		rtc_time64_to_tm(rtcdrv->overflow_rtc
98
+				 << (BITS_PER_LONG - RTC_SHIFT)
99
+				 | rtc_alarm >> RTC_SHIFT, &alrm->time);
101
100
 	if (sirfsoc_rtc_readl(rtcdrv, RTC_STATUS) & SIRFSOC_RTC_AL0E)
102
101
 		alrm->enabled = 1;
103
102
 
..
..
@@ -114,7 +113,7 @@
114
113
 	rtcdrv = dev_get_drvdata(dev);
115
114
 
116
115
 	if (alrm->enabled) {
117
-		rtc_tm_to_time(&(alrm->time), &rtc_alarm);
116
+		rtc_alarm = rtc_tm_to_time64(&alrm->time);
118
117
 
119
118
 		spin_lock_irq(&rtcdrv->lock);
120
119
 
..
..
@@ -182,8 +181,8 @@
182
181
 		cpu_relax();
183
182
 	} while (tmp_rtc != sirfsoc_rtc_readl(rtcdrv, RTC_CN));
184
183
 
185
-	rtc_time_to_tm(rtcdrv->overflow_rtc << (BITS_PER_LONG - RTC_SHIFT) |
186
-					tmp_rtc >> RTC_SHIFT, tm);
184
+	rtc_time64_to_tm(rtcdrv->overflow_rtc << (BITS_PER_LONG - RTC_SHIFT)
185
+			 | tmp_rtc >> RTC_SHIFT, tm);
187
186
 	return 0;
188
187
 }
189
188
 
..
..
@@ -194,7 +193,7 @@
194
193
 	struct sirfsoc_rtc_drv *rtcdrv;
195
194
 	rtcdrv = dev_get_drvdata(dev);
196
195
 
197
-	rtc_tm_to_time(tm, &rtc_time);
196
+	rtc_time = rtc_tm_to_time64(tm);
198
197
 
199
198
 	rtcdrv->overflow_rtc = rtc_time >> (BITS_PER_LONG - RTC_SHIFT);
200
199
 
..
..
@@ -279,7 +278,7 @@
279
278
 	{},
280
279
 };
281
280
 
282
-const struct regmap_config sysrtc_regmap_config = {
281
+static const struct regmap_config sysrtc_regmap_config = {
283
282
 	.reg_bits = 32,
284
283
 	.val_bits = 32,
285
284
 	.fast_io = true,
..
..
@@ -342,35 +341,22 @@
342
341
 	rtcdrv->overflow_rtc =
343
342
 		sirfsoc_rtc_readl(rtcdrv, RTC_SW_VALUE);
344
343
 
345
-	rtcdrv->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
346
-			&sirfsoc_rtc_ops, THIS_MODULE);
347
-	if (IS_ERR(rtcdrv->rtc)) {
348
-		err = PTR_ERR(rtcdrv->rtc);
349
-		dev_err(&pdev->dev, "can't register RTC device\n");
350
-		return err;
351
-	}
344
+	rtcdrv->rtc = devm_rtc_allocate_device(&pdev->dev);
345
+	if (IS_ERR(rtcdrv->rtc))
346
+		return PTR_ERR(rtcdrv->rtc);
347
+
348
+	rtcdrv->rtc->ops = &sirfsoc_rtc_ops;
349
+	rtcdrv->rtc->range_max = (1ULL << 60) - 1;
352
350
 
353
351
 	rtcdrv->irq = platform_get_irq(pdev, 0);
354
-	err = devm_request_irq(
355
-			&pdev->dev,
356
-			rtcdrv->irq,
357
-			sirfsoc_rtc_irq_handler,
358
-			IRQF_SHARED,
359
-			pdev->name,
360
-			rtcdrv);
352
+	err = devm_request_irq(&pdev->dev, rtcdrv->irq, sirfsoc_rtc_irq_handler,
353
+			       IRQF_SHARED, pdev->name, rtcdrv);
361
354
 	if (err) {
362
355
 		dev_err(&pdev->dev, "Unable to register for the SiRF SOC RTC IRQ\n");
363
356
 		return err;
364
357
 	}
365
358
 
366
-	return 0;
367
-}
368
-
369
-static int sirfsoc_rtc_remove(struct platform_device *pdev)
370
-{
371
-	device_init_wakeup(&pdev->dev, 0);
372
-
373
-	return 0;
359
+	return rtc_register_device(rtcdrv->rtc);
374
360
 }
375
361
 
376
362
 #ifdef CONFIG_PM_SLEEP
..
..
@@ -451,7 +437,6 @@
451
437
 		.of_match_table = sirfsoc_rtc_of_match,
452
438
 	},
453
439
 	.probe = sirfsoc_rtc_probe,
454
-	.remove = sirfsoc_rtc_remove,
455
440
 };
456
441
 module_platform_driver(sirfsoc_rtc_driver);
457
442