drivers/rtc/rtc-stmp3xxx.c

   1 /*
   2  * Freescale STMP37XX/STMP378X Real Time Clock driver
   3  *
   4  * Copyright (c) 2007 Sigmatel, Inc.
   5  * Peter Hartley, <peter.hartley@sigmatel.com>
   6  *
   7  * Copyright 2008 Freescale Semiconductor, Inc. All Rights Reserved.
   8  * Copyright 2008 Embedded Alley Solutions, Inc All Rights Reserved.
   9  */
  10
  11 /*
  12  * The code contained herein is licensed under the GNU General Public
  13  * License. You may obtain a copy of the GNU General Public License
  14  * Version 2 or later at the following locations:
  15  *
  16  * http://www.opensource.org/licenses/gpl-license.html
  17  * http://www.gnu.org/copyleft/gpl.html
  18  */
  19 #include <linux/kernel.h>
  20 #include <linux/module.h>
  21 #include <linux/init.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/rtc.h>
  25 #include <linux/slab.h>
  26
  27 #include <mach/common.h>
  28 #include <mach/mxs.h>
  29
  30 #define STMP3XXX_RTC_CTRL                       0x0
  31 #define STMP3XXX_RTC_CTRL_ALARM_IRQ_EN          0x00000001
  32 #define STMP3XXX_RTC_CTRL_ONEMSEC_IRQ_EN        0x00000002
  33 #define STMP3XXX_RTC_CTRL_ALARM_IRQ             0x00000004
  34 #define STMP3XXX_RTC_CTRL_ONEMSEC_IRQ           0x00000008
  35
  36 #define STMP3XXX_RTC_STAT                       0x10
  37 #define STMP3XXX_RTC_STAT_STALE_SHIFT           16
  38 #define STMP3XXX_RTC_STAT_RTC_PRESENT           0x80000000
  39
  40 #define STMP3XXX_RTC_SECONDS                    0x30
  41
  42 #define STMP3XXX_RTC_ALARM                      0x40
  43
  44 #define STMP3XXX_RTC_PERSISTENT0                0x60
  45 #define STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN  0x00000002
  46 #define STMP3XXX_RTC_PERSISTENT0_ALARM_EN       0x00000004
  47 #define STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE     0x00000080
  48
  49 struct stmp3xxx_rtc_data {
  50         struct rtc_device *rtc;
  51         unsigned irq_count;
  52         void __iomem *io;
  53         int irq_alarm, irq_1msec;
  54 };
  55
  56 static void stmp3xxx_wait_time(struct stmp3xxx_rtc_data *rtc_data)
  57 {
  58         /*
  59          * The datasheet doesn't say which way round the
  60          * NEW_REGS/STALE_REGS bitfields go. In fact it's 0x1=P0,
  61          * 0x2=P1, .., 0x20=P5, 0x40=ALARM, 0x80=SECONDS
  62          */
  63         while (__raw_readl(rtc_data->io + STMP3XXX_RTC_STAT) &
  64                         (0x80 << STMP3XXX_RTC_STAT_STALE_SHIFT))
  65                 cpu_relax();
  66 }
  67
  68 /* Time read/write */
  69 static int stmp3xxx_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
  70 {
  71         struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
  72
  73         stmp3xxx_wait_time(rtc_data);
  74         rtc_time_to_tm(__raw_readl(rtc_data->io + STMP3XXX_RTC_SECONDS),
  75                         rtc_tm);
  76         return 0;
  77 }
  78
  79 static int stmp3xxx_rtc_set_mmss(struct device *dev, unsigned long t)
  80 {
  81         struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
  82
  83         __raw_writel(t, rtc_data->io + STMP3XXX_RTC_SECONDS);
  84         stmp3xxx_wait_time(rtc_data);
  85         return 0;
  86 }
  87
  88 /* interrupt(s) handler */
  89 static irqreturn_t stmp3xxx_rtc_interrupt(int irq, void *dev_id)
  90 {
  91         struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev_id);
  92         u32 status;
  93         u32 events = 0;
  94
  95         status = __raw_readl(rtc_data->io + STMP3XXX_RTC_CTRL) &
  96                         (STMP3XXX_RTC_CTRL_ALARM_IRQ |
  97                          STMP3XXX_RTC_CTRL_ONEMSEC_IRQ);
  98
  99         if (status & STMP3XXX_RTC_CTRL_ALARM_IRQ) {
 100                 __mxs_clrl(STMP3XXX_RTC_CTRL_ALARM_IRQ,
 101                                 rtc_data->io + STMP3XXX_RTC_CTRL);
 102                 events |= RTC_AF | RTC_IRQF;
 103         }
 104
 105         if (status & STMP3XXX_RTC_CTRL_ONEMSEC_IRQ) {
 106                 __mxs_clrl(STMP3XXX_RTC_CTRL_ONEMSEC_IRQ,
 107                                 rtc_data->io + STMP3XXX_RTC_CTRL);
 108                 if (++rtc_data->irq_count % 1000 == 0) {
 109                         events |= RTC_UF | RTC_IRQF;
 110                         rtc_data->irq_count = 0;
 111                 }
 112         }
 113
 114         if (events)
 115                 rtc_update_irq(rtc_data->rtc, 1, events);
 116
 117         return IRQ_HANDLED;
 118 }
 119
 120 static int stmp3xxx_alarm_irq_enable(struct device *dev, unsigned int enabled)
 121 {
 122         struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
 123         void __iomem *p = rtc_data->io + STMP3XXX_RTC_PERSISTENT0,
 124                      *ctl = rtc_data->io + STMP3XXX_RTC_CTRL;
 125
 126         if (enabled) {
 127                 __mxs_setl(STMP3XXX_RTC_PERSISTENT0_ALARM_EN |
 128                               STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN, p);
 129                 __mxs_setl(STMP3XXX_RTC_CTRL_ALARM_IRQ_EN, ctl);
 130         } else {
 131                 __mxs_clrl(STMP3XXX_RTC_PERSISTENT0_ALARM_EN |
 132                               STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN, p);
 133                 __mxs_clrl(STMP3XXX_RTC_CTRL_ALARM_IRQ_EN, ctl);
 134         }
 135         return 0;
 136 }
 137
 138 static int stmp3xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
 139 {
 140         struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
 141
 142         rtc_time_to_tm(__raw_readl(rtc_data->io + STMP3XXX_RTC_ALARM),
 143                         &alm->time);
 144         return 0;
 145 }
 146
 147 static int stmp3xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
 148 {
 149         unsigned long t;
 150         struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
 151
 152         rtc_tm_to_time(&alm->time, &t);
 153         __raw_writel(t, rtc_data->io + STMP3XXX_RTC_ALARM);
 154         return 0;
 155 }
 156
 157 static struct rtc_class_ops stmp3xxx_rtc_ops = {
 158         .alarm_irq_enable =
 159                           stmp3xxx_alarm_irq_enable,
 160         .read_time      = stmp3xxx_rtc_gettime,
 161         .set_mmss       = stmp3xxx_rtc_set_mmss,
 162         .read_alarm     = stmp3xxx_rtc_read_alarm,
 163         .set_alarm      = stmp3xxx_rtc_set_alarm,
 164 };
 165
 166 static int stmp3xxx_rtc_remove(struct platform_device *pdev)
 167 {
 168         struct stmp3xxx_rtc_data *rtc_data = platform_get_drvdata(pdev);
 169
 170         if (!rtc_data)
 171                 return 0;
 172
 173         __mxs_clrl(STMP3XXX_RTC_CTRL_ONEMSEC_IRQ_EN |
 174                         STMP3XXX_RTC_CTRL_ALARM_IRQ_EN,
 175                         rtc_data->io + STMP3XXX_RTC_CTRL);
 176         free_irq(rtc_data->irq_alarm, &pdev->dev);
 177         free_irq(rtc_data->irq_1msec, &pdev->dev);
 178         rtc_device_unregister(rtc_data->rtc);
 179         platform_set_drvdata(pdev, NULL);
 180         iounmap(rtc_data->io);
 181         kfree(rtc_data);
 182
 183         return 0;
 184 }
 185
 186 static int stmp3xxx_rtc_probe(struct platform_device *pdev)
 187 {
 188         struct stmp3xxx_rtc_data *rtc_data;
 189         struct resource *r;
 190         int err;
 191
 192         rtc_data = kzalloc(sizeof *rtc_data, GFP_KERNEL);
 193         if (!rtc_data)
 194                 return -ENOMEM;
 195
 196         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 197         if (!r) {
 198                 dev_err(&pdev->dev, "failed to get resource\n");
 199                 err = -ENXIO;
 200                 goto out_free;
 201         }
 202
 203         rtc_data->io = ioremap(r->start, resource_size(r));
 204         if (!rtc_data->io) {
 205                 dev_err(&pdev->dev, "ioremap failed\n");
 206                 err = -EIO;
 207                 goto out_free;
 208         }
 209
 210         rtc_data->irq_alarm = platform_get_irq(pdev, 0);
 211         rtc_data->irq_1msec = platform_get_irq(pdev, 1);
 212
 213         if (!(__raw_readl(STMP3XXX_RTC_STAT + rtc_data->io) &
 214                         STMP3XXX_RTC_STAT_RTC_PRESENT)) {
 215                 dev_err(&pdev->dev, "no device onboard\n");
 216                 err = -ENODEV;
 217                 goto out_remap;
 218         }
 219
 220         platform_set_drvdata(pdev, rtc_data);
 221
 222         mxs_reset_block(rtc_data->io);
 223         __mxs_clrl(STMP3XXX_RTC_PERSISTENT0_ALARM_EN |
 224                         STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN |
 225                         STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE,
 226                         rtc_data->io + STMP3XXX_RTC_PERSISTENT0);
 227
 228         rtc_data->rtc = rtc_device_register(pdev->name, &pdev->dev,
 229                                 &stmp3xxx_rtc_ops, THIS_MODULE);
 230         if (IS_ERR(rtc_data->rtc)) {
 231                 err = PTR_ERR(rtc_data->rtc);
 232                 goto out_remap;
 233         }
 234
 235         rtc_data->irq_count = 0;
 236         err = request_irq(rtc_data->irq_alarm, stmp3xxx_rtc_interrupt,
 237                         IRQF_DISABLED, "RTC alarm", &pdev->dev);
 238         if (err) {
 239                 dev_err(&pdev->dev, "Cannot claim IRQ%d\n",
 240                         rtc_data->irq_alarm);
 241                 goto out_irq_alarm;
 242         }
 243         err = request_irq(rtc_data->irq_1msec, stmp3xxx_rtc_interrupt,
 244                         IRQF_DISABLED, "RTC tick", &pdev->dev);
 245         if (err) {
 246                 dev_err(&pdev->dev, "Cannot claim IRQ%d\n",
 247                         rtc_data->irq_1msec);
 248                 goto out_irq1;
 249         }
 250
 251         return 0;
 252
 253 out_irq1:
 254         free_irq(rtc_data->irq_alarm, &pdev->dev);
 255 out_irq_alarm:
 256         __mxs_clrl(STMP3XXX_RTC_CTRL_ONEMSEC_IRQ_EN |
 257                         STMP3XXX_RTC_CTRL_ALARM_IRQ_EN,
 258                         rtc_data->io + STMP3XXX_RTC_CTRL);
 259         rtc_device_unregister(rtc_data->rtc);
 260 out_remap:
 261         platform_set_drvdata(pdev, NULL);
 262         iounmap(rtc_data->io);
 263 out_free:
 264         kfree(rtc_data);
 265         return err;
 266 }
 267
 268 #ifdef CONFIG_PM
 269 static int stmp3xxx_rtc_suspend(struct platform_device *dev, pm_message_t state)
 270 {
 271         return 0;
 272 }
 273
 274 static int stmp3xxx_rtc_resume(struct platform_device *dev)
 275 {
 276         struct stmp3xxx_rtc_data *rtc_data = platform_get_drvdata(dev);
 277
 278         mxs_reset_block(rtc_data->io);
 279         __mxs_clrl(STMP3XXX_RTC_PERSISTENT0_ALARM_EN |
 280                         STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN |
 281                         STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE,
 282                         rtc_data->io + STMP3XXX_RTC_PERSISTENT0);
 283         return 0;
 284 }
 285 #else
 286 #define stmp3xxx_rtc_suspend    NULL
 287 #define stmp3xxx_rtc_resume     NULL
 288 #endif
 289
 290 static struct platform_driver stmp3xxx_rtcdrv = {
 291         .probe          = stmp3xxx_rtc_probe,
 292         .remove         = stmp3xxx_rtc_remove,
 293         .suspend        = stmp3xxx_rtc_suspend,
 294         .resume         = stmp3xxx_rtc_resume,
 295         .driver         = {
 296                 .name   = "stmp3xxx-rtc",
 297                 .owner  = THIS_MODULE,
 298         },
 299 };
 300
 301 static int __init stmp3xxx_rtc_init(void)
 302 {
 303         return platform_driver_register(&stmp3xxx_rtcdrv);
 304 }
 305
 306 static void __exit stmp3xxx_rtc_exit(void)
 307 {
 308         platform_driver_unregister(&stmp3xxx_rtcdrv);
 309 }
 310
 311 module_init(stmp3xxx_rtc_init);
 312 module_exit(stmp3xxx_rtc_exit);
 313
 314 MODULE_DESCRIPTION("STMP3xxx RTC Driver");
 315 MODULE_AUTHOR("dmitry pervushin <dpervushin@embeddedalley.com>");
 316 MODULE_LICENSE("GPL");