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

tjh.dev / kernel

fork atom

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

fork atom

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

Pull RTC updates from Alexandre Belloni:
"Not much this cycle, there are multiple small fixes.

Core:
- use boolean values with device_init_wakeup()

Drivers:
- pcf2127: add BSM support
- pcf85063: fix possible out of bounds write"

* tag 'rtc-6.14' of git://git.kernel.org/pub/scm/linux/kernel/git/abelloni/linux:
rtc: pcf2127: add BSM support
rtc: Remove hpet_rtc_dropped_irq()
dt-bindings: rtc: mxc: Document fsl,imx31-rtc
rtc: stm32: Use syscon_regmap_lookup_by_phandle_args
rtc: zynqmp: Fix optional clock name property
rtc: loongson: clear TOY_MATCH0_REG in loongson_rtc_isr()
rtc: pcf85063: fix potential OOB write in PCF85063 NVMEM read
rtc: tps6594: Fix integer overflow on 32bit systems
rtc: use boolean values with device_init_wakeup()
rtc: RTC_DRV_SPEAR should not default to y when compile-testing

Linus Torvalds 1 year ago 2a9f04bd a4b5e48e

+180 -102

61 changed files

expand all collapse all

Documentation

devicetree

bindings

rtc

rtc-mxc.yaml

arch

x86

include

asm

hpet.h

kernel

hpet.c

drivers

rtc

Kconfig

rtc-88pm80x.c

rtc-88pm860x.c

rtc-amlogic-a4.c

rtc-armada38x.c

rtc-as3722.c

rtc-at91rm9200.c

rtc-at91sam9.c

rtc-cadence.c

rtc-cmos.c

rtc-cpcap.c

rtc-cros-ec.c

rtc-da9055.c

rtc-ds3232.c

rtc-isl1208.c

rtc-jz4740.c

rtc-loongson.c

rtc-lp8788.c

rtc-lpc32xx.c

rtc-max77686.c

rtc-max8925.c

rtc-max8997.c

rtc-meson-vrtc.c

rtc-mpc5121.c

rtc-mt6397.c

rtc-mv.c

rtc-mxc.c

rtc-mxc_v2.c

rtc-omap.c

rtc-palmas.c

rtc-pcf2127.c

rtc-pcf85063.c

rtc-pic32.c

rtc-pm8xxx.c

rtc-pxa.c

rtc-rc5t583.c

rtc-rc5t619.c

rtc-renesas-rtca3.c

rtc-rk808.c

rtc-s3c.c

rtc-s5m.c

rtc-sa1100.c

rtc-sc27xx.c

rtc-sh.c

rtc-spear.c

rtc-stm32.c

rtc-sun6i.c

rtc-sunplus.c

rtc-tegra.c

rtc-test.c

rtc-tps6586x.c

rtc-tps65910.c

rtc-tps6594.c

rtc-twl.c

rtc-wm831x.c

rtc-wm8350.c

rtc-xgene.c

rtc-zynqmp.c

+7 -3

Documentation/devicetree/bindings/rtc/rtc-mxc.yaml

reviewed

··· 14 14 15 15 properties: 16 16 compatible: 17 17 - enum: 18 18 - - fsl,imx1-rtc 19 19 - - fsl,imx21-rtc 17 17 + oneOf: 18 18 + - const: fsl,imx1-rtc 19 19 + - const: fsl,imx21-rtc 20 20 + - items: 21 21 + - enum: 22 22 + - fsl,imx31-rtc 23 23 + - const: fsl,imx21-rtc 20 24 21 25 reg: 22 26 maxItems: 1

-1

arch/x86/include/asm/hpet.h

reviewed

··· 84 84 extern int hpet_set_alarm_time(unsigned char hrs, unsigned char min, 85 85 unsigned char sec); 86 86 extern int hpet_set_periodic_freq(unsigned long freq); 87 87 - extern int hpet_rtc_dropped_irq(void); 88 87 extern int hpet_rtc_timer_init(void); 89 88 extern irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id); 90 89 extern int hpet_register_irq_handler(rtc_irq_handler handler);

-6

arch/x86/kernel/hpet.c

reviewed

