Commit 4b424a3f authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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
parents d0b3b7b2 08d82d0c

drivers/rtc/rtc-cmos.c

+6 −4
Original line number Diff line number Diff line
@@ -692,8 +692,12 @@ static irqreturn_t cmos_interrupt(int irq, void *p) 
{

	u8		irqstat;

	u8		rtc_control;

	unsigned long	flags;



	spin_lock(&rtc_lock);

	/* We cannot use spin_lock() here, as cmos_interrupt() is also called

	 * in a non-irq context.

	 */

	spin_lock_irqsave(&rtc_lock, flags);



	/* When the HPET interrupt handler calls us, the interrupt

	 * status is passed as arg1 instead of the irq number.  But
@@ -727,7 +731,7 @@ static irqreturn_t cmos_interrupt(int irq, void *p) 
			hpet_mask_rtc_irq_bit(RTC_AIE);

		CMOS_READ(RTC_INTR_FLAGS);

	}

	spin_unlock(&rtc_lock);

	spin_unlock_irqrestore(&rtc_lock, flags);



	if (is_intr(irqstat)) {

		rtc_update_irq(p, 1, irqstat);
@@ -1295,9 +1299,7 @@ static void cmos_check_wkalrm(struct device *dev) 
	 * ACK the rtc irq here

	 */

	if (t_now >= cmos->alarm_expires && cmos_use_acpi_alarm()) {

		local_irq_disable();

		cmos_interrupt(0, (void *)cmos->rtc);

		local_irq_enable();

		return;

	}

drivers/rtc/rtc-pcf2127.c

+6 −1
Original line number Diff line number Diff line
@@ -1538,7 +1538,12 @@ static int pcf2127_spi_probe(struct spi_device *spi) 
		variant = &pcf21xx_cfg[type];

	}



	config.max_register = variant->max_register,

	if (variant->type == PCF2131) {

		config.read_flag_mask = 0x0;

		config.write_flag_mask = 0x0;

	}



	config.max_register = variant->max_register;



	regmap = devm_regmap_init_spi(spi, &config);

	if (IS_ERR(regmap)) {

drivers/rtc/rtc-s5m.c

+128 −69
Original line number Diff line number Diff line
@@ -10,6 +10,7 @@ 
#include <linux/module.h>

#include <linux/i2c.h>

#include <linux/bcd.h>

#include <linux/reboot.h>

#include <linux/regmap.h>

#include <linux/rtc.h>

#include <linux/platform_device.h>
@@ -53,6 +54,7 @@ enum { 
 * Device     | Write time | Read time | Write alarm

 * =================================================

 * S5M8767    | UDR + TIME |           | UDR

 * S2MPG10    | WUDR       | RUDR      | AUDR

 * S2MPS11/14 | WUDR       | RUDR      | WUDR + RUDR

 * S2MPS13    | WUDR       | RUDR      | WUDR + AUDR

 * S2MPS15    | WUDR       | RUDR      | AUDR
@@ -99,6 +101,20 @@ static const struct s5m_rtc_reg_config s5m_rtc_regs = { 
	.write_alarm_udr_mask	= S5M_RTC_UDR_MASK,

};



/* Register map for S2MPG10 */

static const struct s5m_rtc_reg_config s2mpg10_rtc_regs = {

	.regs_count		= 7,

	.time			= S2MPG10_RTC_SEC,

	.ctrl			= S2MPG10_RTC_CTRL,

	.alarm0			= S2MPG10_RTC_A0SEC,

	.alarm1			= S2MPG10_RTC_A1SEC,

	.udr_update		= S2MPG10_RTC_UPDATE,

	.autoclear_udr_mask	= S2MPS15_RTC_WUDR_MASK | S2MPS15_RTC_AUDR_MASK,

	.read_time_udr_mask	= S2MPS_RTC_RUDR_MASK,

	.write_time_udr_mask	= S2MPS15_RTC_WUDR_MASK,

	.write_alarm_udr_mask	= S2MPS15_RTC_AUDR_MASK,

};



/* Register map for S2MPS13 */

static const struct s5m_rtc_reg_config s2mps13_rtc_regs = {

	.regs_count		= 7,
@@ -227,7 +243,7 @@ static int s5m8767_wait_for_udr_update(struct s5m_rtc_info *info) 
	return ret;

}



static int s5m_check_peding_alarm_interrupt(struct s5m_rtc_info *info,

static int s5m_check_pending_alarm_interrupt(struct s5m_rtc_info *info,

					     struct rtc_wkalrm *alarm)

{

	int ret;
@@ -238,6 +254,7 @@ static int s5m_check_peding_alarm_interrupt(struct s5m_rtc_info *info, 
		ret = regmap_read(info->regmap, S5M_RTC_STATUS, &val);

		val &= S5M_ALARM0_STATUS;

		break;

	case S2MPG10:

	case S2MPS15X:

	case S2MPS14X:

	case S2MPS13X:
@@ -262,17 +279,9 @@ static int s5m_check_peding_alarm_interrupt(struct s5m_rtc_info *info, 
static int s5m8767_rtc_set_time_reg(struct s5m_rtc_info *info)

{

	int ret;

	unsigned int data;



	ret = regmap_read(info->regmap, info->regs->udr_update, &data);

	if (ret < 0) {

		dev_err(info->dev, "failed to read update reg(%d)\n", ret);

		return ret;

	}



	data |= info->regs->write_time_udr_mask;



	ret = regmap_write(info->regmap, info->regs->udr_update, data);

	ret = regmap_set_bits(info->regmap, info->regs->udr_update,

			      info->regs->write_time_udr_mask);

	if (ret < 0) {

		dev_err(info->dev, "failed to write update reg(%d)\n", ret);

		return ret;
@@ -286,20 +295,14 @@ static int s5m8767_rtc_set_time_reg(struct s5m_rtc_info *info) 
static int s5m8767_rtc_set_alarm_reg(struct s5m_rtc_info *info)

{

	int ret;

	unsigned int data;

	unsigned int udr_mask;



	ret = regmap_read(info->regmap, info->regs->udr_update, &data);

	if (ret < 0) {

		dev_err(info->dev, "%s: fail to read update reg(%d)\n",

			__func__, ret);

		return ret;

	}



	data |= info->regs->write_alarm_udr_mask;

	udr_mask = info->regs->write_alarm_udr_mask;

	switch (info->device_type) {

	case S5M8767X:

		data &= ~S5M_RTC_TIME_EN_MASK;

		udr_mask |= S5M_RTC_TIME_EN_MASK;

		break;

	case S2MPG10:

	case S2MPS15X:

	case S2MPS14X:

	case S2MPS13X:
@@ -309,7 +312,8 @@ static int s5m8767_rtc_set_alarm_reg(struct s5m_rtc_info *info) 
		return -EINVAL;

	}



	ret = regmap_write(info->regmap, info->regs->udr_update, data);

	ret = regmap_update_bits(info->regmap, info->regs->udr_update,

				 udr_mask, info->regs->write_alarm_udr_mask);

	if (ret < 0) {

		dev_err(info->dev, "%s: fail to write update reg(%d)\n",

			__func__, ret);
@@ -320,8 +324,8 @@ static int s5m8767_rtc_set_alarm_reg(struct s5m_rtc_info *info) 


	/* On S2MPS13 the AUDR is not auto-cleared */

	if (info->device_type == S2MPS13X)

		regmap_update_bits(info->regmap, info->regs->udr_update,

				   S2MPS13_RTC_AUDR_MASK, 0);

		regmap_clear_bits(info->regmap, info->regs->udr_update,

				  S2MPS13_RTC_AUDR_MASK);



	return ret;

}
@@ -333,9 +337,7 @@ static int s5m_rtc_read_time(struct device *dev, struct rtc_time *tm) 
	int ret;



	if (info->regs->read_time_udr_mask) {

		ret = regmap_update_bits(info->regmap,

				info->regs->udr_update,

				info->regs->read_time_udr_mask,

		ret = regmap_set_bits(info->regmap, info->regs->udr_update,

				      info->regs->read_time_udr_mask);

		if (ret) {

			dev_err(dev,
@@ -351,6 +353,7 @@ static int s5m_rtc_read_time(struct device *dev, struct rtc_time *tm) 


	switch (info->device_type) {

	case S5M8767X:

	case S2MPG10:

	case S2MPS15X:

	case S2MPS14X:

	case S2MPS13X:
@@ -374,6 +377,7 @@ static int s5m_rtc_set_time(struct device *dev, struct rtc_time *tm) 


	switch (info->device_type) {

	case S5M8767X:

	case S2MPG10:

	case S2MPS15X:

	case S2MPS14X:

	case S2MPS13X:
@@ -411,6 +415,7 @@ static int s5m_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm) 


	switch (info->device_type) {

	case S5M8767X:

	case S2MPG10:

	case S2MPS15X:

	case S2MPS14X:

	case S2MPS13X:
@@ -430,7 +435,7 @@ static int s5m_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm) 


	dev_dbg(dev, "%s: %ptR(%d)\n", __func__, &alrm->time, alrm->time.tm_wday);



	return s5m_check_peding_alarm_interrupt(info, alrm);

	return s5m_check_pending_alarm_interrupt(info, alrm);

}



static int s5m_rtc_stop_alarm(struct s5m_rtc_info *info)
@@ -449,6 +454,7 @@ static int s5m_rtc_stop_alarm(struct s5m_rtc_info *info) 


	switch (info->device_type) {

	case S5M8767X:

	case S2MPG10:

	case S2MPS15X:

	case S2MPS14X:

	case S2MPS13X:
@@ -487,6 +493,7 @@ static int s5m_rtc_start_alarm(struct s5m_rtc_info *info) 


	switch (info->device_type) {

	case S5M8767X:

	case S2MPG10:

	case S2MPS15X:

	case S2MPS14X:

	case S2MPS13X:
@@ -524,6 +531,7 @@ static int s5m_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm) 


	switch (info->device_type) {

	case S5M8767X:

	case S2MPG10:

	case S2MPS15X:

	case S2MPS14X:

	case S2MPS13X:
@@ -604,6 +612,7 @@ static int s5m8767_rtc_init_reg(struct s5m_rtc_info *info) 
		ret = regmap_raw_write(info->regmap, S5M_ALARM0_CONF, data, 2);

		break;



	case S2MPG10:

	case S2MPS15X:

	case S2MPS14X:

	case S2MPS13X:
@@ -634,19 +643,43 @@ static int s5m8767_rtc_init_reg(struct s5m_rtc_info *info) 
	return ret;

}



static int s5m_rtc_restart_s2mpg10(struct sys_off_data *data)

{

	struct s5m_rtc_info *info = data->cb_data;

	int ret;



	if (data->mode != REBOOT_COLD && data->mode != REBOOT_HARD)

		return NOTIFY_DONE;



	/*

	 * Arm watchdog with maximum timeout (2 seconds), and perform full reset

	 * on expiry.

	 */

	ret = regmap_set_bits(info->regmap, S2MPG10_RTC_WTSR,

			      (S2MPG10_WTSR_COLDTIMER | S2MPG10_WTSR_COLDRST

			       | S2MPG10_WTSR_WTSRT | S2MPG10_WTSR_WTSR_EN));



	return ret ? NOTIFY_BAD : NOTIFY_DONE;

}



static int s5m_rtc_probe(struct platform_device *pdev)

{

	struct sec_pmic_dev *s5m87xx = dev_get_drvdata(pdev->dev.parent);

	enum sec_device_type device_type =

		platform_get_device_id(pdev)->driver_data;

	struct s5m_rtc_info *info;

	struct i2c_client *i2c;

	const struct regmap_config *regmap_cfg;

	int ret, alarm_irq;



	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);

	if (!info)

		return -ENOMEM;



	switch (platform_get_device_id(pdev)->driver_data) {

	info->regmap = dev_get_regmap(pdev->dev.parent, "rtc");

	if (!info->regmap) {

		const struct regmap_config *regmap_cfg;

		struct i2c_client *i2c;



		switch (device_type) {

		case S2MPS15X:

			regmap_cfg = &s2mps14_rtc_regmap_config;

			info->regs = &s2mps15_rtc_regs;
@@ -669,24 +702,33 @@ static int s5m_rtc_probe(struct platform_device *pdev) 
			break;

		default:

			return dev_err_probe(&pdev->dev, -ENODEV,

				     "Device type %lu is not supported by RTC driver\n",

				     platform_get_device_id(pdev)->driver_data);

					     "Unsupported device type %d\n",

					     device_type);

		}



	i2c = devm_i2c_new_dummy_device(&pdev->dev, s5m87xx->i2c->adapter,

		i2c = devm_i2c_new_dummy_device(&pdev->dev,

						s5m87xx->i2c->adapter,

						RTC_I2C_ADDR);

		if (IS_ERR(i2c))

			return dev_err_probe(&pdev->dev, PTR_ERR(i2c),

				     "Failed to allocate I2C for RTC\n");

					     "Failed to allocate I2C\n");



		info->regmap = devm_regmap_init_i2c(i2c, regmap_cfg);

		if (IS_ERR(info->regmap))

			return dev_err_probe(&pdev->dev, PTR_ERR(info->regmap),

				     "Failed to allocate RTC register map\n");

					     "Failed to allocate regmap\n");

	} else if (device_type == S2MPG10) {

		info->regs = &s2mpg10_rtc_regs;

		alarm_irq = S2MPG10_IRQ_RTCA0;

	} else {

		return dev_err_probe(&pdev->dev, -ENODEV,

				     "Unsupported device type %d\n",

				     device_type);

	}



	info->dev = &pdev->dev;

	info->s5m87xx = s5m87xx;

	info->device_type = platform_get_device_id(pdev)->driver_data;

	info->device_type = device_type;



	if (s5m87xx->irq_data) {

		info->irq = regmap_irq_get_virq(s5m87xx->irq_data, alarm_irq);
@@ -721,7 +763,23 @@ static int s5m_rtc_probe(struct platform_device *pdev) 
			return dev_err_probe(&pdev->dev, ret,

					     "Failed to request alarm IRQ %d\n",

					     info->irq);

		device_init_wakeup(&pdev->dev, true);



		ret = devm_device_init_wakeup(&pdev->dev);

		if (ret < 0)

			return dev_err_probe(&pdev->dev, ret,

					     "Failed to init wakeup\n");

	}



	if (of_device_is_system_power_controller(pdev->dev.parent->of_node) &&

	    info->device_type == S2MPG10) {

		ret = devm_register_sys_off_handler(&pdev->dev,

						    SYS_OFF_MODE_RESTART,

						    SYS_OFF_PRIO_HIGH + 1,

						    s5m_rtc_restart_s2mpg10,

						    info);

		if (ret)

			return dev_err_probe(&pdev->dev, ret,

				       "Failed to register restart handler\n");

	}



	return devm_rtc_register_device(info->rtc_dev);
@@ -755,6 +813,7 @@ static SIMPLE_DEV_PM_OPS(s5m_rtc_pm_ops, s5m_rtc_suspend, s5m_rtc_resume); 


static const struct platform_device_id s5m_rtc_id[] = {

	{ "s5m-rtc",		S5M8767X },

	{ "s2mpg10-rtc",	S2MPG10 },

	{ "s2mps13-rtc",	S2MPS13X },

	{ "s2mps14-rtc",	S2MPS14X },

	{ "s2mps15-rtc",	S2MPS15X },