drivers/rtc/rtc-wm8350.c - kernel/mindspeed - Git at Google

 /*
  *	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_alarm_irq_enable(struct device *dev,
 				       unsigned int enabled)
 {
 	struct wm8350 *wm8350 = dev_get_drvdata(dev);

 	if (enabled)
 		return wm8350_rtc_start_alarm(wm8350);
 	else
 		return wm8350_rtc_stop_alarm(wm8350);
 }

 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;
 }

 static irqreturn_t wm8350_rtc_alarm_handler(int irq, void *data)
 {
 	struct wm8350 *wm8350 = 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);
 	}

 	return IRQ_HANDLED;
 }

 static irqreturn_t wm8350_rtc_update_handler(int irq, void *data)
 {
 	struct wm8350 *wm8350 = data;
 	struct rtc_device *rtc = wm8350->rtc.rtc;

 	rtc_update_irq(rtc, 1, RTC_IRQF | RTC_UF);

 	return IRQ_HANDLED;
 }

 static const struct rtc_class_ops wm8350_rtc_ops = {
 	.read_time = wm8350_rtc_readtime,
 	.set_time = wm8350_rtc_settime,
 	.read_alarm = wm8350_rtc_readalarm,
 	.set_alarm = wm8350_rtc_setalarm,
 	.alarm_irq_enable = wm8350_rtc_alarm_irq_enable,
 };

 #ifdef CONFIG_PM
 static int wm8350_rtc_suspend(struct device *dev)
 {
 	struct platform_device *pdev = to_platform_device(dev);
 	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 device *dev)
 {
 	struct platform_device *pdev = to_platform_device(dev);
 	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_register_irq(wm8350, WM8350_IRQ_RTC_SEC,
 			    wm8350_rtc_update_handler, 0,
 			    "RTC Seconds", wm8350);
 	wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC);

 	wm8350_register_irq(wm8350, WM8350_IRQ_RTC_ALM,
 			    wm8350_rtc_alarm_handler, 0,
 			    "RTC Alarm", wm8350);

 	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_free_irq(wm8350, WM8350_IRQ_RTC_SEC, wm8350);
 	wm8350_free_irq(wm8350, WM8350_IRQ_RTC_ALM, wm8350);

 	rtc_device_unregister(wm_rtc->rtc);

 	return 0;
 }

 static struct dev_pm_ops wm8350_rtc_pm_ops = {
 	.suspend = wm8350_rtc_suspend,
 	.resume = wm8350_rtc_resume,
 };

 static struct platform_driver wm8350_rtc_driver = {
 	.probe = wm8350_rtc_probe,
 	.remove = __devexit_p(wm8350_rtc_remove),
 	.driver = {
 		.name = "wm8350-rtc",
 		.pm = &wm8350_rtc_pm_ops,
 	},
 };

 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");
	/*
	* 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_alarm_irq_enable(struct device *dev,
	unsigned int enabled)
	{
	struct wm8350 *wm8350 = dev_get_drvdata(dev);

	if (enabled)
	return wm8350_rtc_start_alarm(wm8350);
	else
	return wm8350_rtc_stop_alarm(wm8350);
	}

	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;
	}

	static irqreturn_t wm8350_rtc_alarm_handler(int irq, void *data)
	{
	struct wm8350 *wm8350 = 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);
	}

	return IRQ_HANDLED;
	}

	static irqreturn_t wm8350_rtc_update_handler(int irq, void *data)
	{
	struct wm8350 *wm8350 = data;
	struct rtc_device *rtc = wm8350->rtc.rtc;

	rtc_update_irq(rtc, 1, RTC_IRQF \| RTC_UF);

	return IRQ_HANDLED;
	}

	static const struct rtc_class_ops wm8350_rtc_ops = {
	.read_time = wm8350_rtc_readtime,
	.set_time = wm8350_rtc_settime,
	.read_alarm = wm8350_rtc_readalarm,
	.set_alarm = wm8350_rtc_setalarm,
	.alarm_irq_enable = wm8350_rtc_alarm_irq_enable,
	};

	#ifdef CONFIG_PM
	static int wm8350_rtc_suspend(struct device *dev)
	{
	struct platform_device *pdev = to_platform_device(dev);
	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 device *dev)
	{
	struct platform_device *pdev = to_platform_device(dev);
	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_register_irq(wm8350, WM8350_IRQ_RTC_SEC,
	wm8350_rtc_update_handler, 0,
	"RTC Seconds", wm8350);
	wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC);

	wm8350_register_irq(wm8350, WM8350_IRQ_RTC_ALM,
	wm8350_rtc_alarm_handler, 0,
	"RTC Alarm", wm8350);

	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_free_irq(wm8350, WM8350_IRQ_RTC_SEC, wm8350);
	wm8350_free_irq(wm8350, WM8350_IRQ_RTC_ALM, wm8350);

	rtc_device_unregister(wm_rtc->rtc);

	return 0;
	}

	static struct dev_pm_ops wm8350_rtc_pm_ops = {
	.suspend = wm8350_rtc_suspend,
	.resume = wm8350_rtc_resume,
	};

	static struct platform_driver wm8350_rtc_driver = {
	.probe = wm8350_rtc_probe,
	.remove = __devexit_p(wm8350_rtc_remove),
	.driver = {
	.name = "wm8350-rtc",
	.pm = &wm8350_rtc_pm_ops,
	},
	};

	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");