Commit 077eaf5b authored by Mark Brown's avatar Mark Brown Committed by Linus Torvalds
Browse files

rtc: rtc-wm8350: add support for WM8350 RTC 



This adds support for the RTC provided by the Wolfson Microelectronics
WM8350.

This driver was originally written by Graeme Gregory and Liam Girdwood,
though it has been modified since then to update it to current mainline
coding standards and for API completeness.

[akpm@linux-foundation.org: s/schedule_timeout_interruptible/schedule_timeout_uninterruptible/ to prevent bogus timeout when signal_pending()]
Signed-off-by: default avatarMark Brown <broonie@opensource.wolfsonmicro.com>
Cc: Alessandro Zummo <a.zummo@towertech.it>
Cc: David Brownell <david-b@pacbell.net>
Cc: Liam Girdwood <linux@wolfsonmicro.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent a412ae3f

drivers/rtc/Kconfig

+10 −0
Original line number Diff line number Diff line
@@ -468,6 +468,16 @@ config RTC_DRV_V3020 
	  This driver can also be built as a module. If so, the module

	  will be called rtc-v3020.



config RTC_DRV_WM8350

	tristate "Wolfson Microelectronics WM8350 RTC"

	depends on MFD_WM8350

	help

	  If you say yes here you will get support for the RTC subsystem

	  of the Wolfson Microelectronics WM8350.



	  This driver can also be built as a module. If so, the module

	  will be called "rtc-wm8350".



comment "on-CPU RTC drivers"



config RTC_DRV_OMAP

drivers/rtc/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -66,4 +66,5 @@ obj-$(CONFIG_RTC_DRV_TEST) += rtc-test.o 
obj-$(CONFIG_RTC_DRV_TWL4030)	+= rtc-twl4030.o

obj-$(CONFIG_RTC_DRV_V3020)	+= rtc-v3020.o

obj-$(CONFIG_RTC_DRV_VR41XX)	+= rtc-vr41xx.o

obj-$(CONFIG_RTC_DRV_WM8350)	+= rtc-wm8350.o

obj-$(CONFIG_RTC_DRV_X1205)	+= rtc-x1205.o

drivers/rtc/rtc-wm8350.c

0 → 100644
+514 −0
Original line number Diff line number Diff line 
/*

 *	Real Time Clock driver for Wolfson Microelectronics WM8350

 *

 *	Copyright (C) 2007, 2008 Wolfson Microelectronics PLC.

 *

 *  Author: Liam Girdwood

 *          linux@wolfsonmicro.com

 *

 *  This program is free software; you can redistribute  it and/or modify it

 *  under  the terms of  the GNU General  Public License as published by the

 *  Free Software Foundation;  either version 2 of the  License, or (at your

 *  option) any later version.

 *

 */



#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/time.h>

#include <linux/rtc.h>

#include <linux/bcd.h>

#include <linux/interrupt.h>

#include <linux/ioctl.h>

#include <linux/completion.h>

#include <linux/mfd/wm8350/rtc.h>

#include <linux/mfd/wm8350/core.h>

#include <linux/delay.h>

#include <linux/platform_device.h>



#define WM8350_SET_ALM_RETRIES	5

#define WM8350_SET_TIME_RETRIES	5

#define WM8350_GET_TIME_RETRIES	5



#define to_wm8350_from_rtc_dev(d) container_of(d, struct wm8350, rtc.pdev.dev)



/*

 * Read current time and date in RTC

 */

static int wm8350_rtc_readtime(struct device *dev, struct rtc_time *tm)