··· 1382 1382 } 1383 1383 EXPORT_SYMBOL_GPL(hpet_set_periodic_freq); 1384 1384 1385 1385 - int hpet_rtc_dropped_irq(void) 1386 1386 - { 1387 1387 - return is_hpet_enabled(); 1388 1388 - } 1389 1389 - EXPORT_SYMBOL_GPL(hpet_rtc_dropped_irq); 1390 1390 - 1391 1385 static void hpet_rtc_timer_reinit(void) 1392 1386 { 1393 1387 unsigned int delta;

+1 -1

drivers/rtc/Kconfig

reviewed

··· 1316 1316 config RTC_DRV_SPEAR 1317 1317 tristate "SPEAR ST RTC" 1318 1318 depends on PLAT_SPEAR || COMPILE_TEST 1319 1319 - default y 1319 1319 + default PLAT_SPEAR 1320 1320 help 1321 1321 If you say Y here you will get support for the RTC found on 1322 1322 spear

+1 -1

drivers/rtc/rtc-88pm80x.c

reviewed

··· 308 308 /* remember whether this power up is caused by PMIC RTC or not */ 309 309 info->rtc_dev->dev.platform_data = &pdata->rtc_wakeup; 310 310 311 311 - device_init_wakeup(&pdev->dev, 1); 311 311 + device_init_wakeup(&pdev->dev, true); 312 312 313 313 return 0; 314 314 out_rtc:

+1 -1

drivers/rtc/rtc-88pm860x.c

reviewed

··· 326 326 schedule_delayed_work(&info->calib_work, VRTC_CALIB_INTERVAL); 327 327 #endif /* VRTC_CALIBRATION */ 328 328 329 329 - device_init_wakeup(&pdev->dev, 1); 329 329 + device_init_wakeup(&pdev->dev, true); 330 330 331 331 return 0; 332 332 }

+3 -3

drivers/rtc/rtc-amlogic-a4.c

reviewed

··· 361 361 "failed to get_enable rtc sys clk\n"); 362 362 aml_rtc_init(rtc); 363 363 364 364 - device_init_wakeup(dev, 1); 364 364 + device_init_wakeup(dev, true); 365 365 platform_set_drvdata(pdev, rtc); 366 366 367 367 rtc->rtc_dev = devm_rtc_allocate_device(dev); ··· 391 391 return 0; 392 392 err_clk: 393 393 clk_disable_unprepare(rtc->sys_clk); 394 394 - device_init_wakeup(dev, 0); 394 394 + device_init_wakeup(dev, false); 395 395 396 396 return ret; 397 397 } ··· 426 426 struct aml_rtc_data *rtc = dev_get_drvdata(&pdev->dev); 427 427 428 428 clk_disable_unprepare(rtc->sys_clk); 429 429 - device_init_wakeup(&pdev->dev, 0); 429 429 + device_init_wakeup(&pdev->dev, false); 430 430 } 431 431 432 432 static const struct aml_rtc_config a5_rtc_config = {

+1 -1

drivers/rtc/rtc-armada38x.c

reviewed

··· 527 527 platform_set_drvdata(pdev, rtc); 528 528 529 529 if (rtc->irq != -1) 530 530 - device_init_wakeup(&pdev->dev, 1); 530 530 + device_init_wakeup(&pdev->dev, true); 531 531 else 532 532 clear_bit(RTC_FEATURE_ALARM, rtc->rtc_dev->features); 533 533

+1 -1

drivers/rtc/rtc-as3722.c

reviewed

··· 187 187 return ret; 188 188 } 189 189 190 190 - device_init_wakeup(&pdev->dev, 1); 190 190 + device_init_wakeup(&pdev->dev, true); 191 191 192 192 as3722_rtc->rtc = devm_rtc_device_register(&pdev->dev, "as3722-rtc", 193 193 &as3722_rtc_ops, THIS_MODULE);

+1 -1

drivers/rtc/rtc-at91rm9200.c

reviewed

··· 528 528 * being wake-capable; if it didn't, do that here. 529 529 */ 530 530 if (!device_can_wakeup(&pdev->dev)) 531 531 - device_init_wakeup(&pdev->dev, 1); 531 531 + device_init_wakeup(&pdev->dev, true); 532 532 533 533 if (at91_rtc_config->has_correction) 534 534 rtc->ops = &sama5d4_rtc_ops;

+1 -1

drivers/rtc/rtc-at91sam9.c

reviewed

··· 353 353 354 354 /* platform setup code should have handled this; sigh */ 355 355 if (!device_can_wakeup(&pdev->dev)) 356 356 - device_init_wakeup(&pdev->dev, 1); 356 356 + device_init_wakeup(&pdev->dev, true); 357 357 358 358 platform_set_drvdata(pdev, rtc); 359 359

+1 -1

drivers/rtc/rtc-cadence.c

reviewed

··· 359 359 struct cdns_rtc *crtc = platform_get_drvdata(pdev); 360 360 361 361 cdns_rtc_alarm_irq_enable(&pdev->dev, 0); 362 362 - device_init_wakeup(&pdev->dev, 0); 362 362 + device_init_wakeup(&pdev->dev, false); 363 363 364 364 clk_disable_unprepare(crtc->pclk); 365 365 clk_disable_unprepare(crtc->ref_clk);

+1 -6

drivers/rtc/rtc-cmos.c

reviewed

