drivers/rtc/rtc-pl031.c

   1 /*
   2  * drivers/rtc/rtc-pl031.c
   3  *
   4  * Real Time Clock interface for ARM AMBA PrimeCell 031 RTC
   5  *
   6  * Author: Deepak Saxena <dsaxena@plexity.net>
   7  *
   8  * Copyright 2006 (c) MontaVista Software, Inc.
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version
  13  * 2 of the License, or (at your option) any later version.
  14  */
  15
  16 #include <linux/platform_device.h>
  17 #include <linux/module.h>
  18 #include <linux/rtc.h>
  19 #include <linux/init.h>
  20 #include <linux/fs.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/string.h>
  23 #include <linux/pm.h>
  24
  25 #include <linux/amba/bus.h>
  26
  27 #include <asm/io.h>
  28 #include <asm/bitops.h>
  29 #include <asm/hardware.h>
  30 #include <asm/irq.h>
  31 #include <asm/rtc.h>
  32
  33 /*
  34  * Register definitions
  35  */
  36 #define RTC_DR          0x00    /* Data read register */
  37 #define RTC_MR          0x04    /* Match register */
  38 #define RTC_LR          0x08    /* Data load register */
  39 #define RTC_CR          0x0c    /* Control register */
  40 #define RTC_IMSC        0x10    /* Interrupt mask and set register */
  41 #define RTC_RIS         0x14    /* Raw interrupt status register */
  42 #define RTC_MIS         0x18    /* Masked interrupt status register */
  43 #define RTC_ICR         0x1c    /* Interrupt clear register */
  44
  45 struct pl031_local {
  46         struct rtc_device *rtc;
  47         void __iomem *base;
  48 };
  49
  50 static irqreturn_t pl031_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  51 {
  52         struct rtc_device *rtc = dev_id;
  53
  54         rtc_update_irq(&rtc->class_dev, 1, RTC_AF);
  55
  56         return IRQ_HANDLED;
  57 }
  58
  59 static int pl031_open(struct device *dev)
  60 {
  61         /*
  62          * We request IRQ in pl031_probe, so nothing to do here...
  63          */
  64         return 0;
  65 }
  66
  67 static void pl031_release(struct device *dev)
  68 {
  69 }
  70
  71 static int pl031_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
  72 {
  73         struct pl031_local *ldata = dev_get_drvdata(dev);
  74
  75         switch (cmd) {
  76         case RTC_AIE_OFF:
  77                 __raw_writel(1, ldata->base + RTC_MIS);
  78                 return 0;
  79         case RTC_AIE_ON:
  80                 __raw_writel(0, ldata->base + RTC_MIS);
  81                 return 0;
  82         }
  83
  84         return -ENOIOCTLCMD;
  85 }
  86
  87 static int pl031_read_time(struct device *dev, struct rtc_time *tm)
  88 {
  89         struct pl031_local *ldata = dev_get_drvdata(dev);
  90
  91         rtc_time_to_tm(__raw_readl(ldata->base + RTC_DR), tm);
  92
  93         return 0;
  94 }
  95
  96 static int pl031_set_time(struct device *dev, struct rtc_time *tm)
  97 {
  98         unsigned long time;
  99         struct pl031_local *ldata = dev_get_drvdata(dev);
 100
 101         rtc_tm_to_time(tm, &time);
 102         __raw_writel(time, ldata->base + RTC_LR);
 103
 104         return 0;
 105 }
 106
 107 static int pl031_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 108 {
 109         struct pl031_local *ldata = dev_get_drvdata(dev);
 110
 111         rtc_time_to_tm(__raw_readl(ldata->base + RTC_MR), &alarm->time);
 112         alarm->pending = __raw_readl(ldata->base + RTC_RIS);
 113         alarm->enabled = __raw_readl(ldata->base + RTC_IMSC);
 114
 115         return 0;
 116 }
 117
 118 static int pl031_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 119 {
 120         struct pl031_local *ldata = dev_get_drvdata(dev);
 121         unsigned long time;
 122
 123         rtc_tm_to_time(&alarm->time, &time);
 124
 125         __raw_writel(time, ldata->base + RTC_MR);
 126         __raw_writel(!alarm->enabled, ldata->base + RTC_MIS);
 127
 128         return 0;
 129 }
 130
 131 static const struct rtc_class_ops pl031_ops = {
 132         .open = pl031_open,
 133         .release = pl031_release,
 134         .ioctl = pl031_ioctl,
 135         .read_time = pl031_read_time,
 136         .set_time = pl031_set_time,
 137         .read_alarm = pl031_read_alarm,
 138         .set_alarm = pl031_set_alarm,
 139 };
 140
 141 static int pl031_remove(struct amba_device *adev)
 142 {
 143         struct pl031_local *ldata = dev_get_drvdata(&adev->dev);
 144
 145         if (ldata) {
 146                 dev_set_drvdata(&adev->dev, NULL);
 147                 free_irq(adev->irq[0], ldata->rtc);
 148                 rtc_device_unregister(ldata->rtc);
 149                 iounmap(ldata->base);
 150                 kfree(ldata);
 151         }
 152
 153         return 0;
 154 }
 155
 156 static int pl031_probe(struct amba_device *adev, void *id)
 157 {
 158         int ret;
 159         struct pl031_local *ldata;
 160
 161
 162         ldata = kmalloc(sizeof(struct pl031_local), GFP_KERNEL);
 163         if (!ldata) {
 164                 ret = -ENOMEM;
 165                 goto out;
 166         }
 167         dev_set_drvdata(&adev->dev, ldata);
 168
 169         ldata->base = ioremap(adev->res.start,
 170                               adev->res.end - adev->res.start + 1);
 171         if (!ldata->base) {
 172                 ret = -ENOMEM;
 173                 goto out_no_remap;
 174         }
 175
 176         if (request_irq(adev->irq[0], pl031_interrupt, IRQF_DISABLED,
 177                         "rtc-pl031", ldata->rtc)) {
 178                 ret = -EIO;
 179                 goto out_no_irq;
 180         }
 181
 182         ldata->rtc = rtc_device_register("pl031", &adev->dev, &pl031_ops,
 183                                          THIS_MODULE);
 184         if (IS_ERR(ldata->rtc)) {
 185                 ret = PTR_ERR(ldata->rtc);
 186                 goto out_no_rtc;
 187         }
 188
 189         return 0;
 190
 191 out_no_rtc:
 192         free_irq(adev->irq[0], ldata->rtc);
 193 out_no_irq:
 194         iounmap(ldata->base);
 195 out_no_remap:
 196         dev_set_drvdata(&adev->dev, NULL);
 197         kfree(ldata);
 198 out:
 199         return ret;
 200 }
 201
 202 static struct amba_id pl031_ids[] __initdata = {
 203         {
 204                  .id = 0x00041031,
 205                 .mask = 0x000fffff, },
 206         {0, 0},
 207 };
 208
 209 static struct amba_driver pl031_driver = {
 210         .drv = {
 211                 .name = "rtc-pl031",
 212         },
 213         .id_table = pl031_ids,
 214         .probe = pl031_probe,
 215         .remove = pl031_remove,
 216 };
 217
 218 static int __init pl031_init(void)
 219 {
 220         return amba_driver_register(&pl031_driver);
 221 }
 222
 223 static void __exit pl031_exit(void)
 224 {
 225         amba_driver_unregister(&pl031_driver);
 226 }
 227
 228 module_init(pl031_init);
 229 module_exit(pl031_exit);
 230
 231 MODULE_AUTHOR("Deepak Saxena <dsaxena@plexity.net");
 232 MODULE_DESCRIPTION("ARM AMBA PL031 RTC Driver");
 233 MODULE_LICENSE("GPL");