Commit ce9af893 authored by Marek Szyprowski's avatar Marek Szyprowski Committed by Alexandre Belloni
Browse files

rtc: s3c: Remove dead code related to periodic tick handling 



Support for periodic tick interrupts has been moved from the RTC class to
the HR-timers long time ago. Then it has been removed from this driver by
commits 80d4bb51 ("RTC: Cleanup rtc_class_ops->irq_set_state") and
696160fe ("RTC: Cleanup rtc_class_ops->irq_set_freq()"). They however
did not remove all the code related to the tick handling. Do it now then.

Signed-off-by: default avatarMarek Szyprowski <m.szyprowski@samsung.com>
Signed-off-by: default avatarAlexandre Belloni <alexandre.belloni@bootlin.com>
Reviewed-by: default avatarKrzysztof Kozlowski <krzk@kernel.org>
Link: https://lore.kernel.org/r/20201202111318.5353-2-m.szyprowski@samsung.com
parent 31b16d97

drivers/rtc/rtc-s3c.c

+2 −224
Original line number Diff line number Diff line
@@ -42,26 +42,15 @@ struct s3c_rtc { 
	const struct s3c_rtc_data *data;



	int irq_alarm;

	int irq_tick;



	spinlock_t pie_lock;

	spinlock_t alarm_lock;



	int ticnt_save;

	int ticnt_en_save;

	bool wake_en;

};



struct s3c_rtc_data {

	int max_user_freq;

	bool needs_src_clk;



	void (*irq_handler) (struct s3c_rtc *info, int mask);

	void (*set_freq) (struct s3c_rtc *info, int freq);

	void (*enable_tick) (struct s3c_rtc *info, struct seq_file *seq);

	void (*select_tick_clk) (struct s3c_rtc *info);

	void (*save_tick_cnt) (struct s3c_rtc *info);

	void (*restore_tick_cnt) (struct s3c_rtc *info);

	void (*enable) (struct s3c_rtc *info);

	void (*disable) (struct s3c_rtc *info);

};
@@ -91,17 +80,7 @@ static void s3c_rtc_disable_clk(struct s3c_rtc *info) 
	clk_disable(info->rtc_clk);

}



/* IRQ Handlers */

static irqreturn_t s3c_rtc_tickirq(int irq, void *id)

{

	struct s3c_rtc *info = (struct s3c_rtc *)id;



	if (info->data->irq_handler)

		info->data->irq_handler(info, S3C2410_INTP_TIC);



	return IRQ_HANDLED;

}



/* IRQ Handler */

static irqreturn_t s3c_rtc_alarmirq(int irq, void *id)

{

	struct s3c_rtc *info = (struct s3c_rtc *)id;
@@ -148,28 +127,6 @@ static int s3c_rtc_setaie(struct device *dev, unsigned int enabled) 
	return ret;

}



/* Set RTC frequency */

static int s3c_rtc_setfreq(struct s3c_rtc *info, int freq)

{

	int ret;



	if (!is_power_of_2(freq))

		return -EINVAL;



	ret = s3c_rtc_enable_clk(info);

	if (ret)

		return ret;

	spin_lock_irq(&info->pie_lock);



	if (info->data->set_freq)

		info->data->set_freq(info, freq);



	spin_unlock_irq(&info->pie_lock);

	s3c_rtc_disable_clk(info);



	return 0;

}



/* Time read/write */

static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)

{
@@ -348,29 +305,11 @@ static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm) 
	return 0;

}



static int s3c_rtc_proc(struct device *dev, struct seq_file *seq)

{

	struct s3c_rtc *info = dev_get_drvdata(dev);

	int ret;



	ret = s3c_rtc_enable_clk(info);

	if (ret)

		return ret;



	if (info->data->enable_tick)

		info->data->enable_tick(info, seq);



	s3c_rtc_disable_clk(info);



	return 0;

}



static const struct rtc_class_ops s3c_rtcops = {

	.read_time	= s3c_rtc_gettime,

	.set_time	= s3c_rtc_settime,

	.read_alarm	= s3c_rtc_getalarm,

	.set_alarm	= s3c_rtc_setalarm,

	.proc		= s3c_rtc_proc,

	.alarm_irq_enable = s3c_rtc_setaie,

};
@@ -450,18 +389,12 @@ static int s3c_rtc_probe(struct platform_device *pdev) 
	if (!info)

		return -ENOMEM;



	/* find the IRQs */

	info->irq_tick = platform_get_irq(pdev, 1);

	if (info->irq_tick < 0)

		return info->irq_tick;



	info->dev = &pdev->dev;

	info->data = of_device_get_match_data(&pdev->dev);

	if (!info->data) {

		dev_err(&pdev->dev, "failed getting s3c_rtc_data\n");

		return -EINVAL;

	}

	spin_lock_init(&info->pie_lock);

	spin_lock_init(&info->alarm_lock);



	platform_set_drvdata(pdev, info);