··· 151 151 return 0; 152 152 } 153 153 154 154 - static inline int hpet_rtc_dropped_irq(void) 155 155 - { 156 156 - return 0; 157 157 - } 158 158 - 159 154 static inline int hpet_rtc_timer_init(void) 160 155 { 161 156 return 0; ··· 859 864 dev_info(dev, "RTC can wake from S4\n"); 860 865 861 866 /* RTC always wakes from S1/S2/S3, and often S4/STD */ 862 862 - device_init_wakeup(dev, 1); 867 867 + device_init_wakeup(dev, true); 863 868 } 864 869 865 870 static void cmos_check_acpi_rtc_status(struct device *dev,

+1 -1

drivers/rtc/rtc-cpcap.c

reviewed

··· 295 295 } 296 296 disable_irq(rtc->update_irq); 297 297 298 298 - err = device_init_wakeup(dev, 1); 298 298 + err = device_init_wakeup(dev, true); 299 299 if (err) { 300 300 dev_err(dev, "wakeup initialization failed (%d)\n", err); 301 301 /* ignore error and continue without wakeup support */

+1 -1

drivers/rtc/rtc-cros-ec.c

reviewed

··· 337 337 return ret; 338 338 } 339 339 340 340 - ret = device_init_wakeup(&pdev->dev, 1); 340 340 + ret = device_init_wakeup(&pdev->dev, true); 341 341 if (ret) { 342 342 dev_err(&pdev->dev, "failed to initialize wakeup\n"); 343 343 return ret;

+1 -1

drivers/rtc/rtc-da9055.c

reviewed

··· 288 288 if (ret & DA9055_RTC_ALM_EN) 289 289 rtc->alarm_enable = 1; 290 290 291 291 - device_init_wakeup(&pdev->dev, 1); 291 291 + device_init_wakeup(&pdev->dev, true); 292 292 293 293 rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name, 294 294 &da9055_rtc_ops, THIS_MODULE);

+1 -1

drivers/rtc/rtc-ds3232.c

reviewed

··· 508 508 return ret; 509 509 510 510 if (ds3232->irq > 0) 511 511 - device_init_wakeup(dev, 1); 511 511 + device_init_wakeup(dev, true); 512 512 513 513 ds3232_hwmon_register(dev, name); 514 514

+1 -1

drivers/rtc/rtc-isl1208.c

reviewed

··· 830 830 isl1208_driver.driver.name, 831 831 client); 832 832 if (!rc) { 833 833 - device_init_wakeup(&client->dev, 1); 833 833 + device_init_wakeup(&client->dev, true); 834 834 enable_irq_wake(irq); 835 835 } else { 836 836 dev_err(&client->dev,

+1 -1

drivers/rtc/rtc-jz4740.c

reviewed

··· 367 367 368 368 platform_set_drvdata(pdev, rtc); 369 369 370 370 - device_init_wakeup(dev, 1); 370 370 + device_init_wakeup(dev, true); 371 371 372 372 ret = dev_pm_set_wake_irq(dev, irq); 373 373 if (ret)

+10 -7

drivers/rtc/rtc-loongson.c

reviewed

··· 114 114 struct loongson_rtc_priv *priv = (struct loongson_rtc_priv *)id; 115 115 116 116 rtc_update_irq(priv->rtcdev, 1, RTC_AF | RTC_IRQF); 117 117 + 118 118 + /* 119 119 + * The TOY_MATCH0_REG should be cleared 0 here, 120 120 + * otherwise the interrupt cannot be cleared. 121 121 + */ 122 122 + regmap_write(priv->regmap, TOY_MATCH0_REG, 0); 123 123 + 117 124 return IRQ_HANDLED; 118 125 } 119 126 ··· 138 131 writel(RTC_STS, priv->pm_base + PM1_STS_REG); 139 132 spin_unlock(&priv->lock); 140 133 141 141 - /* 142 142 - * The TOY_MATCH0_REG should be cleared 0 here, 143 143 - * otherwise the interrupt cannot be cleared. 144 144 - */ 145 145 - return regmap_write(priv->regmap, TOY_MATCH0_REG, 0); 134 134 + return ACPI_INTERRUPT_HANDLED; 146 135 } 147 136 148 137 static int loongson_rtc_set_enabled(struct device *dev) ··· 332 329 alarm_irq); 333 330 334 331 priv->pm_base = regs - priv->config->pm_offset; 335 335 - device_init_wakeup(dev, 1); 332 332 + device_init_wakeup(dev, true); 336 333 337 334 if (has_acpi_companion(dev)) 338 335 acpi_install_fixed_event_handler(ACPI_EVENT_RTC, ··· 363 360 acpi_remove_fixed_event_handler(ACPI_EVENT_RTC, 364 361 loongson_rtc_handler); 365 362 366 366 - device_init_wakeup(dev, 0); 363 363 + device_init_wakeup(dev, false); 367 364 loongson_rtc_alarm_irq_enable(dev, 0); 368 365 } 369 366

+1 -1

drivers/rtc/rtc-lp8788.c

reviewed

··· 293 293 rtc->alarm = lp->pdata ? lp->pdata->alarm_sel : DEFAULT_ALARM_SEL; 294 294 platform_set_drvdata(pdev, rtc); 295 295 296 296 - device_init_wakeup(dev, 1); 296 296 + device_init_wakeup(dev, true); 297 297 298 298 rtc->rdev = devm_rtc_device_register(dev, "lp8788_rtc", 299 299 &lp8788_rtc_ops, THIS_MODULE);

+1 -1

drivers/rtc/rtc-lpc32xx.c

