1 files changed, 121 insertions, 17 deletions

diff --git a/drivers/rtc/rtc-ab8500.c b/drivers/rtc/rtc-ab8500.c
index e346705aae92..4bcf9ca2818a 100644
--- a/drivers/rtc/rtc-ab8500.c
+++ b/drivers/rtc/rtc-ab8500.c
@@ -15,7 +15,7 @@
 #include <linux/platform_device.h>
 #include <linux/rtc.h>
 #include <linux/mfd/abx500.h>
-#include <linux/mfd/ab8500.h>
+#include <linux/mfd/abx500/ab8500.h>
 #include <linux/delay.h>
 
 #define AB8500_RTC_SOFF_STAT_REG        0x00
@@ -90,7 +90,7 @@ static int ab8500_rtc_read_time(struct device *dev, struct rtc_time *tm)
 
         /* Early AB8500 chips will not clear the rtc read request bit */
         if (abx500_get_chip_id(dev) == 0) {
-                msleep(1);
+                usleep_range(1000, 1000);
         } else {
                 /* Wait for some cycles after enabling the rtc read in ab8500 */
                 while (time_before(jiffies, timeout)) {
@@ -102,7 +102,7 @@ static int ab8500_rtc_read_time(struct device *dev, struct rtc_time *tm)
                         if (!(value & RTC_READ_REQUEST))
                                 break;
 
-                        msleep(1);
+                        usleep_range(1000, 5000);
                 }
         }
 
@@ -258,6 +258,109 @@ static int ab8500_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
         return ab8500_rtc_irq_enable(dev, alarm->enabled);
 }
 
+
+static int ab8500_rtc_set_calibration(struct device *dev, int calibration)
+{
+        int retval;
+        u8  rtccal = 0;
+
+        /*
+         * Check that the calibration value (which is in units of 0.5
+         * parts-per-million) is in the AB8500's range for RtcCalibration
+         * register. -128 (0x80) is not permitted because the AB8500 uses
+         * a sign-bit rather than two's complement, so 0x80 is just another
+         * representation of zero.
+         */
+        if ((calibration < -127) || (calibration > 127)) {
+                dev_err(dev, "RtcCalibration value outside permitted range\n");
+                return -EINVAL;
+        }
+
+        /*
+         * The AB8500 uses sign (in bit7) and magnitude (in bits0-7)
+         * so need to convert to this sort of representation before writing
+         * into RtcCalibration register...
+         */
+        if (calibration >= 0)
+                rtccal = 0x7F & calibration;
+        else
+                rtccal = ~(calibration - 1) | 0x80;
+
+        retval = abx500_set_register_interruptible(dev, AB8500_RTC,
+                        AB8500_RTC_CALIB_REG, rtccal);
+
+        return retval;
+}
+
+static int ab8500_rtc_get_calibration(struct device *dev, int *calibration)
+{
+        int retval;
+        u8  rtccal = 0;
+
+        retval =  abx500_get_register_interruptible(dev, AB8500_RTC,
+                        AB8500_RTC_CALIB_REG, &rtccal);
+        if (retval >= 0) {
+                /*
+                 * The AB8500 uses sign (in bit7) and magnitude (in bits0-7)
+                 * so need to convert value from RtcCalibration register into
+                 * a two's complement signed value...
+                 */
+                if (rtccal & 0x80)
+                        *calibration = 0 - (rtccal & 0x7F);
+                else
+                        *calibration = 0x7F & rtccal;
+        }
+
+        return retval;
+}
+
+static ssize_t ab8500_sysfs_store_rtc_calibration(struct device *dev,
+                                struct device_attribute *attr,
+                                const char *buf, size_t count)
+{
+        int retval;
+        int calibration = 0;
+
+        if (sscanf(buf, " %i ", &calibration) != 1) {
+                dev_err(dev, "Failed to store RTC calibration attribute\n");
+                return -EINVAL;
+        }
+
+        retval = ab8500_rtc_set_calibration(dev, calibration);
+
+        return retval ? retval : count;
+}
+
+static ssize_t ab8500_sysfs_show_rtc_calibration(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int  retval = 0;
+        int  calibration = 0;
+
+        retval = ab8500_rtc_get_calibration(dev, &calibration);
+        if (retval < 0) {
+                dev_err(dev, "Failed to read RTC calibration attribute\n");
+                sprintf(buf, "0\n");
+                return retval;
+        }
+
+        return sprintf(buf, "%d\n", calibration);
+}
+
+static DEVICE_ATTR(rtc_calibration, S_IRUGO | S_IWUSR,
+                   ab8500_sysfs_show_rtc_calibration,
+                   ab8500_sysfs_store_rtc_calibration);
+
+static int ab8500_sysfs_rtc_register(struct device *dev)
+{
+        return device_create_file(dev, &dev_attr_rtc_calibration);
+}
+
+static void ab8500_sysfs_rtc_unregister(struct device *dev)
+{
+        device_remove_file(dev, &dev_attr_rtc_calibration);
+}
+
 static irqreturn_t rtc_alarm_handler(int irq, void *data)
 {
         struct rtc_device *rtc = data;
@@ -295,7 +398,7 @@ static int __devinit ab8500_rtc_probe(struct platform_device *pdev)
                 return err;
 
         /* Wait for reset by the PorRtc */
-        msleep(1);
+        usleep_range(1000, 5000);
 
         err = abx500_get_register_interruptible(&pdev->dev, AB8500_RTC,
                 AB8500_RTC_STAT_REG, &rtc_ctrl);
@@ -308,6 +411,8 @@ static int __devinit ab8500_rtc_probe(struct platform_device *pdev)
                 return -ENODEV;
         }
 