{

	struct wm8350 *wm8350 = dev_get_drvdata(dev);

	u16 time1[4], time2[4];

	int retries = WM8350_GET_TIME_RETRIES, ret;



	/*

	 * Read the time twice and compare.

	 * If time1 == time2, then time is valid else retry.

	 */

	do {

		ret = wm8350_block_read(wm8350, WM8350_RTC_SECONDS_MINUTES,

					4, time1);

		if (ret < 0)

			return ret;

		ret = wm8350_block_read(wm8350, WM8350_RTC_SECONDS_MINUTES,

					4, time2);

		if (ret < 0)

			return ret;



		if (memcmp(time1, time2, sizeof(time1)) == 0) {

			tm->tm_sec = time1[0] & WM8350_RTC_SECS_MASK;



			tm->tm_min = (time1[0] & WM8350_RTC_MINS_MASK)

			    >> WM8350_RTC_MINS_SHIFT;



			tm->tm_hour = time1[1] & WM8350_RTC_HRS_MASK;



			tm->tm_wday = ((time1[1] >> WM8350_RTC_DAY_SHIFT)

				       & 0x7) - 1;



			tm->tm_mon = ((time1[2] & WM8350_RTC_MTH_MASK)

				      >> WM8350_RTC_MTH_SHIFT) - 1;



			tm->tm_mday = (time1[2] & WM8350_RTC_DATE_MASK);



			tm->tm_year = ((time1[3] & WM8350_RTC_YHUNDREDS_MASK)

				       >> WM8350_RTC_YHUNDREDS_SHIFT) * 100;

			tm->tm_year += time1[3] & WM8350_RTC_YUNITS_MASK;



			tm->tm_yday = rtc_year_days(tm->tm_mday, tm->tm_mon,

						    tm->tm_year);

			tm->tm_year -= 1900;



			dev_dbg(dev, "Read (%d left): %04x %04x %04x %04x\n",

				retries,

				time1[0], time1[1], time1[2], time1[3]);



			return 0;

		}

	} while (retries--);



	dev_err(dev, "timed out reading RTC time\n");

	return -EIO;

}



/*

 * Set current time and date in RTC

 */

static int wm8350_rtc_settime(struct device *dev, struct rtc_time *tm)

{

	struct wm8350 *wm8350 = dev_get_drvdata(dev);

	u16 time[4];

	u16 rtc_ctrl;

	int ret, retries = WM8350_SET_TIME_RETRIES;



	time[0] = tm->tm_sec;

	time[0] |= tm->tm_min << WM8350_RTC_MINS_SHIFT;

	time[1] = tm->tm_hour;

	time[1] |= (tm->tm_wday + 1) << WM8350_RTC_DAY_SHIFT;

	time[2] = tm->tm_mday;

	time[2] |= (tm->tm_mon + 1) << WM8350_RTC_MTH_SHIFT;

	time[3] = ((tm->tm_year + 1900) / 100) << WM8350_RTC_YHUNDREDS_SHIFT;

	time[3] |= (tm->tm_year + 1900) % 100;



	dev_dbg(dev, "Setting: %04x %04x %04x %04x\n",

		time[0], time[1], time[2], time[3]);



	/* Set RTC_SET to stop the clock */

	ret = wm8350_set_bits(wm8350, WM8350_RTC_TIME_CONTROL, WM8350_RTC_SET);

	if (ret < 0)

		return ret;



	/* Wait until confirmation of stopping */

	do {

		rtc_ctrl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL);

		schedule_timeout_uninterruptible(msecs_to_jiffies(1));

	} while (retries-- && !(rtc_ctrl & WM8350_RTC_STS));



	if (!retries) {

		dev_err(dev, "timed out on set confirmation\n");

		return -EIO;

	}



	/* Write time to RTC */

	ret = wm8350_block_write(wm8350, WM8350_RTC_SECONDS_MINUTES, 4, time);

	if (ret < 0)

		return ret;



	/* Clear RTC_SET to start the clock */

	ret = wm8350_clear_bits(wm8350, WM8350_RTC_TIME_CONTROL,

				WM8350_RTC_SET);

	return ret;

}



/*

 * Read alarm time and date in RTC

 */

static int wm8350_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)