reviewed

··· 257 257 dev_warn(&pdev->dev, "Can't request interrupt.\n"); 258 258 rtc->irq = -1; 259 259 } else { 260 260 - device_init_wakeup(&pdev->dev, 1); 260 260 + device_init_wakeup(&pdev->dev, true); 261 261 } 262 262 } 263 263

+1 -1

drivers/rtc/rtc-max77686.c

reviewed

··· 770 770 goto err_rtc; 771 771 } 772 772 773 773 - device_init_wakeup(&pdev->dev, 1); 773 773 + device_init_wakeup(&pdev->dev, true); 774 774 775 775 info->rtc_dev = devm_rtc_device_register(&pdev->dev, id->name, 776 776 &max77686_rtc_ops, THIS_MODULE);

+1 -1

drivers/rtc/rtc-max8925.c

reviewed

··· 270 270 /* XXX - isn't this redundant? */ 271 271 platform_set_drvdata(pdev, info); 272 272 273 273 - device_init_wakeup(&pdev->dev, 1); 273 273 + device_init_wakeup(&pdev->dev, true); 274 274 275 275 info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8925-rtc", 276 276 &max8925_rtc_ops, THIS_MODULE);

+1 -1

drivers/rtc/rtc-max8997.c

reviewed

··· 473 473 max8997_rtc_enable_wtsr(info, true); 474 474 max8997_rtc_enable_smpl(info, true); 475 475 476 476 - device_init_wakeup(&pdev->dev, 1); 476 476 + device_init_wakeup(&pdev->dev, true); 477 477 478 478 info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8997-rtc", 479 479 &max8997_rtc_ops, THIS_MODULE);

+1 -1

drivers/rtc/rtc-meson-vrtc.c

reviewed

··· 74 74 if (IS_ERR(vrtc->io_alarm)) 75 75 return PTR_ERR(vrtc->io_alarm); 76 76 77 77 - device_init_wakeup(&pdev->dev, 1); 77 77 + device_init_wakeup(&pdev->dev, true); 78 78 79 79 platform_set_drvdata(pdev, vrtc); 80 80

+1 -1

drivers/rtc/rtc-mpc5121.c

reviewed

··· 303 303 return PTR_ERR(rtc->regs); 304 304 } 305 305 306 306 - device_init_wakeup(&op->dev, 1); 306 306 + device_init_wakeup(&op->dev, true); 307 307 308 308 platform_set_drvdata(op, rtc); 309 309

+1 -1

drivers/rtc/rtc-mt6397.c

reviewed

··· 286 286 return ret; 287 287 } 288 288 289 289 - device_init_wakeup(&pdev->dev, 1); 289 289 + device_init_wakeup(&pdev->dev, true); 290 290 291 291 rtc->rtc_dev->ops = &mtk_rtc_ops; 292 292 rtc->rtc_dev->range_min = RTC_TIMESTAMP_BEGIN_1900;

+2 -2

drivers/rtc/rtc-mv.c

reviewed

··· 264 264 } 265 265 266 266 if (pdata->irq >= 0) 267 267 - device_init_wakeup(&pdev->dev, 1); 267 267 + device_init_wakeup(&pdev->dev, true); 268 268 else 269 269 clear_bit(RTC_FEATURE_ALARM, pdata->rtc->features); 270 270 ··· 287 287 struct rtc_plat_data *pdata = platform_get_drvdata(pdev); 288 288 289 289 if (pdata->irq >= 0) 290 290 - device_init_wakeup(&pdev->dev, 0); 290 290 + device_init_wakeup(&pdev->dev, false); 291 291 292 292 if (!IS_ERR(pdata->clk)) 293 293 clk_disable_unprepare(pdata->clk);

+1 -1

drivers/rtc/rtc-mxc.c

reviewed

··· 377 377 } 378 378 379 379 if (pdata->irq >= 0) { 380 380 - device_init_wakeup(&pdev->dev, 1); 380 380 + device_init_wakeup(&pdev->dev, true); 381 381 ret = dev_pm_set_wake_irq(&pdev->dev, pdata->irq); 382 382 if (ret) 383 383 dev_err(&pdev->dev, "failed to enable irq wake\n");

+1 -1

drivers/rtc/rtc-mxc_v2.c

reviewed

··· 302 302 if (pdata->irq < 0) 303 303 return pdata->irq; 304 304 305 305 - device_init_wakeup(&pdev->dev, 1); 305 305 + device_init_wakeup(&pdev->dev, true); 306 306 ret = dev_pm_set_wake_irq(&pdev->dev, pdata->irq); 307 307 if (ret) 308 308 dev_err(&pdev->dev, "failed to enable irq wake\n");

+1 -1

drivers/rtc/rtc-omap.c

reviewed

··· 920 920 omap_rtc_power_off_rtc = NULL; 921 921 } 922 922 923 923 - device_init_wakeup(&pdev->dev, 0); 923 923 + device_init_wakeup(&pdev->dev, false); 924 924 925 925 if (!IS_ERR(rtc->clk)) 926 926 clk_disable_unprepare(rtc->clk);

