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