{

	struct wm8350 *wm8350 = dev_get_drvdata(dev);

	struct rtc_time *tm = &alrm->time;

	u16 time[4];

	int ret;



	ret = wm8350_block_read(wm8350, WM8350_ALARM_SECONDS_MINUTES, 4, time);

	if (ret < 0)

		return ret;



	tm->tm_sec = time[0] & WM8350_RTC_ALMSECS_MASK;

	if (tm->tm_sec == WM8350_RTC_ALMSECS_MASK)

		tm->tm_sec = -1;



	tm->tm_min = time[0] & WM8350_RTC_ALMMINS_MASK;

	if (tm->tm_min == WM8350_RTC_ALMMINS_MASK)

		tm->tm_min = -1;

	else

		tm->tm_min >>= WM8350_RTC_ALMMINS_SHIFT;



	tm->tm_hour = time[1] & WM8350_RTC_ALMHRS_MASK;

	if (tm->tm_hour == WM8350_RTC_ALMHRS_MASK)

		tm->tm_hour = -1;



	tm->tm_wday = ((time[1] >> WM8350_RTC_ALMDAY_SHIFT) & 0x7) - 1;

	if (tm->tm_wday > 7)

		tm->tm_wday = -1;



	tm->tm_mon = time[2] & WM8350_RTC_ALMMTH_MASK;

	if (tm->tm_mon == WM8350_RTC_ALMMTH_MASK)

		tm->tm_mon = -1;

	else

		tm->tm_mon = (tm->tm_mon >> WM8350_RTC_ALMMTH_SHIFT) - 1;



	tm->tm_mday = (time[2] & WM8350_RTC_ALMDATE_MASK);

	if (tm->tm_mday == WM8350_RTC_ALMDATE_MASK)

		tm->tm_mday = -1;



	tm->tm_year = -1;



	alrm->enabled = !(time[3] & WM8350_RTC_ALMSTS);



	return 0;

}



static int wm8350_rtc_stop_alarm(struct wm8350 *wm8350)

{

	int retries = WM8350_SET_ALM_RETRIES;

	u16 rtc_ctrl;

	int ret;



	/* Set RTC_SET to stop the clock */

	ret = wm8350_set_bits(wm8350, WM8350_RTC_TIME_CONTROL,

			      WM8350_RTC_ALMSET);

	if (ret < 0)

		return ret;



	/* Wait until confirmation of stopping */

	do {

		rtc_ctrl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL);

		schedule_timeout_uninterruptible(msecs_to_jiffies(1));

	} while (retries-- && !(rtc_ctrl & WM8350_RTC_ALMSTS));



	if (!(rtc_ctrl & WM8350_RTC_ALMSTS))

		return -ETIMEDOUT;



	return 0;

}



static int wm8350_rtc_start_alarm(struct wm8350 *wm8350)

{

	int ret;

	int retries = WM8350_SET_ALM_RETRIES;

	u16 rtc_ctrl;



	ret = wm8350_clear_bits(wm8350, WM8350_RTC_TIME_CONTROL,

				WM8350_RTC_ALMSET);

	if (ret < 0)

		return ret;



	/* Wait until confirmation */

	do {

		rtc_ctrl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL);

		schedule_timeout_uninterruptible(msecs_to_jiffies(1));

	} while (retries-- && rtc_ctrl & WM8350_RTC_ALMSTS);



	if (rtc_ctrl & WM8350_RTC_ALMSTS)

		return -ETIMEDOUT;



	return 0;

}



static int wm8350_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)

{

	struct wm8350 *wm8350 = dev_get_drvdata(dev);

	struct rtc_time *tm = &alrm->time;

	u16 time[3];

	int ret;



	memset(time, 0, sizeof(time));



	if (tm->tm_sec != -1)

		time[0] |= tm->tm_sec;

	else

		time[0] |= WM8350_RTC_ALMSECS_MASK;



	if (tm->tm_min != -1)

		time[0] |= tm->tm_min << WM8350_RTC_ALMMINS_SHIFT;

	else

		time[0] |= WM8350_RTC_ALMMINS_MASK;



	if (tm->tm_hour != -1)

		time[1] |= tm->tm_hour;

	else

		time[1] |= WM8350_RTC_ALMHRS_MASK;



	if (tm->tm_wday != -1)

		time[1] |= (tm->tm_wday + 1) << WM8350_RTC_ALMDAY_SHIFT;

	else

		time[1] |= WM8350_RTC_ALMDAY_MASK;



	if (tm->tm_mday != -1)

		time[2] |= tm->tm_mday;

	else

		time[2] |= WM8350_RTC_ALMDATE_MASK;



	if (tm->tm_mon != -1)

		time[2] |= (tm->tm_mon + 1) << WM8350_RTC_ALMMTH_SHIFT;

	else

		time[2] |= WM8350_RTC_ALMMTH_MASK;



	ret = wm8350_rtc_stop_alarm(wm8350);

	if (ret < 0)

		return ret;



	/* Write time to RTC */

	ret = wm8350_block_write(wm8350, WM8350_ALARM_SECONDS_MINUTES,

				 3, time);

	if (ret < 0)

		return ret;



	if (alrm->enabled)

		ret = wm8350_rtc_start_alarm(wm8350);



	return ret;

}