+1 -1

drivers/rtc/rtc-palmas.c

reviewed

··· 287 287 288 288 palmas_rtc->irq = platform_get_irq(pdev, 0); 289 289 290 290 - device_init_wakeup(&pdev->dev, 1); 290 290 + device_init_wakeup(&pdev->dev, true); 291 291 palmas_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name, 292 292 &palmas_rtc_ops, THIS_MODULE); 293 293 if (IS_ERR(palmas_rtc->rtc)) {

+82

drivers/rtc/rtc-pcf2127.c

reviewed

··· 20 20 #include <linux/i2c.h> 21 21 #include <linux/spi/spi.h> 22 22 #include <linux/bcd.h> 23 23 + #include <linux/bitfield.h> 23 24 #include <linux/rtc.h> 24 25 #include <linux/slab.h> 25 26 #include <linux/module.h> ··· 49 48 #define PCF2127_BIT_CTRL3_BLF BIT(2) 50 49 #define PCF2127_BIT_CTRL3_BF BIT(3) 51 50 #define PCF2127_BIT_CTRL3_BTSE BIT(4) 51 51 + #define PCF2127_CTRL3_PM GENMASK(7, 5) 52 52 /* Time and date registers */ 53 53 #define PCF2127_REG_TIME_BASE 0x03 54 54 #define PCF2127_BIT_SC_OSF BIT(7) ··· 328 326 dev_dbg(dev, "clearing STOP bit failed\n"); 329 327 return err; 330 328 } 329 329 + } 330 330 + 331 331 + return 0; 332 332 + } 333 333 + 334 334 + static int pcf2127_param_get(struct device *dev, struct rtc_param *param) 335 335 + { 336 336 + struct pcf2127 *pcf2127 = dev_get_drvdata(dev); 337 337 + u32 value; 338 338 + int ret; 339 339 + 340 340 + switch (param->param) { 341 341 + case RTC_PARAM_BACKUP_SWITCH_MODE: 342 342 + ret = regmap_read(pcf2127->regmap, PCF2127_REG_CTRL3, &value); 343 343 + if (ret < 0) 344 344 + return ret; 345 345 + 346 346 + value = FIELD_GET(PCF2127_CTRL3_PM, value); 347 347 + 348 348 + if (value < 0x3) 349 349 + param->uvalue = RTC_BSM_LEVEL; 350 350 + else if (value < 0x6) 351 351 + param->uvalue = RTC_BSM_DIRECT; 352 352 + else 353 353 + param->uvalue = RTC_BSM_DISABLED; 354 354 + 355 355 + break; 356 356 + 357 357 + default: 358 358 + return -EINVAL; 359 359 + } 360 360 + 361 361 + return 0; 362 362 + } 363 363 + 364 364 + static int pcf2127_param_set(struct device *dev, struct rtc_param *param) 365 365 + { 366 366 + struct pcf2127 *pcf2127 = dev_get_drvdata(dev); 367 367 + u8 mode = 0; 368 368 + u32 value; 369 369 + int ret; 370 370 + 371 371 + switch (param->param) { 372 372 + case RTC_PARAM_BACKUP_SWITCH_MODE: 373 373 + ret = regmap_read(pcf2127->regmap, PCF2127_REG_CTRL3, &value); 374 374 + if (ret < 0) 375 375 + return ret; 376 376 + 377 377 + value = FIELD_GET(PCF2127_CTRL3_PM, value); 378 378 + 379 379 + if (value > 5) 380 380 + value -= 5; 381 381 + else if (value > 2) 382 382 + value -= 3; 383 383 + 384 384 + switch (param->uvalue) { 385 385 + case RTC_BSM_LEVEL: 386 386 + break; 387 387 + case RTC_BSM_DIRECT: 388 388 + mode = 3; 389 389 + break; 390 390 + case RTC_BSM_DISABLED: 391 391 + if (value == 0) 392 392 + value = 1; 393 393 + mode = 5; 394 394 + break; 395 395 + default: 396 396 + return -EINVAL; 397 397 + } 398 398 + 399 399 + return regmap_update_bits(pcf2127->regmap, PCF2127_REG_CTRL3, 400 400 + PCF2127_CTRL3_PM, 401 401 + FIELD_PREP(PCF2127_CTRL3_PM, mode + value)); 402 402 + 403 403 + break; 404 404 + 405 405 + default: 406 406 + return -EINVAL; 331 407 } 332 408 333 409 return 0; ··· 821 741 .read_alarm = pcf2127_rtc_read_alarm, 822 742 .set_alarm = pcf2127_rtc_set_alarm, 823 743 .alarm_irq_enable = pcf2127_rtc_alarm_irq_enable, 744 744 + .param_get = pcf2127_param_get, 745 745 + .param_set = pcf2127_param_set, 824 746 }; 825 747 826 748 /* sysfs interface */

+10 -1

drivers/rtc/rtc-pcf85063.c

reviewed

··· 322 322 static int pcf85063_nvmem_read(void *priv, unsigned int offset, 323 323 void *val, size_t bytes) 324 324 { 325 325 - return regmap_read(priv, PCF85063_REG_RAM, val); 325 325 + unsigned int tmp; 326 326 + int ret; 327 327 + 328 328 + ret = regmap_read(priv, PCF85063_REG_RAM, &tmp); 329 329 + if (ret < 0) 330 330 + return ret; 331 331 + 332 332 + *(u8 *)val = tmp; 333 333 + 334 334 + return 0; 326 335 } 327 336 328 337 static int pcf85063_nvmem_write(void *priv, unsigned int offset,

+1 -1

drivers/rtc/rtc-pic32.c

reviewed

··· 330 330 331 331 pic32_rtc_enable(pdata, 1); 332 332 333 333 - device_init_wakeup(&pdev->dev, 1); 333 333 + device_init_wakeup(&pdev->dev, true); 334 334 335 335 pdata->rtc->ops = &pic32_rtcops; 336 336 pdata->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;

+1 -1

drivers/rtc/rtc-pm8xxx.c

reviewed

··· 503 503 504 504 platform_set_drvdata(pdev, rtc_dd); 505 505 506 506 - device_init_wakeup(&pdev->dev, 1); 506 506 + device_init_wakeup(&pdev->dev, true); 507 507 508 508 rtc_dd->rtc = devm_rtc_allocate_device(&pdev->dev); 509 509 if (IS_ERR(rtc_dd->rtc))

+1 -1

drivers/rtc/rtc-pxa.c

reviewed

··· 360 360 return ret; 361 361 } 362 362 363 363 - device_init_wakeup(dev, 1); 363 363 + device_init_wakeup(dev, true); 364 364 365 365 return 0; 366 366 }