@@ -470,8 +403,7 @@ static int s3c_rtc_probe(struct platform_device *pdev) 
	if (info->irq_alarm < 0)

		return info->irq_alarm;



	dev_dbg(&pdev->dev, "s3c2410_rtc: tick irq %d, alarm irq %d\n",

		info->irq_tick, info->irq_alarm);

	dev_dbg(&pdev->dev, "s3c2410_rtc: alarm irq %d\n", info->irq_alarm);



	/* get the memory region */

	info->base = devm_platform_ioremap_resource(pdev, 0);
@@ -546,18 +478,6 @@ static int s3c_rtc_probe(struct platform_device *pdev) 
		goto err_nortc;

	}



	ret = devm_request_irq(&pdev->dev, info->irq_tick, s3c_rtc_tickirq,

			       0, "s3c2410-rtc tick", info);

	if (ret) {

		dev_err(&pdev->dev, "IRQ%d error %d\n", info->irq_tick, ret);

		goto err_nortc;

	}



	if (info->data->select_tick_clk)

		info->data->select_tick_clk(info);



	s3c_rtc_setfreq(info, 1);



	s3c_rtc_disable_clk(info);



	return 0;
@@ -585,10 +505,6 @@ static int s3c_rtc_suspend(struct device *dev) 
	if (ret)

		return ret;



	/* save TICNT for anyone using periodic interrupts */

	if (info->data->save_tick_cnt)

		info->data->save_tick_cnt(info);



	if (info->data->disable)

		info->data->disable(info);
@@ -609,9 +525,6 @@ static int s3c_rtc_resume(struct device *dev) 
	if (info->data->enable)

		info->data->enable(info);



	if (info->data->restore_tick_cnt)

		info->data->restore_tick_cnt(info);



	s3c_rtc_disable_clk(info);



	if (device_may_wakeup(dev) && info->wake_en) {
@@ -635,162 +548,27 @@ static void s3c6410_rtc_irq(struct s3c_rtc *info, int mask) 
	writeb(mask, info->base + S3C2410_INTP);

}



static void s3c2410_rtc_setfreq(struct s3c_rtc *info, int freq)

{

	unsigned int tmp = 0;

	int val;



	tmp = readb(info->base + S3C2410_TICNT);

	tmp &= S3C2410_TICNT_ENABLE;



	val = (info->rtc->max_user_freq / freq) - 1;

	tmp |= val;



	writel(tmp, info->base + S3C2410_TICNT);

}



static void s3c2416_rtc_setfreq(struct s3c_rtc *info, int freq)

{

	unsigned int tmp = 0;

	int val;



	tmp = readb(info->base + S3C2410_TICNT);

	tmp &= S3C2410_TICNT_ENABLE;



	val = (info->rtc->max_user_freq / freq) - 1;



	tmp |= S3C2443_TICNT_PART(val);

	writel(S3C2443_TICNT1_PART(val), info->base + S3C2443_TICNT1);



	writel(S3C2416_TICNT2_PART(val), info->base + S3C2416_TICNT2);



	writel(tmp, info->base + S3C2410_TICNT);

}



static void s3c2443_rtc_setfreq(struct s3c_rtc *info, int freq)

{

	unsigned int tmp = 0;

	int val;



	tmp = readb(info->base + S3C2410_TICNT);

	tmp &= S3C2410_TICNT_ENABLE;



	val = (info->rtc->max_user_freq / freq) - 1;



	tmp |= S3C2443_TICNT_PART(val);

	writel(S3C2443_TICNT1_PART(val), info->base + S3C2443_TICNT1);



	writel(tmp, info->base + S3C2410_TICNT);

}



static void s3c6410_rtc_setfreq(struct s3c_rtc *info, int freq)

{

	int val;



	val = (info->rtc->max_user_freq / freq) - 1;

	writel(val, info->base + S3C2410_TICNT);

}



static void s3c24xx_rtc_enable_tick(struct s3c_rtc *info, struct seq_file *seq)