/*

 * Handle commands from user-space

 */

static int wm8350_rtc_ioctl(struct device *dev, unsigned int cmd,

			    unsigned long arg)

{

	struct wm8350 *wm8350 = dev_get_drvdata(dev);



	switch (cmd) {

	case RTC_AIE_OFF:

		return wm8350_rtc_stop_alarm(wm8350);

	case RTC_AIE_ON:

		return wm8350_rtc_start_alarm(wm8350);



	case RTC_UIE_OFF:

		wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC);

		break;

	case RTC_UIE_ON:

		wm8350_unmask_irq(wm8350, WM8350_IRQ_RTC_SEC);

		break;



	default:

		return -ENOIOCTLCMD;

	}



	return 0;

}



static void wm8350_rtc_alarm_handler(struct wm8350 *wm8350, int irq,

				     void *data)

{

	struct rtc_device *rtc = wm8350->rtc.rtc;

	int ret;



	rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF);



	/* Make it one shot */

	ret = wm8350_set_bits(wm8350, WM8350_RTC_TIME_CONTROL,

			      WM8350_RTC_ALMSET);

	if (ret != 0) {

		dev_err(&(wm8350->rtc.pdev->dev),

			"Failed to disable alarm: %d\n", ret);

	}

}



static void wm8350_rtc_update_handler(struct wm8350 *wm8350, int irq,

				      void *data)

{

	struct rtc_device *rtc = wm8350->rtc.rtc;



	rtc_update_irq(rtc, 1, RTC_IRQF | RTC_UF);

}



static const struct rtc_class_ops wm8350_rtc_ops = {

	.ioctl = wm8350_rtc_ioctl,

	.read_time = wm8350_rtc_readtime,

	.set_time = wm8350_rtc_settime,

	.read_alarm = wm8350_rtc_readalarm,

	.set_alarm = wm8350_rtc_setalarm,

};



#ifdef CONFIG_PM

static int wm8350_rtc_suspend(struct platform_device *pdev, pm_message_t state)

{

	struct wm8350 *wm8350 = dev_get_drvdata(&pdev->dev);

	int ret = 0;

	u16 reg;



	reg = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL);



	if (device_may_wakeup(&wm8350->rtc.pdev->dev) &&

	    reg & WM8350_RTC_ALMSTS) {

		ret = wm8350_rtc_stop_alarm(wm8350);

		if (ret != 0)

			dev_err(&pdev->dev, "Failed to stop RTC alarm: %d\n",

				ret);

	}



	return ret;

}



static int wm8350_rtc_resume(struct platform_device *pdev)

{

	struct wm8350 *wm8350 = dev_get_drvdata(&pdev->dev);

	int ret;



	if (wm8350->rtc.alarm_enabled) {

		ret = wm8350_rtc_start_alarm(wm8350);

		if (ret != 0)

			dev_err(&pdev->dev,

				"Failed to restart RTC alarm: %d\n", ret);

	}



	return 0;

}



#else

#define wm8350_rtc_suspend NULL

#define wm8350_rtc_resume NULL

#endif



static int wm8350_rtc_probe(struct platform_device *pdev)