+1 -1

drivers/rtc/rtc-rc5t583.c

reviewed

··· 245 245 dev_err(&pdev->dev, "IRQ is not free.\n"); 246 246 return ret; 247 247 } 248 248 - device_init_wakeup(&pdev->dev, 1); 248 248 + device_init_wakeup(&pdev->dev, true); 249 249 250 250 ricoh_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name, 251 251 &rc5t583_rtc_ops, THIS_MODULE);

+1 -1

drivers/rtc/rtc-rc5t619.c

reviewed

··· 414 414 415 415 } else { 416 416 /* enable wake */ 417 417 - device_init_wakeup(&pdev->dev, 1); 417 417 + device_init_wakeup(&pdev->dev, true); 418 418 enable_irq_wake(rtc->irq); 419 419 } 420 420 } else {

+1 -1

drivers/rtc/rtc-renesas-rtca3.c

reviewed

··· 768 768 if (ret) 769 769 return ret; 770 770 771 771 - device_init_wakeup(&pdev->dev, 1); 771 771 + device_init_wakeup(&pdev->dev, true); 772 772 773 773 priv->rtc_dev = devm_rtc_allocate_device(&pdev->dev); 774 774 if (IS_ERR(priv->rtc_dev))

+1 -1

drivers/rtc/rtc-rk808.c

reviewed

··· 418 418 return ret; 419 419 } 420 420 421 421 - device_init_wakeup(&pdev->dev, 1); 421 421 + device_init_wakeup(&pdev->dev, true); 422 422 423 423 rk808_rtc->rtc = devm_rtc_allocate_device(&pdev->dev); 424 424 if (IS_ERR(rk808_rtc->rtc))

+1 -1

drivers/rtc/rtc-s3c.c

reviewed

··· 456 456 dev_dbg(&pdev->dev, "s3c2410_rtc: RTCCON=%02x\n", 457 457 readw(info->base + S3C2410_RTCCON)); 458 458 459 459 - device_init_wakeup(&pdev->dev, 1); 459 459 + device_init_wakeup(&pdev->dev, true); 460 460 461 461 info->rtc = devm_rtc_allocate_device(&pdev->dev); 462 462 if (IS_ERR(info->rtc)) {

+1 -1

drivers/rtc/rtc-s5m.c

reviewed

··· 729 729 info->irq, ret); 730 730 return ret; 731 731 } 732 732 - device_init_wakeup(&pdev->dev, 1); 732 732 + device_init_wakeup(&pdev->dev, true); 733 733 } 734 734 735 735 return devm_rtc_register_device(info->rtc_dev);

+1 -1

drivers/rtc/rtc-sa1100.c

reviewed

··· 292 292 } 293 293 294 294 platform_set_drvdata(pdev, info); 295 295 - device_init_wakeup(&pdev->dev, 1); 295 295 + device_init_wakeup(&pdev->dev, true); 296 296 297 297 return sa1100_rtc_init(pdev, info); 298 298 }

+2 -2

drivers/rtc/rtc-sc27xx.c

reviewed