+        device_init_wakeup(&pdev->dev, true);
+
         rtc = rtc_device_register("ab8500-rtc", &pdev->dev, &ab8500_rtc_ops,
                         THIS_MODULE);
         if (IS_ERR(rtc)) {
@@ -316,8 +421,8 @@ static int __devinit ab8500_rtc_probe(struct platform_device *pdev)
                 return err;
         }
 
-        err = request_threaded_irq(irq, NULL, rtc_alarm_handler, 0,
-                                   "ab8500-rtc", rtc);
+        err = request_threaded_irq(irq, NULL, rtc_alarm_handler,
+                IRQF_NO_SUSPEND, "ab8500-rtc", rtc);
         if (err < 0) {
                 rtc_device_unregister(rtc);
                 return err;
@@ -325,6 +430,13 @@ static int __devinit ab8500_rtc_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, rtc);
 
+
+        err = ab8500_sysfs_rtc_register(&pdev->dev);
+        if (err) {
+                dev_err(&pdev->dev, "sysfs RTC failed to register\n");
+                return err;
+        }
+
         return 0;
 }
 
@@ -333,6 +445,8 @@ static int __devexit ab8500_rtc_remove(struct platform_device *pdev)
         struct rtc_device *rtc = platform_get_drvdata(pdev);
         int irq = platform_get_irq_byname(pdev, "ALARM");
 
+        ab8500_sysfs_rtc_unregister(&pdev->dev);
+
         free_irq(irq, rtc);
         rtc_device_unregister(rtc);
         platform_set_drvdata(pdev, NULL);
@@ -349,18 +463,8 @@ static struct platform_driver ab8500_rtc_driver = {
         .remove = __devexit_p(ab8500_rtc_remove),
 };
 
-static int __init ab8500_rtc_init(void)
-{
-        return platform_driver_register(&ab8500_rtc_driver);
-}
-
-static void __exit ab8500_rtc_exit(void)
-{
-        platform_driver_unregister(&ab8500_rtc_driver);
-}
+module_platform_driver(ab8500_rtc_driver);
 
-module_init(ab8500_rtc_init);
-module_exit(ab8500_rtc_exit);
 MODULE_AUTHOR("Virupax Sadashivpetimath <virupax.sadashivpetimath@stericsson.com>");
 MODULE_DESCRIPTION("AB8500 RTC Driver");
 MODULE_LICENSE("GPL v2");