{

	struct wm8350 *wm8350 = platform_get_drvdata(pdev);

	struct wm8350_rtc *wm_rtc = &wm8350->rtc;

	int ret = 0;

	u16 timectl, power5;



	timectl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL);

	if (timectl & WM8350_RTC_BCD) {

		dev_err(&pdev->dev, "RTC BCD mode not supported\n");

		return -EINVAL;

	}

	if (timectl & WM8350_RTC_12HR) {

		dev_err(&pdev->dev, "RTC 12 hour mode not supported\n");

		return -EINVAL;

	}



	/* enable the RTC if it's not already enabled */

	power5 = wm8350_reg_read(wm8350, WM8350_POWER_MGMT_5);

	if (!(power5 &  WM8350_RTC_TICK_ENA)) {

		dev_info(wm8350->dev, "Starting RTC\n");



		wm8350_reg_unlock(wm8350);



		ret = wm8350_set_bits(wm8350, WM8350_POWER_MGMT_5,

				      WM8350_RTC_TICK_ENA);

		if (ret < 0) {

			dev_err(&pdev->dev, "failed to enable RTC: %d\n", ret);

			return ret;

		}



		wm8350_reg_lock(wm8350);

	}



	if (timectl & WM8350_RTC_STS) {

		int retries;



		ret = wm8350_clear_bits(wm8350, WM8350_RTC_TIME_CONTROL,

					WM8350_RTC_SET);

		if (ret < 0) {

			dev_err(&pdev->dev, "failed to start: %d\n", ret);

			return ret;

		}



		retries = WM8350_SET_TIME_RETRIES;

		do {

			timectl = wm8350_reg_read(wm8350,

						  WM8350_RTC_TIME_CONTROL);

		} while (timectl & WM8350_RTC_STS && retries--);



		if (retries == 0) {

			dev_err(&pdev->dev, "failed to start: timeout\n");

			return -ENODEV;

		}

	}



	device_init_wakeup(&pdev->dev, 1);



	wm_rtc->rtc = rtc_device_register("wm8350", &pdev->dev,

					  &wm8350_rtc_ops, THIS_MODULE);

	if (IS_ERR(wm_rtc->rtc)) {

		ret = PTR_ERR(wm_rtc->rtc);

		dev_err(&pdev->dev, "failed to register RTC: %d\n", ret);

		return ret;

	}



	wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC);

	wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_PER);



	wm8350_register_irq(wm8350, WM8350_IRQ_RTC_SEC,

			    wm8350_rtc_update_handler, NULL);



	wm8350_register_irq(wm8350, WM8350_IRQ_RTC_ALM,

			    wm8350_rtc_alarm_handler, NULL);

	wm8350_unmask_irq(wm8350, WM8350_IRQ_RTC_ALM);



	return 0;

}



static int __devexit wm8350_rtc_remove(struct platform_device *pdev)

{

	struct wm8350 *wm8350 = platform_get_drvdata(pdev);

	struct wm8350_rtc *wm_rtc = &wm8350->rtc;



	wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC);



	wm8350_free_irq(wm8350, WM8350_IRQ_RTC_SEC);

	wm8350_free_irq(wm8350, WM8350_IRQ_RTC_ALM);



	rtc_device_unregister(wm_rtc->rtc);



	return 0;

}



static struct platform_driver wm8350_rtc_driver = {

	.probe = wm8350_rtc_probe,

	.remove = __devexit_p(wm8350_rtc_remove),

	.suspend = wm8350_rtc_suspend,

	.resume = wm8350_rtc_resume,

	.driver = {

		.name = "wm8350-rtc",

	},

};



static int __init wm8350_rtc_init(void)

{

	return platform_driver_register(&wm8350_rtc_driver);

}

module_init(wm8350_rtc_init);



static void __exit wm8350_rtc_exit(void)

{

	platform_driver_unregister(&wm8350_rtc_driver);

}

module_exit(wm8350_rtc_exit);



MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");

MODULE_DESCRIPTION("RTC driver for the WM8350");

MODULE_LICENSE("GPL");

MODULE_ALIAS("platform:wm8350-rtc");

include/linux/mfd/wm8350/rtc.h

+2 −0
Original line number Diff line number Diff line
@@ -261,6 +261,8 @@ 


struct wm8350_rtc {

	struct platform_device *pdev;

	struct rtc_device *rtc;

	int alarm_enabled;      /* used over suspend/resume */

};



#endif

CRA Git | Maintained and supported by SUSTech CRA and CCSE