··· 613 613 return ret; 614 614 } 615 615 616 616 - device_init_wakeup(&pdev->dev, 1); 616 616 + device_init_wakeup(&pdev->dev, true); 617 617 618 618 rtc->rtc->ops = &sprd_rtc_ops; 619 619 rtc->rtc->range_min = 0; 620 620 rtc->rtc->range_max = 5662310399LL; 621 621 ret = devm_rtc_register_device(rtc->rtc); 622 622 if (ret) { 623 623 - device_init_wakeup(&pdev->dev, 0); 623 623 + device_init_wakeup(&pdev->dev, false); 624 624 return ret; 625 625 } 626 626

+1 -1

drivers/rtc/rtc-sh.c

reviewed

··· 611 611 if (ret) 612 612 goto err_unmap; 613 613 614 614 - device_init_wakeup(&pdev->dev, 1); 614 614 + device_init_wakeup(&pdev->dev, true); 615 615 return 0; 616 616 617 617 err_unmap:

+2 -2

drivers/rtc/rtc-spear.c

reviewed

··· 395 395 goto err_disable_clock; 396 396 397 397 if (!device_can_wakeup(&pdev->dev)) 398 398 - device_init_wakeup(&pdev->dev, 1); 398 398 + device_init_wakeup(&pdev->dev, true); 399 399 400 400 return 0; 401 401 ··· 411 411 412 412 spear_rtc_disable_interrupt(config); 413 413 clk_disable_unprepare(config->clk); 414 414 - device_init_wakeup(&pdev->dev, 0); 414 414 + device_init_wakeup(&pdev->dev, false); 415 415 } 416 416 417 417 #ifdef CONFIG_PM_SLEEP

+7 -15

drivers/rtc/rtc-stm32.c

reviewed

··· 1074 1074 regs = &rtc->data->regs; 1075 1075 1076 1076 if (rtc->data->need_dbp) { 1077 1077 - rtc->dbp = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, 1078 1078 - "st,syscfg"); 1077 1077 + unsigned int args[2]; 1078 1078 + 1079 1079 + rtc->dbp = syscon_regmap_lookup_by_phandle_args(pdev->dev.of_node, 1080 1080 + "st,syscfg", 1081 1081 + 2, args); 1079 1082 if (IS_ERR(rtc->dbp)) { 1080 1083 dev_err(&pdev->dev, "no st,syscfg\n"); 1081 1084 return PTR_ERR(rtc->dbp); 1082 1085 } 1083 1086 1084 1084 - ret = of_property_read_u32_index(pdev->dev.of_node, "st,syscfg", 1085 1085 - 1, &rtc->dbp_reg); 1086 1086 - if (ret) { 1087 1087 - dev_err(&pdev->dev, "can't read DBP register offset\n"); 1088 1088 - return ret; 1089 1089 - } 1090 1090 - 1091 1091 - ret = of_property_read_u32_index(pdev->dev.of_node, "st,syscfg", 1092 1092 - 2, &rtc->dbp_mask); 1093 1093 - if (ret) { 1094 1094 - dev_err(&pdev->dev, "can't read DBP register mask\n"); 1095 1095 - return ret; 1096 1096 - } 1087 1087 + rtc->dbp_reg = args[0]; 1088 1088 + rtc->dbp_mask = args[1]; 1097 1089 } 1098 1090 1099 1091 if (!rtc->data->has_pclk) {

+1 -1

drivers/rtc/rtc-sun6i.c

reviewed

··· 826 826 827 827 clk_prepare_enable(chip->losc); 828 828 829 829 - device_init_wakeup(&pdev->dev, 1); 829 829 + device_init_wakeup(&pdev->dev, true); 830 830 831 831 chip->rtc = devm_rtc_allocate_device(&pdev->dev); 832 832 if (IS_ERR(chip->rtc))

+2 -2

drivers/rtc/rtc-sunplus.c

reviewed

··· 269 269 if (ret) 270 270 goto free_reset_assert; 271 271 272 272 - device_init_wakeup(&plat_dev->dev, 1); 272 272 + device_init_wakeup(&plat_dev->dev, true); 273 273 dev_set_drvdata(&plat_dev->dev, sp_rtc); 274 274 275 275 sp_rtc->rtc = devm_rtc_allocate_device(&plat_dev->dev); ··· 307 307 { 308 308 struct sunplus_rtc *sp_rtc = dev_get_drvdata(&plat_dev->dev); 309 309 310 310 - device_init_wakeup(&plat_dev->dev, 0); 310 310 + device_init_wakeup(&plat_dev->dev, false); 311 311 reset_control_assert(sp_rtc->rstc); 312 312 clk_disable_unprepare(sp_rtc->rtcclk); 313 313 }

+1 -1

drivers/rtc/rtc-tegra.c

reviewed

··· 319 319 writel(0xffffffff, info->base + TEGRA_RTC_REG_INTR_STATUS); 320 320 writel(0, info->base + TEGRA_RTC_REG_INTR_MASK); 321 321 322 322 - device_init_wakeup(&pdev->dev, 1); 322 322 + device_init_wakeup(&pdev->dev, true); 323 323 324 324 ret = devm_request_irq(&pdev->dev, info->irq, tegra_rtc_irq_handler, 325 325 IRQF_TRIGGER_HIGH, dev_name(&pdev->dev),

+1 -1

drivers/rtc/rtc-test.c

reviewed

··· 132 132 break; 133 133 default: 134 134 rtd->rtc->ops = &test_rtc_ops; 135 135 - device_init_wakeup(&plat_dev->dev, 1); 135 135 + device_init_wakeup(&plat_dev->dev, true); 136 136 } 137 137 138 138 timer_setup(&rtd->alarm, test_rtc_alarm_handler, 0);

+1 -1

drivers/rtc/rtc-tps6586x.c

reviewed

··· 241 241 return ret; 242 242 } 243 243 244 244 - device_init_wakeup(&pdev->dev, 1); 244 244 + device_init_wakeup(&pdev->dev, true); 245 245 246 246 platform_set_drvdata(pdev, rtc); 247 247 rtc->rtc = devm_rtc_allocate_device(&pdev->dev);