{

	unsigned int ticnt;



	ticnt = readb(info->base + S3C2410_TICNT);

	ticnt &= S3C2410_TICNT_ENABLE;



	seq_printf(seq, "periodic_IRQ\t: %s\n", ticnt  ? "yes" : "no");

}



static void s3c2416_rtc_select_tick_clk(struct s3c_rtc *info)

{

	unsigned int con;



	con = readw(info->base + S3C2410_RTCCON);

	con |= S3C2443_RTCCON_TICSEL;

	writew(con, info->base + S3C2410_RTCCON);

}



static void s3c6410_rtc_enable_tick(struct s3c_rtc *info, struct seq_file *seq)

{

	unsigned int ticnt;



	ticnt = readw(info->base + S3C2410_RTCCON);

	ticnt &= S3C64XX_RTCCON_TICEN;



	seq_printf(seq, "periodic_IRQ\t: %s\n", ticnt  ? "yes" : "no");

}



static void s3c24xx_rtc_save_tick_cnt(struct s3c_rtc *info)

{

	info->ticnt_save = readb(info->base + S3C2410_TICNT);

}



static void s3c24xx_rtc_restore_tick_cnt(struct s3c_rtc *info)

{

	writeb(info->ticnt_save, info->base + S3C2410_TICNT);

}



static void s3c6410_rtc_save_tick_cnt(struct s3c_rtc *info)

{

	info->ticnt_en_save = readw(info->base + S3C2410_RTCCON);

	info->ticnt_en_save &= S3C64XX_RTCCON_TICEN;

	info->ticnt_save = readl(info->base + S3C2410_TICNT);

}



static void s3c6410_rtc_restore_tick_cnt(struct s3c_rtc *info)

{

	unsigned int con;



	writel(info->ticnt_save, info->base + S3C2410_TICNT);

	if (info->ticnt_en_save) {

		con = readw(info->base + S3C2410_RTCCON);

		writew(con | info->ticnt_en_save, info->base + S3C2410_RTCCON);

	}

}



static struct s3c_rtc_data const s3c2410_rtc_data = {

	.max_user_freq		= 128,

	.irq_handler		= s3c24xx_rtc_irq,

	.set_freq		= s3c2410_rtc_setfreq,

	.enable_tick		= s3c24xx_rtc_enable_tick,

	.save_tick_cnt		= s3c24xx_rtc_save_tick_cnt,

	.restore_tick_cnt	= s3c24xx_rtc_restore_tick_cnt,

	.enable			= s3c24xx_rtc_enable,

	.disable		= s3c24xx_rtc_disable,

};



static struct s3c_rtc_data const s3c2416_rtc_data = {

	.max_user_freq		= 32768,

	.irq_handler		= s3c24xx_rtc_irq,

	.set_freq		= s3c2416_rtc_setfreq,

	.enable_tick		= s3c24xx_rtc_enable_tick,

	.select_tick_clk	= s3c2416_rtc_select_tick_clk,

	.save_tick_cnt		= s3c24xx_rtc_save_tick_cnt,

	.restore_tick_cnt	= s3c24xx_rtc_restore_tick_cnt,

	.enable			= s3c24xx_rtc_enable,

	.disable		= s3c24xx_rtc_disable,

};



static struct s3c_rtc_data const s3c2443_rtc_data = {

	.max_user_freq		= 32768,

	.irq_handler		= s3c24xx_rtc_irq,

	.set_freq		= s3c2443_rtc_setfreq,

	.enable_tick		= s3c24xx_rtc_enable_tick,

	.select_tick_clk	= s3c2416_rtc_select_tick_clk,

	.save_tick_cnt		= s3c24xx_rtc_save_tick_cnt,

	.restore_tick_cnt	= s3c24xx_rtc_restore_tick_cnt,

	.enable			= s3c24xx_rtc_enable,

	.disable		= s3c24xx_rtc_disable,

};



static struct s3c_rtc_data const s3c6410_rtc_data = {

	.max_user_freq		= 32768,

	.needs_src_clk		= true,

	.irq_handler		= s3c6410_rtc_irq,

	.set_freq		= s3c6410_rtc_setfreq,

	.enable_tick		= s3c6410_rtc_enable_tick,

	.save_tick_cnt		= s3c6410_rtc_save_tick_cnt,

	.restore_tick_cnt	= s3c6410_rtc_restore_tick_cnt,

	.enable			= s3c24xx_rtc_enable,

	.disable		= s3c6410_rtc_disable,

};