Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'rtc-6.4' of git://git.kernel.org/pub/scm/linux/kernel/git/abelloni/linux
Pull RTC updates from Alexandre Belloni:
"Not much this cycle, there is the conversion to remove_new and many
small fixes in drivers:
Subsystem:
- Convert to platform remove callback returning void
Drivers:
- meson-vrtc: fix a firmware display issue"
* tag 'rtc-6.4' of git://git.kernel.org/pub/scm/linux/kernel/git/abelloni/linux: (53 commits)
rtc: armada38x: use devm_platform_ioremap_resource_byname()
rtc: sunplus: use devm_platform_ioremap_resource_byname()
rtc: jz4740: Make sure clock provider gets removed
rtc: k3: handle errors while enabling wake irq
rtc: meson-vrtc: Use ktime_get_real_ts64() to get the current time
dt-bindings: rtc: Drop unneeded quotes
rtc: pcf8523: remove unnecessary OR operation
rtc: pcf8523: fix coding-style issues
rtc: ds1390: mark OF related data as maybe unused
rtc: omap: include header for omap_rtc_power_off_program prototype
rtc: sun6i: Use of_property_present() for testing DT property presence
rtc: mpfs: convert SOC_MICROCHIP_POLARFIRE to ARCH_MICROCHIP_POLARFIRE
rtc: zynqmp: Convert to platform remove callback returning void
rtc: xgene: Convert to platform remove callback returning void
rtc: wm8350: Convert to platform remove callback returning void
rtc: vt8500: Convert to platform remove callback returning void
rtc: twl: Convert to platform remove callback returning void
rtc: tps6586x: Convert to platform remove callback returning void
rtc: tegra: Convert to platform remove callback returning void
rtc: sunplus: Convert to platform remove callback returning void
...
+122
-197
+1
-1
Documentation/devicetree/bindings/rtc/allwinner,sun4i-a10-rtc.yaml
+1
-1
Documentation/devicetree/bindings/rtc/allwinner,sun4i-a10-rtc.yaml
+1
-1
Documentation/devicetree/bindings/rtc/allwinner,sun6i-a31-rtc.yaml
+1
-1
Documentation/devicetree/bindings/rtc/allwinner,sun6i-a31-rtc.yaml
+1
-1
Documentation/devicetree/bindings/rtc/atmel,at91rm9200-rtc.yaml
+1
-1
Documentation/devicetree/bindings/rtc/atmel,at91rm9200-rtc.yaml
+1
-1
Documentation/devicetree/bindings/rtc/atmel,at91sam9260-rtt.yaml
+1
-1
Documentation/devicetree/bindings/rtc/atmel,at91sam9260-rtt.yaml
+1
-1
Documentation/devicetree/bindings/rtc/brcm,brcmstb-waketimer.yaml
+1
-1
Documentation/devicetree/bindings/rtc/brcm,brcmstb-waketimer.yaml
+2
-2
Documentation/devicetree/bindings/rtc/faraday,ftrtc010.yaml
+2
-2
Documentation/devicetree/bindings/rtc/faraday,ftrtc010.yaml
+1
-1
Documentation/devicetree/bindings/rtc/microcrystal,rv3032.yaml
+1
-1
Documentation/devicetree/bindings/rtc/microcrystal,rv3032.yaml
+1
-1
Documentation/devicetree/bindings/rtc/mstar,msc313-rtc.yaml
+1
-1
Documentation/devicetree/bindings/rtc/mstar,msc313-rtc.yaml
+1
-1
Documentation/devicetree/bindings/rtc/nuvoton,nct3018y.yaml
+1
-1
Documentation/devicetree/bindings/rtc/nuvoton,nct3018y.yaml
+1
-1
Documentation/devicetree/bindings/rtc/nxp,pcf2127.yaml
+1
-1
Documentation/devicetree/bindings/rtc/nxp,pcf2127.yaml
+1
-1
Documentation/devicetree/bindings/rtc/rtc-mxc.yaml
+1
-1
Documentation/devicetree/bindings/rtc/rtc-mxc.yaml
+1
-1
Documentation/devicetree/bindings/rtc/rtc-mxc_v2.yaml
+1
-1
Documentation/devicetree/bindings/rtc/rtc-mxc_v2.yaml
+2
-2
Documentation/devicetree/bindings/rtc/sa1100-rtc.yaml
+2
-2
Documentation/devicetree/bindings/rtc/sa1100-rtc.yaml
+1
-1
Documentation/devicetree/bindings/rtc/st,stm32-rtc.yaml
+1
-1
Documentation/devicetree/bindings/rtc/st,stm32-rtc.yaml
+1
-1
Documentation/devicetree/bindings/rtc/ti,k3-rtc.yaml
+1
-1
Documentation/devicetree/bindings/rtc/ti,k3-rtc.yaml
+1
-1
Documentation/devicetree/bindings/rtc/trivial-rtc.yaml
+1
-1
Documentation/devicetree/bindings/rtc/trivial-rtc.yaml
+1
-1
drivers/rtc/Kconfig
+1
-1
drivers/rtc/Kconfig
···
1970
1970
1971
1971
config RTC_DRV_POLARFIRE_SOC
1972
1972
tristate "Microchip PolarFire SoC built-in RTC"
1973
-
depends on SOC_MICROCHIP_POLARFIRE
1973
+
depends on ARCH_MICROCHIP_POLARFIRE
1974
1974
help
1975
1975
If you say yes here you will get support for the
1976
1976
built-in RTC on Polarfire SoC.
+2
-3
drivers/rtc/rtc-88pm80x.c
+2
-3
drivers/rtc/rtc-88pm80x.c
···
317
317
return ret;
318
318
}
319
319
320
-
static int pm80x_rtc_remove(struct platform_device *pdev)
320
+
static void pm80x_rtc_remove(struct platform_device *pdev)
321
321
{
322
322
struct pm80x_rtc_info *info = platform_get_drvdata(pdev);
323
323
pm80x_free_irq(info->chip, info->irq, info);
324
-
return 0;
325
324
}
326
325
327
326
static struct platform_driver pm80x_rtc_driver = {
···
329
330
.pm = &pm80x_rtc_pm_ops,
330
331
},
331
332
.probe = pm80x_rtc_probe,
332
-
.remove = pm80x_rtc_remove,
333
+
.remove_new = pm80x_rtc_remove,
333
334
};
334
335
335
336
module_platform_driver(pm80x_rtc_driver);
+2
-4
drivers/rtc/rtc-88pm860x.c
+2
-4
drivers/rtc/rtc-88pm860x.c
···
331
331
return 0;
332
332
}
333
333
334
-
static int pm860x_rtc_remove(struct platform_device *pdev)
334
+
static void pm860x_rtc_remove(struct platform_device *pdev)
335
335
{
336
336
struct pm860x_rtc_info *info = platform_get_drvdata(pdev);
337
337
···
340
340
/* disable measurement */
341
341
pm860x_set_bits(info->i2c, PM8607_MEAS_EN2, MEAS2_VRTC, 0);
342
342
#endif /* VRTC_CALIBRATION */
343
-
344
-
return 0;
345
343
}
346
344
347
345
#ifdef CONFIG_PM_SLEEP
···
371
373
.pm = &pm860x_rtc_pm_ops,
372
374
},
373
375
.probe = pm860x_rtc_probe,
374
-
.remove = pm860x_rtc_remove,
376
+
.remove_new = pm860x_rtc_remove,
375
377
};
376
378
377
379
module_platform_driver(pm860x_rtc_driver);
+2
-4
drivers/rtc/rtc-ab8500.c
+2
-4
drivers/rtc/rtc-ab8500.c
···
392
392
return devm_rtc_register_device(rtc);
393
393
}
394
394
395
-
static int ab8500_rtc_remove(struct platform_device *pdev)
395
+
static void ab8500_rtc_remove(struct platform_device *pdev)
396
396
{
397
397
dev_pm_clear_wake_irq(&pdev->dev);
398
398
device_init_wakeup(&pdev->dev, false);
399
-
400
-
return 0;
401
399
}
402
400
403
401
static struct platform_driver ab8500_rtc_driver = {
···
403
405
.name = "ab8500-rtc",
404
406
},
405
407
.probe = ab8500_rtc_probe,
406
-
.remove = ab8500_rtc_remove,
408
+
.remove_new = ab8500_rtc_remove,
407
409
.id_table = ab85xx_rtc_ids,
408
410
};
409
411
+2
-4
drivers/rtc/rtc-ac100.c
+2
-4
drivers/rtc/rtc-ac100.c
···
613
613
return devm_rtc_register_device(chip->rtc);
614
614
}
615
615
616
-
static int ac100_rtc_remove(struct platform_device *pdev)
616
+
static void ac100_rtc_remove(struct platform_device *pdev)
617
617
{
618
618
struct ac100_rtc_dev *chip = platform_get_drvdata(pdev);
619
619
620
620
ac100_rtc_unregister_clks(chip);
621
-
622
-
return 0;
623
621
}
624
622
625
623
static const struct of_device_id ac100_rtc_match[] = {
···
628
630
629
631
static struct platform_driver ac100_rtc_driver = {
630
632
.probe = ac100_rtc_probe,
631
-
.remove = ac100_rtc_remove,
633
+
.remove_new = ac100_rtc_remove,
632
634
.driver = {
633
635
.name = "ac100-rtc",
634
636
.of_match_table = of_match_ptr(ac100_rtc_match),
+2
-5
drivers/rtc/rtc-armada38x.c
+2
-5
drivers/rtc/rtc-armada38x.c
···
491
491
492
492
static __init int armada38x_rtc_probe(struct platform_device *pdev)
493
493
{
494
-
struct resource *res;
495
494
struct armada38x_rtc *rtc;
496
495
497
496
rtc = devm_kzalloc(&pdev->dev, sizeof(struct armada38x_rtc),
···
507
508
508
509
spin_lock_init(&rtc->lock);
509
510
510
-
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "rtc");
511
-
rtc->regs = devm_ioremap_resource(&pdev->dev, res);
511
+
rtc->regs = devm_platform_ioremap_resource_byname(pdev, "rtc");
512
512
if (IS_ERR(rtc->regs))
513
513
return PTR_ERR(rtc->regs);
514
-
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "rtc-soc");
515
-
rtc->regs_soc = devm_ioremap_resource(&pdev->dev, res);
514
+
rtc->regs_soc = devm_platform_ioremap_resource_byname(pdev, "rtc-soc");
516
515
if (IS_ERR(rtc->regs_soc))
517
516
return PTR_ERR(rtc->regs_soc);
518
517
+2
-3
drivers/rtc/rtc-asm9260.c
+2
-3
drivers/rtc/rtc-asm9260.c
···
308
308
return ret;
309
309
}
310
310
311
-
static int asm9260_rtc_remove(struct platform_device *pdev)
311
+
static void asm9260_rtc_remove(struct platform_device *pdev)
312
312
{
313
313
struct asm9260_rtc_priv *priv = platform_get_drvdata(pdev);
314
314
315
315
/* Disable alarm matching */
316
316
iowrite32(BM_AMR_OFF, priv->iobase + HW_AMR);
317
317
clk_disable_unprepare(priv->clk);
318
-
return 0;
319
318
}
320
319
321
320
static const struct of_device_id asm9260_dt_ids[] = {
···
325
326
326
327
static struct platform_driver asm9260_rtc_driver = {
327
328
.probe = asm9260_rtc_probe,
328
-
.remove = asm9260_rtc_remove,
329
+
.remove_new = asm9260_rtc_remove,
329
330
.driver = {
330
331
.name = "asm9260-rtc",
331
332
.of_match_table = asm9260_dt_ids,
+2
-4
drivers/rtc/rtc-at91sam9.c
+2
-4
drivers/rtc/rtc-at91sam9.c
···
442
442
/*
443
443
* Disable and remove the RTC driver
444
444
*/
445
-
static int at91_rtc_remove(struct platform_device *pdev)
445
+
static void at91_rtc_remove(struct platform_device *pdev)
446
446
{
447
447
struct sam9_rtc *rtc = platform_get_drvdata(pdev);
448
448
u32 mr = rtt_readl(rtc, MR);
···
451
451
rtt_writel(rtc, MR, mr & ~(AT91_RTT_ALMIEN | AT91_RTT_RTTINCIEN));
452
452
453
453
clk_disable_unprepare(rtc->sclk);
454
-
455
-
return 0;
456
454
}
457
455
458
456
static void at91_rtc_shutdown(struct platform_device *pdev)
···
529
531
530
532
static struct platform_driver at91_rtc_driver = {
531
533
.probe = at91_rtc_probe,
532
-
.remove = at91_rtc_remove,
534
+
.remove_new = at91_rtc_remove,
533
535
.shutdown = at91_rtc_shutdown,
534
536
.driver = {
535
537
.name = "rtc-at91sam9",
+2
-4
drivers/rtc/rtc-brcmstb-waketimer.c
+2
-4
drivers/rtc/rtc-brcmstb-waketimer.c
···
336
336
return ret;
337
337
}
338
338
339
-
static int brcmstb_waketmr_remove(struct platform_device *pdev)
339
+
static void brcmstb_waketmr_remove(struct platform_device *pdev)
340
340
{
341
341
struct brcmstb_waketmr *timer = dev_get_drvdata(&pdev->dev);
342
342
343
343
unregister_reboot_notifier(&timer->reboot_notifier);
344
344
clk_disable_unprepare(timer->clk);
345
-
346
-
return 0;
347
345
}
348
346
349
347
#ifdef CONFIG_PM_SLEEP
···
380
382
381
383
static struct platform_driver brcmstb_waketmr_driver = {
382
384
.probe = brcmstb_waketmr_probe,
383
-
.remove = brcmstb_waketmr_remove,
385
+
.remove_new = brcmstb_waketmr_remove,
384
386
.driver = {
385
387
.name = "brcmstb-waketimer",
386
388
.pm = &brcmstb_waketmr_pm_ops,
+2
-4
drivers/rtc/rtc-cadence.c
+2
-4
drivers/rtc/rtc-cadence.c
···
354
354
return ret;
355
355
}
356
356
357
-
static int cdns_rtc_remove(struct platform_device *pdev)
357
+
static void cdns_rtc_remove(struct platform_device *pdev)
358
358
{
359
359
struct cdns_rtc *crtc = platform_get_drvdata(pdev);
360
360
···
363
363
364
364
clk_disable_unprepare(crtc->pclk);
365
365
clk_disable_unprepare(crtc->ref_clk);
366
-
367
-
return 0;
368
366
}
369
367
370
368
#ifdef CONFIG_PM_SLEEP
···
402
404
.pm = &cdns_rtc_pm_ops,
403
405
},
404
406
.probe = cdns_rtc_probe,
405
-
.remove = cdns_rtc_remove,
407
+
.remove_new = cdns_rtc_remove,
406
408
};
407
409
module_platform_driver(cdns_rtc_driver);
408
410
+2
-3
drivers/rtc/rtc-cmos.c
+2
-3
drivers/rtc/rtc-cmos.c
···
1489
1489
return cmos_do_probe(&pdev->dev, resource, irq);
1490
1490
}
1491
1491
1492
-
static int cmos_platform_remove(struct platform_device *pdev)
1492
+
static void cmos_platform_remove(struct platform_device *pdev)
1493
1493
{
1494
1494
cmos_do_remove(&pdev->dev);
1495
-
return 0;
1496
1495
}
1497
1496
1498
1497
static void cmos_platform_shutdown(struct platform_device *pdev)
···
1513
1514
MODULE_ALIAS("platform:rtc_cmos");
1514
1515
1515
1516
static struct platform_driver cmos_platform_driver = {
1516
-
.remove = cmos_platform_remove,
1517
+
.remove_new = cmos_platform_remove,
1517
1518
.shutdown = cmos_platform_shutdown,
1518
1519
.driver = {
1519
1520
.name = driver_name,
+2
-4
drivers/rtc/rtc-cros-ec.c
+2
-4
drivers/rtc/rtc-cros-ec.c
···
371
371
return 0;
372
372
}
373
373
374
-
static int cros_ec_rtc_remove(struct platform_device *pdev)
374
+
static void cros_ec_rtc_remove(struct platform_device *pdev)
375
375
{
376
376
struct cros_ec_rtc *cros_ec_rtc = platform_get_drvdata(pdev);
377
377
struct device *dev = &pdev->dev;
···
382
382
&cros_ec_rtc->notifier);
383
383
if (ret)
384
384
dev_err(dev, "failed to unregister notifier\n");
385
-
386
-
return 0;
387
385
}
388
386
389
387
static struct platform_driver cros_ec_rtc_driver = {
390
388
.probe = cros_ec_rtc_probe,
391
-
.remove = cros_ec_rtc_remove,
389
+
.remove_new = cros_ec_rtc_remove,
392
390
.driver = {
393
391
.name = DRV_NAME,
394
392
.pm = &cros_ec_rtc_pm_ops,
+1
-1
drivers/rtc/rtc-ds1390.c
+1
-1
drivers/rtc/rtc-ds1390.c
+2
-4
drivers/rtc/rtc-ds1685.c
+2
-4
drivers/rtc/rtc-ds1685.c
···
1322
1322
* ds1685_rtc_remove - removes rtc driver.
1323
1323
* @pdev: pointer to platform_device structure.
1324
1324
*/
1325
-
static int
1325
+
static void
1326
1326
ds1685_rtc_remove(struct platform_device *pdev)
1327
1327
{
1328
1328
struct ds1685_priv *rtc = platform_get_drvdata(pdev);
···
1344
1344
rtc->write(rtc, RTC_EXT_CTRL_4A,
1345
1345
(rtc->read(rtc, RTC_EXT_CTRL_4A) &
1346
1346
~(RTC_CTRL_4A_RWK_MASK)));
1347
-
1348
-
return 0;
1349
1347
}
1350
1348
1351
1349
/*
···
1354
1356
.name = "rtc-ds1685",
1355
1357
},
1356
1358
.probe = ds1685_rtc_probe,
1357
-
.remove = ds1685_rtc_remove,
1359
+
.remove_new = ds1685_rtc_remove,
1358
1360
};
1359
1361
module_platform_driver(ds1685_rtc_driver);
1360
1362
/* ----------------------------------------------------------------------- */
+2
-4
drivers/rtc/rtc-ftrtc010.c
+2
-4
drivers/rtc/rtc-ftrtc010.c
···
191
191
return ret;
192
192
}
193
193
194
-
static int ftrtc010_rtc_remove(struct platform_device *pdev)
194
+
static void ftrtc010_rtc_remove(struct platform_device *pdev)
195
195
{
196
196
struct ftrtc010_rtc *rtc = platform_get_drvdata(pdev);
197
197
···
199
199
clk_disable_unprepare(rtc->extclk);
200
200
if (!IS_ERR(rtc->pclk))
201
201
clk_disable_unprepare(rtc->pclk);
202
-
203
-
return 0;
204
202
}
205
203
206
204
static const struct of_device_id ftrtc010_rtc_dt_match[] = {
···
214
216
.of_match_table = ftrtc010_rtc_dt_match,
215
217
},
216
218
.probe = ftrtc010_rtc_probe,
217
-
.remove = ftrtc010_rtc_remove,
219
+
.remove_new = ftrtc010_rtc_remove,
218
220
};
219
221
220
222
module_platform_driver_probe(ftrtc010_rtc_driver, ftrtc010_rtc_probe);
+2
-4
drivers/rtc/rtc-hid-sensor-time.c
+2
-4
drivers/rtc/rtc-hid-sensor-time.c
···
296
296
return ret;
297
297
}
298
298
299
-
static int hid_time_remove(struct platform_device *pdev)
299
+
static void hid_time_remove(struct platform_device *pdev)
300
300
{
301
301
struct hid_sensor_hub_device *hsdev = dev_get_platdata(&pdev->dev);
302
302
303
303
sensor_hub_device_close(hsdev);
304
304
sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_TIME);
305
-
306
-
return 0;
307
305
}
308
306
309
307
static const struct platform_device_id hid_time_ids[] = {
···
319
321
.name = KBUILD_MODNAME,
320
322
},
321
323
.probe = hid_time_probe,
322
-
.remove = hid_time_remove,
324
+
.remove_new = hid_time_remove,
323
325
};
324
326
module_platform_driver(hid_time_platform_driver);
325
327
+2
-1
drivers/rtc/rtc-jz4740.c
+2
-1
drivers/rtc/rtc-jz4740.c
···
414
414
return dev_err_probe(dev, ret,
415
415
"Unable to register clk32k clock\n");
416
416
417
-
ret = of_clk_add_hw_provider(np, of_clk_hw_simple_get, &rtc->clk32k);
417
+
ret = devm_of_clk_add_hw_provider(dev, of_clk_hw_simple_get,
418
+
&rtc->clk32k);
418
419
if (ret)
419
420
return dev_err_probe(dev, ret,
420
421
"Unable to register clk32k clock provider\n");
+2
-4
drivers/rtc/rtc-lpc24xx.c
+2
-4
drivers/rtc/rtc-lpc24xx.c
···
264
264
return ret;
265
265
}
266
266
267
-
static int lpc24xx_rtc_remove(struct platform_device *pdev)
267
+
static void lpc24xx_rtc_remove(struct platform_device *pdev)
268
268
{
269
269
struct lpc24xx_rtc *rtc = platform_get_drvdata(pdev);
270
270
···
276
276
277
277
clk_disable_unprepare(rtc->clk_rtc);
278
278
clk_disable_unprepare(rtc->clk_reg);
279
-
280
-
return 0;
281
279
}
282
280
283
281
static const struct of_device_id lpc24xx_rtc_match[] = {
···
286
288
287
289
static struct platform_driver lpc24xx_rtc_driver = {
288
290
.probe = lpc24xx_rtc_probe,
289
-
.remove = lpc24xx_rtc_remove,
291
+
.remove_new = lpc24xx_rtc_remove,
290
292
.driver = {
291
293
.name = "lpc24xx-rtc",
292
294
.of_match_table = lpc24xx_rtc_match,
+2
-4
drivers/rtc/rtc-max77686.c
+2
-4
drivers/rtc/rtc-max77686.c
···
806
806
return ret;
807
807
}
808
808
809
-
static int max77686_rtc_remove(struct platform_device *pdev)
809
+
static void max77686_rtc_remove(struct platform_device *pdev)
810
810
{
811
811
struct max77686_rtc_info *info = platform_get_drvdata(pdev);
812
812
813
813
free_irq(info->virq, info);
814
814
regmap_del_irq_chip(info->rtc_irq, info->rtc_irq_data);
815
-
816
-
return 0;
817
815
}
818
816
819
817
#ifdef CONFIG_PM_SLEEP
···
875
877
.pm = &max77686_rtc_pm_ops,
876
878
},
877
879
.probe = max77686_rtc_probe,
878
-
.remove = max77686_rtc_remove,
880
+
.remove_new = max77686_rtc_remove,
879
881
.id_table = rtc_id,
880
882
};
881
883
+2
-4
drivers/rtc/rtc-mc13xxx.c
+2
-4
drivers/rtc/rtc-mc13xxx.c
···
324
324
return ret;
325
325
}
326
326
327
-
static int mc13xxx_rtc_remove(struct platform_device *pdev)
327
+
static void mc13xxx_rtc_remove(struct platform_device *pdev)
328
328
{
329
329
struct mc13xxx_rtc *priv = platform_get_drvdata(pdev);
330
330
···
334
334
mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_RTCRST, priv);
335
335
336
336
mc13xxx_unlock(priv->mc13xxx);
337
-
338
-
return 0;
339
337
}
340
338
341
339
static const struct platform_device_id mc13xxx_rtc_idtable[] = {
···
350
352
351
353
static struct platform_driver mc13xxx_rtc_driver = {
352
354
.id_table = mc13xxx_rtc_idtable,
353
-
.remove = mc13xxx_rtc_remove,
355
+
.remove_new = mc13xxx_rtc_remove,
354
356
.driver = {
355
357
.name = DRIVER_NAME,
356
358
},
+2
-2
drivers/rtc/rtc-meson-vrtc.c
+2
-2
drivers/rtc/rtc-meson-vrtc.c
···
23
23
struct timespec64 time;
24
24
25
25
dev_dbg(dev, "%s\n", __func__);
26
-
ktime_get_raw_ts64(&time);
26
+
ktime_get_real_ts64(&time);
27
27
rtc_time64_to_tm(time.tv_sec, tm);
28
28
29
29
return 0;
···
96
96
long alarm_secs;
97
97
struct timespec64 time;
98
98
99
-
ktime_get_raw_ts64(&time);
99
+
ktime_get_real_ts64(&time);
100
100
local_time = time.tv_sec;
101
101
102
102
dev_dbg(dev, "alarm_time = %lus, local_time=%lus\n",
+2
-4
drivers/rtc/rtc-mpc5121.c
+2
-4
drivers/rtc/rtc-mpc5121.c
···
372
372
return err;
373
373
}
374
374
375
-
static int mpc5121_rtc_remove(struct platform_device *op)
375
+
static void mpc5121_rtc_remove(struct platform_device *op)
376
376
{
377
377
struct mpc5121_rtc_data *rtc = platform_get_drvdata(op);
378
378
struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
···
383
383
384
384
irq_dispose_mapping(rtc->irq);
385
385
irq_dispose_mapping(rtc->irq_periodic);
386
-
387
-
return 0;
388
386
}
389
387
390
388
#ifdef CONFIG_OF
···
400
402
.of_match_table = of_match_ptr(mpc5121_rtc_match),
401
403
},
402
404
.probe = mpc5121_rtc_probe,
403
-
.remove = mpc5121_rtc_remove,
405
+
.remove_new = mpc5121_rtc_remove,
404
406
};
405
407
406
408
module_platform_driver(mpc5121_rtc_driver);
+2
-4
drivers/rtc/rtc-mpfs.c
+2
-4
drivers/rtc/rtc-mpfs.c
···
274
274
return devm_rtc_register_device(rtcdev->rtc);
275
275
}
276
276
277
-
static int mpfs_rtc_remove(struct platform_device *pdev)
277
+
static void mpfs_rtc_remove(struct platform_device *pdev)
278
278
{
279
279
dev_pm_clear_wake_irq(&pdev->dev);
280
-
281
-
return 0;
282
280
}
283
281
284
282
static const struct of_device_id mpfs_rtc_of_match[] = {
···
288
290
289
291
static struct platform_driver mpfs_rtc_driver = {
290
292
.probe = mpfs_rtc_probe,
291
-
.remove = mpfs_rtc_remove,
293
+
.remove_new = mpfs_rtc_remove,
292
294
.driver = {
293
295
.name = "mpfs_rtc",
294
296
.of_match_table = mpfs_rtc_of_match,
+2
-4
drivers/rtc/rtc-mt7622.c
+2
-4
drivers/rtc/rtc-mt7622.c
···
357
357
return ret;
358
358
}
359
359
360
-
static int mtk_rtc_remove(struct platform_device *pdev)
360
+
static void mtk_rtc_remove(struct platform_device *pdev)
361
361
{
362
362
struct mtk_rtc *hw = platform_get_drvdata(pdev);
363
363
364
364
clk_disable_unprepare(hw->clk);
365
-
366
-
return 0;
367
365
}
368
366
369
367
#ifdef CONFIG_PM_SLEEP
···
394
396
395
397
static struct platform_driver mtk_rtc_driver = {
396
398
.probe = mtk_rtc_probe,
397
-
.remove = mtk_rtc_remove,
399
+
.remove_new = mtk_rtc_remove,
398
400
.driver = {
399
401
.name = MTK_RTC_DEV,
400
402
.of_match_table = mtk_rtc_match,
+2
-3
drivers/rtc/rtc-mxc_v2.c
+2
-3
drivers/rtc/rtc-mxc_v2.c
···
362
362
return ret;
363
363
}
364
364
365
-
static int mxc_rtc_remove(struct platform_device *pdev)
365
+
static void mxc_rtc_remove(struct platform_device *pdev)
366
366
{
367
367
struct mxc_rtc_data *pdata = platform_get_drvdata(pdev);
368
368
369
369
clk_disable_unprepare(pdata->clk);
370
-
return 0;
371
370
}
372
371
373
372
static const struct of_device_id mxc_ids[] = {
···
381
382
.of_match_table = mxc_ids,
382
383
},
383
384
.probe = mxc_rtc_probe,
384
-
.remove = mxc_rtc_remove,
385
+
.remove_new = mxc_rtc_remove,
385
386
};
386
387
387
388
module_platform_driver(mxc_rtc_driver);
+3
-4
drivers/rtc/rtc-omap.c
+3
-4
drivers/rtc/rtc-omap.c
···
25
25
#include <linux/platform_device.h>
26
26
#include <linux/pm_runtime.h>
27
27
#include <linux/rtc.h>
28
+
#include <linux/rtc/rtc-omap.h>
28
29
29
30
/*
30
31
* The OMAP RTC is a year/month/day/hours/minutes/seconds BCD clock
···
911
910
return ret;
912
911
}
913
912
914
-
static int omap_rtc_remove(struct platform_device *pdev)
913
+
static void omap_rtc_remove(struct platform_device *pdev)
915
914
{
916
915
struct omap_rtc *rtc = platform_get_drvdata(pdev);
917
916
u8 reg;
···
942
941
/* Disable the clock/module */
943
942
pm_runtime_put_sync(&pdev->dev);
944
943
pm_runtime_disable(&pdev->dev);
945
-
946
-
return 0;
947
944
}
948
945
949
946
static int __maybe_unused omap_rtc_suspend(struct device *dev)
···
1016
1017
1017
1018
static struct platform_driver omap_rtc_driver = {
1018
1019
.probe = omap_rtc_probe,
1019
-
.remove = omap_rtc_remove,
1020
+
.remove_new = omap_rtc_remove,
1020
1021
.shutdown = omap_rtc_shutdown,
1021
1022
.driver = {
1022
1023
.name = "omap_rtc",
+2
-3
drivers/rtc/rtc-palmas.c
+2
-3
drivers/rtc/rtc-palmas.c
···
308
308
return 0;
309
309
}
310
310
311
-
static int palmas_rtc_remove(struct platform_device *pdev)
311
+
static void palmas_rtc_remove(struct platform_device *pdev)
312
312
{
313
313
palmas_rtc_alarm_irq_enable(&pdev->dev, 0);
314
-
return 0;
315
314
}
316
315
317
316
#ifdef CONFIG_PM_SLEEP
···
346
347
347
348
static struct platform_driver palmas_rtc_driver = {
348
349
.probe = palmas_rtc_probe,
349
-
.remove = palmas_rtc_remove,
350
+
.remove_new = palmas_rtc_remove,
350
351
.driver = {
351
352
.name = "palmas-rtc",
352
353
.pm = &palmas_rtc_pm_ops,
+2
-4
drivers/rtc/rtc-pcf50633.c
+2
-4
drivers/rtc/rtc-pcf50633.c
···
260
260
return 0;
261
261
}
262
262
263
-
static int pcf50633_rtc_remove(struct platform_device *pdev)
263
+
static void pcf50633_rtc_remove(struct platform_device *pdev)
264
264
{
265
265
struct pcf50633_rtc *rtc;
266
266
267
267
rtc = platform_get_drvdata(pdev);
268
268
pcf50633_free_irq(rtc->pcf, PCF50633_IRQ_ALARM);
269
-
270
-
return 0;
271
269
}
272
270
273
271
static struct platform_driver pcf50633_rtc_driver = {
···
273
275
.name = "pcf50633-rtc",
274
276
},
275
277
.probe = pcf50633_rtc_probe,
276
-
.remove = pcf50633_rtc_remove,
278
+
.remove_new = pcf50633_rtc_remove,
277
279
};
278
280
279
281
module_platform_driver(pcf50633_rtc_driver);
+8
-9
drivers/rtc/rtc-pcf8523.c
+8
-9
drivers/rtc/rtc-pcf8523.c
···
21
21
#define PCF8523_CONTROL2_AF BIT(3)
22
22
23
23
#define PCF8523_REG_CONTROL3 0x02
24
-
#define PCF8523_CONTROL3_PM GENMASK(7,5)
24
+
#define PCF8523_CONTROL3_PM GENMASK(7, 5)
25
25
#define PCF8523_PM_STANDBY 0x7
26
26
#define PCF8523_CONTROL3_BLF BIT(2) /* battery low bit, read-only */
27
27
#define PCF8523_CONTROL3_BSF BIT(3)
···
65
65
load);
66
66
fallthrough;
67
67
case 12500:
68
-
value |= PCF8523_CONTROL1_CAP_SEL;
68
+
value = PCF8523_CONTROL1_CAP_SEL;
69
69
break;
70
70
case 7000:
71
71
break;
···
234
234
int ret;
235
235
u32 value;
236
236
237
-
switch(param->param) {
238
-
237
+
switch (param->param) {
239
238
case RTC_PARAM_BACKUP_SWITCH_MODE:
240
239
ret = regmap_read(pcf8523->regmap, PCF8523_REG_CONTROL3, &value);
241
240
if (ret < 0)
···
242
243
243
244
value = FIELD_GET(PCF8523_CONTROL3_PM, value);
244
245
245
-
switch(value) {
246
+
switch (value) {
246
247
case 0x0:
247
248
case 0x4:
248
249
param->uvalue = RTC_BSM_LEVEL;
···
272
273
struct pcf8523 *pcf8523 = dev_get_drvdata(dev);
273
274
u8 mode;
274
275
275
-
switch(param->param) {
276
+
switch (param->param) {
276
277
case RTC_PARAM_BACKUP_SWITCH_MODE:
277
278
switch (param->uvalue) {
278
279
case RTC_BSM_DISABLED:
···
384
385
};
385
386
386
387
static const struct regmap_config regmap_config = {
387
-
.reg_bits = 8,
388
-
.val_bits = 8,
389
-
.max_register = 0x13,
388
+
.reg_bits = 8,
389
+
.val_bits = 8,
390
+
.max_register = 0x13,
390
391
};
391
392
392
393
static int pcf8523_probe(struct i2c_client *client)
+2
-4
drivers/rtc/rtc-pic32.c
+2
-4
drivers/rtc/rtc-pic32.c
···
284
284
clk_disable(pdata->clk);
285
285
}
286
286
287
-
static int pic32_rtc_remove(struct platform_device *pdev)
287
+
static void pic32_rtc_remove(struct platform_device *pdev)
288
288
{
289
289
struct pic32_rtc_dev *pdata = platform_get_drvdata(pdev);
290
290
291
291
pic32_rtc_setaie(&pdev->dev, 0);
292
292
clk_unprepare(pdata->clk);
293
293
pdata->clk = NULL;
294
-
295
-
return 0;
296
294
}
297
295
298
296
static int pic32_rtc_probe(struct platform_device *pdev)
···
371
373
372
374
static struct platform_driver pic32_rtc_driver = {
373
375
.probe = pic32_rtc_probe,
374
-
.remove = pic32_rtc_remove,
376
+
.remove_new = pic32_rtc_remove,
375
377
.driver = {
376
378
.name = "pic32-rtc",
377
379
.of_match_table = of_match_ptr(pic32_rtc_dt_ids),
+2
-3
drivers/rtc/rtc-pm8xxx.c
+2
-3
drivers/rtc/rtc-pm8xxx.c
···
530
530
return 0;
531
531
}
532
532
533
-
static int pm8xxx_remove(struct platform_device *pdev)
533
+
static void pm8xxx_remove(struct platform_device *pdev)
534
534
{
535
535
dev_pm_clear_wake_irq(&pdev->dev);
536
-
return 0;
537
536
}
538
537
539
538
static struct platform_driver pm8xxx_rtc_driver = {
540
539
.probe = pm8xxx_rtc_probe,
541
-
.remove = pm8xxx_remove,
540
+
.remove_new = pm8xxx_remove,
542
541
.driver = {
543
542
.name = "rtc-pm8xxx",
544
543
.of_match_table = pm8xxx_id_table,
+2
-3
drivers/rtc/rtc-rc5t583.c
+2
-3
drivers/rtc/rtc-rc5t583.c
···
262
262
* Disable rc5t583 RTC interrupts.
263
263
* Sets status flag to free.
264
264
*/
265
-
static int rc5t583_rtc_remove(struct platform_device *pdev)
265
+
static void rc5t583_rtc_remove(struct platform_device *pdev)
266
266
{
267
267
struct rc5t583_rtc *rc5t583_rtc = platform_get_drvdata(pdev);
268
268
269
269
rc5t583_rtc_alarm_irq_enable(&rc5t583_rtc->rtc->dev, 0);
270
-
return 0;
271
270
}
272
271
273
272
#ifdef CONFIG_PM_SLEEP
···
298
299
299
300
static struct platform_driver rc5t583_rtc_driver = {
300
301
.probe = rc5t583_rtc_probe,
301
-
.remove = rc5t583_rtc_remove,
302
+
.remove_new = rc5t583_rtc_remove,
302
303
.driver = {
303
304
.name = "rtc-rc5t583",
304
305
.pm = &rc5t583_rtc_pm_ops,
+2
-4
drivers/rtc/rtc-rtd119x.c
+2
-4
drivers/rtc/rtc-rtd119x.c
···
216
216
return 0;
217
217
}
218
218
219
-
static int rtd119x_rtc_remove(struct platform_device *pdev)
219
+
static void rtd119x_rtc_remove(struct platform_device *pdev)
220
220
{
221
221
struct rtd119x_rtc *data = platform_get_drvdata(pdev);
222
222
···
224
224
225
225
clk_disable_unprepare(data->clk);
226
226
clk_put(data->clk);
227
-
228
-
return 0;
229
227
}
230
228
231
229
static struct platform_driver rtd119x_rtc_driver = {
232
230
.probe = rtd119x_rtc_probe,
233
-
.remove = rtd119x_rtc_remove,
231
+
.remove_new = rtd119x_rtc_remove,
234
232
.driver = {
235
233
.name = "rtd1295-rtc",
236
234
.of_match_table = rtd119x_rtc_dt_ids,
+2
-4
drivers/rtc/rtc-rzn1.c
+2
-4
drivers/rtc/rtc-rzn1.c
···
391
391
return ret;
392
392
}
393
393
394
-
static int rzn1_rtc_remove(struct platform_device *pdev)
394
+
static void rzn1_rtc_remove(struct platform_device *pdev)
395
395
{
396
396
pm_runtime_put(&pdev->dev);
397
-
398
-
return 0;
399
397
}
400
398
401
399
static const struct of_device_id rzn1_rtc_of_match[] = {
···
404
406
405
407
static struct platform_driver rzn1_rtc_driver = {
406
408
.probe = rzn1_rtc_probe,
407
-
.remove = rzn1_rtc_remove,
409
+
.remove_new = rzn1_rtc_remove,
408
410
.driver = {
409
411
.name = "rzn1-rtc",
410
412
.of_match_table = rzn1_rtc_of_match,
+2
-4
drivers/rtc/rtc-s3c.c
+2
-4
drivers/rtc/rtc-s3c.c
···
385
385
writew(con, info->base + S3C2410_RTCCON);
386
386
}
387
387
388
-
static int s3c_rtc_remove(struct platform_device *pdev)
388
+
static void s3c_rtc_remove(struct platform_device *pdev)
389
389
{
390
390
struct s3c_rtc *info = platform_get_drvdata(pdev);
391
391
···
394
394
if (info->data->needs_src_clk)
395
395
clk_unprepare(info->rtc_src_clk);
396
396
clk_unprepare(info->rtc_clk);
397
-
398
-
return 0;
399
397
}
400
398
401
399
static int s3c_rtc_probe(struct platform_device *pdev)
···
598
600
599
601
static struct platform_driver s3c_rtc_driver = {
600
602
.probe = s3c_rtc_probe,
601
-
.remove = s3c_rtc_remove,
603
+
.remove_new = s3c_rtc_remove,
602
604
.driver = {
603
605
.name = "s3c-rtc",
604
606
.pm = &s3c_rtc_pm_ops,
+2
-4
drivers/rtc/rtc-sa1100.c
+2
-4
drivers/rtc/rtc-sa1100.c
···
297
297
return sa1100_rtc_init(pdev, info);
298
298
}
299
299
300
-
static int sa1100_rtc_remove(struct platform_device *pdev)
300
+
static void sa1100_rtc_remove(struct platform_device *pdev)
301
301
{
302
302
struct sa1100_rtc *info = platform_get_drvdata(pdev);
303
303
···
307
307
spin_unlock_irq(&info->lock);
308
308
clk_disable_unprepare(info->clk);
309
309
}
310
-
311
-
return 0;
312
310
}
313
311
314
312
#ifdef CONFIG_PM_SLEEP
···
341
343
342
344
static struct platform_driver sa1100_rtc_driver = {
343
345
.probe = sa1100_rtc_probe,
344
-
.remove = sa1100_rtc_remove,
346
+
.remove_new = sa1100_rtc_remove,
345
347
.driver = {
346
348
.name = "sa1100-rtc",
347
349
.pm = &sa1100_rtc_pm_ops,
+2
-4
drivers/rtc/rtc-spear.c
+2
-4
drivers/rtc/rtc-spear.c
···
405
405
return status;
406
406
}
407
407
408
-
static int spear_rtc_remove(struct platform_device *pdev)
408
+
static void spear_rtc_remove(struct platform_device *pdev)
409
409
{
410
410
struct spear_rtc_config *config = platform_get_drvdata(pdev);
411
411
412
412
spear_rtc_disable_interrupt(config);
413
413
clk_disable_unprepare(config->clk);
414
414
device_init_wakeup(&pdev->dev, 0);
415
-
416
-
return 0;
417
415
}
418
416
419
417
#ifdef CONFIG_PM_SLEEP
···
475
477
476
478
static struct platform_driver spear_rtc_driver = {
477
479
.probe = spear_rtc_probe,
478
-
.remove = spear_rtc_remove,
480
+
.remove_new = spear_rtc_remove,
479
481
.shutdown = spear_rtc_shutdown,
480
482
.driver = {
481
483
.name = "rtc-spear",
+2
-4
drivers/rtc/rtc-stm32.c
+2
-4
drivers/rtc/rtc-stm32.c
···
846
846
return ret;
847
847
}
848
848
849
-
static int stm32_rtc_remove(struct platform_device *pdev)
849
+
static void stm32_rtc_remove(struct platform_device *pdev)
850
850
{
851
851
struct stm32_rtc *rtc = platform_get_drvdata(pdev);
852
852
const struct stm32_rtc_registers *regs = &rtc->data->regs;
···
869
869
870
870
dev_pm_clear_wake_irq(&pdev->dev);
871
871
device_init_wakeup(&pdev->dev, false);
872
-
873
-
return 0;
874
872
}
875
873
876
874
#ifdef CONFIG_PM_SLEEP
···
915
917
916
918
static struct platform_driver stm32_rtc_driver = {
917
919
.probe = stm32_rtc_probe,
918
-
.remove = stm32_rtc_remove,
920
+
.remove_new = stm32_rtc_remove,
919
921
.driver = {
920
922
.name = DRIVER_NAME,
921
923
.pm = &stm32_rtc_pm_ops,
+3
-5
drivers/rtc/rtc-stmp3xxx.c
+3
-5
drivers/rtc/rtc-stmp3xxx.c
···
232
232
.set_alarm = stmp3xxx_rtc_set_alarm,
233
233
};
234
234
235
-
static int stmp3xxx_rtc_remove(struct platform_device *pdev)
235
+
static void stmp3xxx_rtc_remove(struct platform_device *pdev)
236
236
{
237
237
struct stmp3xxx_rtc_data *rtc_data = platform_get_drvdata(pdev);
238
238
239
239
if (!rtc_data)
240
-
return 0;
240
+
return;
241
241
242
242
writel(STMP3XXX_RTC_CTRL_ALARM_IRQ_EN,
243
243
rtc_data->io + STMP3XXX_RTC_CTRL + STMP_OFFSET_REG_CLR);
244
-
245
-
return 0;
246
244
}
247
245
248
246
static int stmp3xxx_rtc_probe(struct platform_device *pdev)
···
404
406
405
407
static struct platform_driver stmp3xxx_rtcdrv = {
406
408
.probe = stmp3xxx_rtc_probe,
407
-
.remove = stmp3xxx_rtc_remove,
409
+
.remove_new = stmp3xxx_rtc_remove,
408
410
.driver = {
409
411
.name = "stmp3xxx-rtc",
410
412
.pm = &stmp3xxx_rtc_pm_ops,
+1
-1
drivers/rtc/rtc-sun6i.c
+1
-1
drivers/rtc/rtc-sun6i.c
···
260
260
}
261
261
262
262
/* Switch to the external, more precise, oscillator, if present */
263
-
if (of_get_property(node, "clocks", NULL)) {
263
+
if (of_property_present(node, "clocks")) {
264
264
reg |= SUN6I_LOSC_CTRL_EXT_OSC;
265
265
if (rtc->data->has_losc_en)
266
266
reg |= SUN6I_LOSC_CTRL_EXT_LOSC_EN;
+3
-6
drivers/rtc/rtc-sunplus.c
+3
-6
drivers/rtc/rtc-sunplus.c
···
235
235
if (!sp_rtc)
236
236
return -ENOMEM;
237
237
238
-
sp_rtc->res = platform_get_resource_byname(plat_dev, IORESOURCE_MEM, RTC_REG_NAME);
239
-
sp_rtc->reg_base = devm_ioremap_resource(&plat_dev->dev, sp_rtc->res);
238
+
sp_rtc->reg_base = devm_platform_ioremap_resource_byname(plat_dev, RTC_REG_NAME);
240
239
if (IS_ERR(sp_rtc->reg_base))
241
240
return dev_err_probe(&plat_dev->dev, PTR_ERR(sp_rtc->reg_base),
242
241
"%s devm_ioremap_resource fail\n", RTC_REG_NAME);
···
303
304
return ret;
304
305
}
305
306
306
-
static int sp_rtc_remove(struct platform_device *plat_dev)
307
+
static void sp_rtc_remove(struct platform_device *plat_dev)
307
308
{
308
309
struct sunplus_rtc *sp_rtc = dev_get_drvdata(&plat_dev->dev);
309
310
310
311
device_init_wakeup(&plat_dev->dev, 0);
311
312
reset_control_assert(sp_rtc->rstc);
312
313
clk_disable_unprepare(sp_rtc->rtcclk);
313
-
314
-
return 0;
315
314
}
316
315
317
316
#ifdef CONFIG_PM_SLEEP
···
344
347
345
348
static struct platform_driver sp_rtc_driver = {
346
349
.probe = sp_rtc_probe,
347
-
.remove = sp_rtc_remove,
350
+
.remove_new = sp_rtc_remove,
348
351
.driver = {
349
352
.name = "sp7021-rtc",
350
353
.of_match_table = sp_rtc_of_match,
+2
-4
drivers/rtc/rtc-tegra.c
+2
-4
drivers/rtc/rtc-tegra.c
···
342
342
return ret;
343
343
}
344
344
345
-
static int tegra_rtc_remove(struct platform_device *pdev)
345
+
static void tegra_rtc_remove(struct platform_device *pdev)
346
346
{
347
347
struct tegra_rtc_info *info = platform_get_drvdata(pdev);
348
348
349
349
clk_disable_unprepare(info->clk);
350
-
351
-
return 0;
352
350
}
353
351
354
352
#ifdef CONFIG_PM_SLEEP
···
399
401
400
402
static struct platform_driver tegra_rtc_driver = {
401
403
.probe = tegra_rtc_probe,
402
-
.remove = tegra_rtc_remove,
404
+
.remove_new = tegra_rtc_remove,
403
405
.shutdown = tegra_rtc_shutdown,
404
406
.driver = {
405
407
.name = "tegra_rtc",
+2
-1
drivers/rtc/rtc-ti-k3.c
+2
-1
drivers/rtc/rtc-ti-k3.c
+2
-3
drivers/rtc/rtc-tps6586x.c
+2
-3
drivers/rtc/rtc-tps6586x.c
···
279
279
return ret;
280
280
};
281
281
282
-
static int tps6586x_rtc_remove(struct platform_device *pdev)
282
+
static void tps6586x_rtc_remove(struct platform_device *pdev)
283
283
{
284
284
struct device *tps_dev = to_tps6586x_dev(&pdev->dev);
285
285
286
286
tps6586x_update(tps_dev, RTC_CTRL, 0,
287
287
RTC_ENABLE | OSC_SRC_SEL | PRE_BYPASS | CL_SEL_MASK);
288
-
return 0;
289
288
}
290
289
291
290
#ifdef CONFIG_PM_SLEEP
···
316
317
.pm = &tps6586x_pm_ops,
317
318
},
318
319
.probe = tps6586x_rtc_probe,
319
-
.remove = tps6586x_rtc_remove,
320
+
.remove_new = tps6586x_rtc_remove,
320
321
};
321
322
module_platform_driver(tps6586x_rtc_driver);
322
323
+2
-4
drivers/rtc/rtc-twl.c
+2
-4
drivers/rtc/rtc-twl.c
···
586
586
* Disable all TWL RTC module interrupts.
587
587
* Sets status flag to free.
588
588
*/
589
-
static int twl_rtc_remove(struct platform_device *pdev)
589
+
static void twl_rtc_remove(struct platform_device *pdev)
590
590
{
591
591
struct twl_rtc *twl_rtc = platform_get_drvdata(pdev);
592
592
···
599
599
twl6030_interrupt_mask(TWL6030_RTC_INT_MASK,
600
600
REG_INT_MSK_STS_A);
601
601
}
602
-
603
-
return 0;
604
602
}
605
603
606
604
static void twl_rtc_shutdown(struct platform_device *pdev)
···
640
642
641
643
static struct platform_driver twl4030rtc_driver = {
642
644
.probe = twl_rtc_probe,
643
-
.remove = twl_rtc_remove,
645
+
.remove_new = twl_rtc_remove,
644
646
.shutdown = twl_rtc_shutdown,
645
647
.driver = {
646
648
.name = "twl_rtc",
+2
-4
drivers/rtc/rtc-vt8500.c
+2
-4
drivers/rtc/rtc-vt8500.c
···
235
235
return devm_rtc_register_device(vt8500_rtc->rtc);
236
236
}
237
237
238
-
static int vt8500_rtc_remove(struct platform_device *pdev)
238
+
static void vt8500_rtc_remove(struct platform_device *pdev)
239
239
{
240
240
struct vt8500_rtc *vt8500_rtc = platform_get_drvdata(pdev);
241
241
242
242
/* Disable alarm matching */
243
243
writel(0, vt8500_rtc->regbase + VT8500_RTC_IS);
244
-
245
-
return 0;
246
244
}
247
245
248
246
static const struct of_device_id wmt_dt_ids[] = {
···
251
253
252
254
static struct platform_driver vt8500_rtc_driver = {
253
255
.probe = vt8500_rtc_probe,
254
-
.remove = vt8500_rtc_remove,
256
+
.remove_new = vt8500_rtc_remove,
255
257
.driver = {
256
258
.name = "vt8500-rtc",
257
259
.of_match_table = wmt_dt_ids,
+2
-4
drivers/rtc/rtc-wm8350.c
+2
-4
drivers/rtc/rtc-wm8350.c
···
451
451
return 0;
452
452
}
453
453
454
-
static int wm8350_rtc_remove(struct platform_device *pdev)
454
+
static void wm8350_rtc_remove(struct platform_device *pdev)
455
455
{
456
456
struct wm8350 *wm8350 = platform_get_drvdata(pdev);
457
457
458
458
wm8350_free_irq(wm8350, WM8350_IRQ_RTC_SEC, wm8350);
459
459
wm8350_free_irq(wm8350, WM8350_IRQ_RTC_ALM, wm8350);
460
-
461
-
return 0;
462
460
}
463
461
464
462
static SIMPLE_DEV_PM_OPS(wm8350_rtc_pm_ops, wm8350_rtc_suspend,
···
464
466
465
467
static struct platform_driver wm8350_rtc_driver = {
466
468
.probe = wm8350_rtc_probe,
467
-
.remove = wm8350_rtc_remove,
469
+
.remove_new = wm8350_rtc_remove,
468
470
.driver = {
469
471
.name = "wm8350-rtc",
470
472
.pm = &wm8350_rtc_pm_ops,
+2
-3
drivers/rtc/rtc-xgene.c
+2
-3
drivers/rtc/rtc-xgene.c
···
192
192
return 0;
193
193
}
194
194
195
-
static int xgene_rtc_remove(struct platform_device *pdev)
195
+
static void xgene_rtc_remove(struct platform_device *pdev)
196
196
{
197
197
struct xgene_rtc_dev *pdata = platform_get_drvdata(pdev);
198
198
199
199
xgene_rtc_alarm_irq_enable(&pdev->dev, 0);
200
200
device_init_wakeup(&pdev->dev, 0);
201
201
clk_disable_unprepare(pdata->clk);
202
-
return 0;
203
202
}
204
203
205
204
static int __maybe_unused xgene_rtc_suspend(struct device *dev)
···
263
264
264
265
static struct platform_driver xgene_rtc_driver = {
265
266
.probe = xgene_rtc_probe,
266
-
.remove = xgene_rtc_remove,
267
+
.remove_new = xgene_rtc_remove,
267
268
.driver = {
268
269
.name = "xgene-rtc",
269
270
.pm = &xgene_rtc_pm_ops,
+2
-4
drivers/rtc/rtc-zynqmp.c
+2
-4
drivers/rtc/rtc-zynqmp.c
···
342
342
return devm_rtc_register_device(xrtcdev->rtc);
343
343
}
344
344
345
-
static int xlnx_rtc_remove(struct platform_device *pdev)
345
+
static void xlnx_rtc_remove(struct platform_device *pdev)
346
346
{
347
347
xlnx_rtc_alarm_irq_enable(&pdev->dev, 0);
348
348
device_init_wakeup(&pdev->dev, 0);
349
-
350
-
return 0;
351
349
}
352
350
353
351
static int __maybe_unused xlnx_rtc_suspend(struct device *dev)
···
382
384
383
385
static struct platform_driver xlnx_rtc_driver = {
384
386
.probe = xlnx_rtc_probe,
385
-
.remove = xlnx_rtc_remove,
387
+
.remove_new = xlnx_rtc_remove,
386
388
.driver = {
387
389
.name = KBUILD_MODNAME,
388
390
.pm = &xlnx_rtc_pm_ops,