+1 -1

drivers/rtc/rtc-tps65910.c

reviewed

··· 418 418 tps_rtc->irq = irq; 419 419 if (irq != -1) { 420 420 if (device_property_present(tps65910->dev, "wakeup-source")) 421 421 - device_init_wakeup(&pdev->dev, 1); 421 421 + device_init_wakeup(&pdev->dev, true); 422 422 else 423 423 device_set_wakeup_capable(&pdev->dev, 1); 424 424 } else {

+1 -1

drivers/rtc/rtc-tps6594.c

reviewed

··· 37 37 #define MAX_OFFSET (277774) 38 38 39 39 // Number of ticks per hour 40 40 - #define TICKS_PER_HOUR (32768 * 3600) 40 40 + #define TICKS_PER_HOUR (32768 * 3600LL) 41 41 42 42 // Multiplier for ppb conversions 43 43 #define PPB_MULT NANO

+1 -1

drivers/rtc/rtc-twl.c

reviewed

··· 572 572 return ret; 573 573 574 574 platform_set_drvdata(pdev, twl_rtc); 575 575 - device_init_wakeup(&pdev->dev, 1); 575 575 + device_init_wakeup(&pdev->dev, true); 576 576 577 577 twl_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name, 578 578 &twl_rtc_ops, THIS_MODULE);

+1 -1

drivers/rtc/rtc-wm831x.c

reviewed

··· 420 420 if (ret & WM831X_RTC_ALM_ENA) 421 421 wm831x_rtc->alarm_enabled = 1; 422 422 423 423 - device_init_wakeup(&pdev->dev, 1); 423 423 + device_init_wakeup(&pdev->dev, true); 424 424 425 425 wm831x_rtc->rtc = devm_rtc_allocate_device(&pdev->dev); 426 426 if (IS_ERR(wm831x_rtc->rtc))

+1 -1

drivers/rtc/rtc-wm8350.c

reviewed

··· 420 420 } 421 421 } 422 422 423 423 - device_init_wakeup(&pdev->dev, 1); 423 423 + device_init_wakeup(&pdev->dev, true); 424 424 425 425 wm_rtc->rtc = devm_rtc_device_register(&pdev->dev, "wm8350", 426 426 &wm8350_rtc_ops, THIS_MODULE);

+2 -2

drivers/rtc/rtc-xgene.c

reviewed

··· 174 174 /* Turn on the clock and the crystal */ 175 175 writel(RTC_CCR_EN, pdata->csr_base + RTC_CCR); 176 176 177 177 - ret = device_init_wakeup(&pdev->dev, 1); 177 177 + ret = device_init_wakeup(&pdev->dev, true); 178 178 if (ret) { 179 179 clk_disable_unprepare(pdata->clk); 180 180 return ret; ··· 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); 200 200 + device_init_wakeup(&pdev->dev, false); 201 201 clk_disable_unprepare(pdata->clk); 202 202 } 203 203

+4 -4

drivers/rtc/rtc-zynqmp.c

reviewed

··· 318 318 return ret; 319 319 } 320 320 321 321 - /* Getting the rtc_clk info */ 322 322 - xrtcdev->rtc_clk = devm_clk_get_optional(&pdev->dev, "rtc_clk"); 321 321 + /* Getting the rtc info */ 322 322 + xrtcdev->rtc_clk = devm_clk_get_optional(&pdev->dev, "rtc"); 323 323 if (IS_ERR(xrtcdev->rtc_clk)) { 324 324 if (PTR_ERR(xrtcdev->rtc_clk) != -EPROBE_DEFER) 325 325 dev_warn(&pdev->dev, "Device clock not found.\n"); ··· 337 337 338 338 xlnx_init_rtc(xrtcdev); 339 339 340 340 - device_init_wakeup(&pdev->dev, 1); 340 340 + device_init_wakeup(&pdev->dev, true); 341 341 342 342 return devm_rtc_register_device(xrtcdev->rtc); 343 343 } ··· 345 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); 348 348 + device_init_wakeup(&pdev->dev, false); 349 349 } 350 350 351 351 static int __maybe_unused xlnx_rtc_suspend(struct device *dev)