Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'rtc-6.16-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/abelloni/linux
Pull RTC fixes from Alexandre Belloni:
"Some fixes for 6.16. The cmos one is important for PREEMPT_RT. I've
also added the s5m changes as they had a dependency on the MFD pull
request that was included in 6.16-rc1 and we didn't synchronize before
the merge window and they won't hurt.
- cmos: use spin_lock_irqsave in cmos_interrupt
- pcf2127: fix SPI command byte for PCF2131
- s5m: add S2MPG10 support"
* tag 'rtc-6.16-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/abelloni/linux:
rtc: pcf2127: add missing semicolon after statement
rtc: pcf2127: fix SPI command byte for PCF2131
rtc: cmos: use spin_lock_irqsave in cmos_interrupt
rtc: s5m: replace open-coded read/modify/write registers with regmap helpers
rtc: s5m: replace regmap_update_bits with regmap_clear/set_bits
rtc: s5m: switch to devm_device_init_wakeup
rtc: s5m: fix a typo: peding -> pending
rtc: s5m: add support for S2MPG10 RTC
rtc: s5m: prepare for external regmap
rtc: s5m: cache device type during probe
+140
-74
+6
-4
drivers/rtc/rtc-cmos.c
+6
-4
drivers/rtc/rtc-cmos.c
···
692
692
{
693
693
u8 irqstat;
694
694
u8 rtc_control;
695
+
unsigned long flags;
695
696
696
-
spin_lock(&rtc_lock);
697
+
/* We cannot use spin_lock() here, as cmos_interrupt() is also called
698
+
* in a non-irq context.
699
+
*/
700
+
spin_lock_irqsave(&rtc_lock, flags);
697
701
698
702
/* When the HPET interrupt handler calls us, the interrupt
699
703
* status is passed as arg1 instead of the irq number. But
···
731
727
hpet_mask_rtc_irq_bit(RTC_AIE);
732
728
CMOS_READ(RTC_INTR_FLAGS);
733
729
}
734
-
spin_unlock(&rtc_lock);
730
+
spin_unlock_irqrestore(&rtc_lock, flags);
735
731
736
732
if (is_intr(irqstat)) {
737
733
rtc_update_irq(p, 1, irqstat);
···
1299
1295
* ACK the rtc irq here
1300
1296
*/
1301
1297
if (t_now >= cmos->alarm_expires && cmos_use_acpi_alarm()) {
1302
-
local_irq_disable();
1303
1298
cmos_interrupt(0, (void *)cmos->rtc);
1304
-
local_irq_enable();
1305
1299
return;
1306
1300
}
1307
1301
+6
-1
drivers/rtc/rtc-pcf2127.c
+6
-1
drivers/rtc/rtc-pcf2127.c
···
1538
1538
variant = &pcf21xx_cfg[type];
1539
1539
}
1540
1540
1541
-
config.max_register = variant->max_register,
1541
+
if (variant->type == PCF2131) {
1542
+
config.read_flag_mask = 0x0;
1543
+
config.write_flag_mask = 0x0;
1544
+
}
1545
+
1546
+
config.max_register = variant->max_register;
1542
1547
1543
1548
regmap = devm_regmap_init_spi(spi, &config);
1544
1549
if (IS_ERR(regmap)) {
+128
-69
drivers/rtc/rtc-s5m.c
+128
-69
drivers/rtc/rtc-s5m.c
···
10
10
#include <linux/module.h>
11
11
#include <linux/i2c.h>
12
12
#include <linux/bcd.h>
13
+
#include <linux/reboot.h>
13
14
#include <linux/regmap.h>
14
15
#include <linux/rtc.h>
15
16
#include <linux/platform_device.h>
···
54
53
* Device | Write time | Read time | Write alarm
55
54
* =================================================
56
55
* S5M8767 | UDR + TIME | | UDR
56
+
* S2MPG10 | WUDR | RUDR | AUDR
57
57
* S2MPS11/14 | WUDR | RUDR | WUDR + RUDR
58
58
* S2MPS13 | WUDR | RUDR | WUDR + AUDR
59
59
* S2MPS15 | WUDR | RUDR | AUDR
···
99
97
.read_time_udr_mask = 0, /* Not needed */
100
98
.write_time_udr_mask = S5M_RTC_UDR_MASK | S5M_RTC_TIME_EN_MASK,
101
99
.write_alarm_udr_mask = S5M_RTC_UDR_MASK,
100
+
};
101
+
102
+
/* Register map for S2MPG10 */
103
+
static const struct s5m_rtc_reg_config s2mpg10_rtc_regs = {
104
+
.regs_count = 7,
105
+
.time = S2MPG10_RTC_SEC,
106
+
.ctrl = S2MPG10_RTC_CTRL,
107
+
.alarm0 = S2MPG10_RTC_A0SEC,
108
+
.alarm1 = S2MPG10_RTC_A1SEC,
109
+
.udr_update = S2MPG10_RTC_UPDATE,
110
+
.autoclear_udr_mask = S2MPS15_RTC_WUDR_MASK | S2MPS15_RTC_AUDR_MASK,
111
+
.read_time_udr_mask = S2MPS_RTC_RUDR_MASK,
112
+
.write_time_udr_mask = S2MPS15_RTC_WUDR_MASK,
113
+
.write_alarm_udr_mask = S2MPS15_RTC_AUDR_MASK,
102
114
};
103
115
104
116
/* Register map for S2MPS13 */
···
243
227
return ret;
244
228
}
245
229
246
-
static int s5m_check_peding_alarm_interrupt(struct s5m_rtc_info *info,
247
-
struct rtc_wkalrm *alarm)
230
+
static int s5m_check_pending_alarm_interrupt(struct s5m_rtc_info *info,
231
+
struct rtc_wkalrm *alarm)
248
232
{
249
233
int ret;
250
234
unsigned int val;
···
254
238
ret = regmap_read(info->regmap, S5M_RTC_STATUS, &val);
255
239
val &= S5M_ALARM0_STATUS;
256
240
break;
241
+
case S2MPG10:
257
242
case S2MPS15X:
258
243
case S2MPS14X:
259
244
case S2MPS13X:
···
279
262
static int s5m8767_rtc_set_time_reg(struct s5m_rtc_info *info)
280
263
{
281
264
int ret;
282
-
unsigned int data;
283
265
284
-
ret = regmap_read(info->regmap, info->regs->udr_update, &data);
285
-
if (ret < 0) {
286
-
dev_err(info->dev, "failed to read update reg(%d)\n", ret);
287
-
return ret;
288
-
}
289
-
290
-
data |= info->regs->write_time_udr_mask;
291
-
292
-
ret = regmap_write(info->regmap, info->regs->udr_update, data);
266
+
ret = regmap_set_bits(info->regmap, info->regs->udr_update,
267
+
info->regs->write_time_udr_mask);
293
268
if (ret < 0) {
294
269
dev_err(info->dev, "failed to write update reg(%d)\n", ret);
295
270
return ret;
···
295
286
static int s5m8767_rtc_set_alarm_reg(struct s5m_rtc_info *info)
296
287
{
297
288
int ret;
298
-
unsigned int data;
289
+
unsigned int udr_mask;
299
290
300
-
ret = regmap_read(info->regmap, info->regs->udr_update, &data);
301
-
if (ret < 0) {
302
-
dev_err(info->dev, "%s: fail to read update reg(%d)\n",
303
-
__func__, ret);
304
-
return ret;
305
-
}
306
-
307
-
data |= info->regs->write_alarm_udr_mask;
291
+
udr_mask = info->regs->write_alarm_udr_mask;
308
292
switch (info->device_type) {
309
293
case S5M8767X:
310
-
data &= ~S5M_RTC_TIME_EN_MASK;
294
+
udr_mask |= S5M_RTC_TIME_EN_MASK;
311
295
break;
296
+
case S2MPG10:
312
297
case S2MPS15X:
313
298
case S2MPS14X:
314
299
case S2MPS13X:
···
312
309
return -EINVAL;
313
310
}
314
311
315
-
ret = regmap_write(info->regmap, info->regs->udr_update, data);
312
+
ret = regmap_update_bits(info->regmap, info->regs->udr_update,
313
+
udr_mask, info->regs->write_alarm_udr_mask);
316
314
if (ret < 0) {
317
315
dev_err(info->dev, "%s: fail to write update reg(%d)\n",
318
316
__func__, ret);
···
324
320
325
321
/* On S2MPS13 the AUDR is not auto-cleared */
326
322
if (info->device_type == S2MPS13X)
327
-
regmap_update_bits(info->regmap, info->regs->udr_update,
328
-
S2MPS13_RTC_AUDR_MASK, 0);
323
+
regmap_clear_bits(info->regmap, info->regs->udr_update,
324
+
S2MPS13_RTC_AUDR_MASK);
329
325
330
326
return ret;
331
327
}
···
337
333
int ret;
338
334
339
335
if (info->regs->read_time_udr_mask) {
340
-
ret = regmap_update_bits(info->regmap,
341
-
info->regs->udr_update,
342
-
info->regs->read_time_udr_mask,
343
-
info->regs->read_time_udr_mask);
336
+
ret = regmap_set_bits(info->regmap, info->regs->udr_update,
337
+
info->regs->read_time_udr_mask);
344
338
if (ret) {
345
339
dev_err(dev,
346
340
"Failed to prepare registers for time reading: %d\n",
···
353
351
354
352
switch (info->device_type) {
355
353
case S5M8767X:
354
+
case S2MPG10:
356
355
case S2MPS15X:
357
356
case S2MPS14X:
358
357
case S2MPS13X:
···
377
374
378
375
switch (info->device_type) {
379
376
case S5M8767X:
377
+
case S2MPG10:
380
378
case S2MPS15X:
381
379
case S2MPS14X:
382
380
case S2MPS13X:
···
415
411
416
412
switch (info->device_type) {
417
413
case S5M8767X:
414
+
case S2MPG10:
418
415
case S2MPS15X:
419
416
case S2MPS14X:
420
417
case S2MPS13X:
···
435
430
436
431
dev_dbg(dev, "%s: %ptR(%d)\n", __func__, &alrm->time, alrm->time.tm_wday);
437
432
438
-
return s5m_check_peding_alarm_interrupt(info, alrm);
433
+
return s5m_check_pending_alarm_interrupt(info, alrm);
439
434
}
440
435
441
436
static int s5m_rtc_stop_alarm(struct s5m_rtc_info *info)
···
454
449
455
450
switch (info->device_type) {
456
451
case S5M8767X:
452
+
case S2MPG10:
457
453
case S2MPS15X:
458
454
case S2MPS14X:
459
455
case S2MPS13X:
···
493
487
494
488
switch (info->device_type) {
495
489
case S5M8767X:
490
+
case S2MPG10:
496
491
case S2MPS15X:
497
492
case S2MPS14X:
498
493
case S2MPS13X:
···
531
524
532
525
switch (info->device_type) {
533
526
case S5M8767X:
527
+
case S2MPG10:
534
528
case S2MPS15X:
535
529
case S2MPS14X:
536
530
case S2MPS13X:
···
612
604
ret = regmap_raw_write(info->regmap, S5M_ALARM0_CONF, data, 2);
613
605
break;
614
606
607
+
case S2MPG10:
615
608
case S2MPS15X:
616
609
case S2MPS14X:
617
610
case S2MPS13X:
···
643
634
return ret;
644
635
}
645
636
637
+
static int s5m_rtc_restart_s2mpg10(struct sys_off_data *data)
638
+
{
639
+
struct s5m_rtc_info *info = data->cb_data;
640
+
int ret;
641
+
642
+
if (data->mode != REBOOT_COLD && data->mode != REBOOT_HARD)
643
+
return NOTIFY_DONE;
644
+
645
+
/*
646
+
* Arm watchdog with maximum timeout (2 seconds), and perform full reset
647
+
* on expiry.
648
+
*/
649
+
ret = regmap_set_bits(info->regmap, S2MPG10_RTC_WTSR,
650
+
(S2MPG10_WTSR_COLDTIMER | S2MPG10_WTSR_COLDRST
651
+
| S2MPG10_WTSR_WTSRT | S2MPG10_WTSR_WTSR_EN));
652
+
653
+
return ret ? NOTIFY_BAD : NOTIFY_DONE;
654
+
}
655
+
646
656
static int s5m_rtc_probe(struct platform_device *pdev)
647
657
{
648
658
struct sec_pmic_dev *s5m87xx = dev_get_drvdata(pdev->dev.parent);
659
+
enum sec_device_type device_type =
660
+
platform_get_device_id(pdev)->driver_data;
649
661
struct s5m_rtc_info *info;
650
-
struct i2c_client *i2c;
651
-
const struct regmap_config *regmap_cfg;
652
662
int ret, alarm_irq;
653
663
654
664
info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
655
665
if (!info)
656
666
return -ENOMEM;
657
667
658
-
switch (platform_get_device_id(pdev)->driver_data) {
659
-
case S2MPS15X:
660
-
regmap_cfg = &s2mps14_rtc_regmap_config;
661
-
info->regs = &s2mps15_rtc_regs;
662
-
alarm_irq = S2MPS14_IRQ_RTCA0;
663
-
break;
664
-
case S2MPS14X:
665
-
regmap_cfg = &s2mps14_rtc_regmap_config;
666
-
info->regs = &s2mps14_rtc_regs;
667
-
alarm_irq = S2MPS14_IRQ_RTCA0;
668
-
break;
669
-
case S2MPS13X:
670
-
regmap_cfg = &s2mps14_rtc_regmap_config;
671
-
info->regs = &s2mps13_rtc_regs;
672
-
alarm_irq = S2MPS14_IRQ_RTCA0;
673
-
break;
674
-
case S5M8767X:
675
-
regmap_cfg = &s5m_rtc_regmap_config;
676
-
info->regs = &s5m_rtc_regs;
677
-
alarm_irq = S5M8767_IRQ_RTCA1;
678
-
break;
679
-
default:
668
+
info->regmap = dev_get_regmap(pdev->dev.parent, "rtc");
669
+
if (!info->regmap) {
670
+
const struct regmap_config *regmap_cfg;
671
+
struct i2c_client *i2c;
672
+
673
+
switch (device_type) {
674
+
case S2MPS15X:
675
+
regmap_cfg = &s2mps14_rtc_regmap_config;
676
+
info->regs = &s2mps15_rtc_regs;
677
+
alarm_irq = S2MPS14_IRQ_RTCA0;
678
+
break;
679
+
case S2MPS14X:
680
+
regmap_cfg = &s2mps14_rtc_regmap_config;
681
+
info->regs = &s2mps14_rtc_regs;
682
+
alarm_irq = S2MPS14_IRQ_RTCA0;
683
+
break;
684
+
case S2MPS13X:
685
+
regmap_cfg = &s2mps14_rtc_regmap_config;
686
+
info->regs = &s2mps13_rtc_regs;
687
+
alarm_irq = S2MPS14_IRQ_RTCA0;
688
+
break;
689
+
case S5M8767X:
690
+
regmap_cfg = &s5m_rtc_regmap_config;
691
+
info->regs = &s5m_rtc_regs;
692
+
alarm_irq = S5M8767_IRQ_RTCA1;
693
+
break;
694
+
default:
695
+
return dev_err_probe(&pdev->dev, -ENODEV,
696
+
"Unsupported device type %d\n",
697
+
device_type);
698
+
}
699
+
700
+
i2c = devm_i2c_new_dummy_device(&pdev->dev,
701
+
s5m87xx->i2c->adapter,
702
+
RTC_I2C_ADDR);
703
+
if (IS_ERR(i2c))
704
+
return dev_err_probe(&pdev->dev, PTR_ERR(i2c),
705
+
"Failed to allocate I2C\n");
706
+
707
+
info->regmap = devm_regmap_init_i2c(i2c, regmap_cfg);
708
+
if (IS_ERR(info->regmap))
709
+
return dev_err_probe(&pdev->dev, PTR_ERR(info->regmap),
710
+
"Failed to allocate regmap\n");
711
+
} else if (device_type == S2MPG10) {
712
+
info->regs = &s2mpg10_rtc_regs;
713
+
alarm_irq = S2MPG10_IRQ_RTCA0;
714
+
} else {
680
715
return dev_err_probe(&pdev->dev, -ENODEV,
681
-
"Device type %lu is not supported by RTC driver\n",
682
-
platform_get_device_id(pdev)->driver_data);
716
+
"Unsupported device type %d\n",
717
+
device_type);
683
718
}
684
-
685
-
i2c = devm_i2c_new_dummy_device(&pdev->dev, s5m87xx->i2c->adapter,
686
-
RTC_I2C_ADDR);
687
-
if (IS_ERR(i2c))
688
-
return dev_err_probe(&pdev->dev, PTR_ERR(i2c),
689
-
"Failed to allocate I2C for RTC\n");
690
-
691
-
info->regmap = devm_regmap_init_i2c(i2c, regmap_cfg);
692
-
if (IS_ERR(info->regmap))
693
-
return dev_err_probe(&pdev->dev, PTR_ERR(info->regmap),
694
-
"Failed to allocate RTC register map\n");
695
719
696
720
info->dev = &pdev->dev;
697
721
info->s5m87xx = s5m87xx;
698
-
info->device_type = platform_get_device_id(pdev)->driver_data;
722
+
info->device_type = device_type;
699
723
700
724
if (s5m87xx->irq_data) {
701
725
info->irq = regmap_irq_get_virq(s5m87xx->irq_data, alarm_irq);
···
763
721
return dev_err_probe(&pdev->dev, ret,
764
722
"Failed to request alarm IRQ %d\n",
765
723
info->irq);
766
-
device_init_wakeup(&pdev->dev, true);
724
+
725
+
ret = devm_device_init_wakeup(&pdev->dev);
726
+
if (ret < 0)
727
+
return dev_err_probe(&pdev->dev, ret,
728
+
"Failed to init wakeup\n");
729
+
}
730
+
731
+
if (of_device_is_system_power_controller(pdev->dev.parent->of_node) &&
732
+
info->device_type == S2MPG10) {
733
+
ret = devm_register_sys_off_handler(&pdev->dev,
734
+
SYS_OFF_MODE_RESTART,
735
+
SYS_OFF_PRIO_HIGH + 1,
736
+
s5m_rtc_restart_s2mpg10,
737
+
info);
738
+
if (ret)
739
+
return dev_err_probe(&pdev->dev, ret,
740
+
"Failed to register restart handler\n");
767
741
}
768
742
769
743
return devm_rtc_register_device(info->rtc_dev);
···
813
755
814
756
static const struct platform_device_id s5m_rtc_id[] = {
815
757
{ "s5m-rtc", S5M8767X },
758
+
{ "s2mpg10-rtc", S2MPG10 },
816
759
{ "s2mps13-rtc", S2MPS13X },
817
760
{ "s2mps14-rtc", S2MPS14X },
818
761
{ "s2mps15-rtc", S2MPS15X },