LXR linux/drivers/rtc/rtc-ds1286.c

   1/*
   2 * DS1286 Real Time Clock interface for Linux
   3 *
   4 * Copyright (C) 1998, 1999, 2000 Ralf Baechle
   5 * Copyright (C) 2008 Thomas Bogendoerfer
   6 *
   7 * Based on code written by Paul Gortmaker.
   8 *
   9 * This program is free software; you can redistribute it and/or modify it
  10 * under the terms of the GNU General Public License as published by the
  11 * Free Software Foundation; either version 2 of the License, or (at your
  12 * option) any later version.
  13 */
  14
  15#include <linux/module.h>
  16#include <linux/rtc.h>
  17#include <linux/platform_device.h>
  18#include <linux/bcd.h>
  19#include <linux/ds1286.h>
  20#include <linux/io.h>
  21
  22#define DRV_VERSION             "1.0"
  23
  24struct ds1286_priv {
  25        struct rtc_device *rtc;
  26        u32 __iomem *rtcregs;
  27        size_t size;
  28        unsigned long baseaddr;
  29        spinlock_t lock;
  30};
  31
  32static inline u8 ds1286_rtc_read(struct ds1286_priv *priv, int reg)
  33{
  34        return __raw_readl(&priv->rtcregs[reg]) & 0xff;
  35}
  36
  37static inline void ds1286_rtc_write(struct ds1286_priv *priv, u8 data, int reg)
  38{
  39        __raw_writel(data, &priv->rtcregs[reg]);
  40}
  41
  42#ifdef CONFIG_RTC_INTF_DEV
  43
  44static int ds1286_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
  45{
  46        struct ds1286_priv *priv = dev_get_drvdata(dev);
  47        unsigned long flags;
  48        unsigned char val;
  49
  50        switch (cmd) {
  51        case RTC_AIE_OFF:
  52                /* Mask alarm int. enab. bit    */
  53                spin_lock_irqsave(&priv->lock, flags);
  54                val = ds1286_rtc_read(priv, RTC_CMD);
  55                val |=  RTC_TDM;
  56                ds1286_rtc_write(priv, val, RTC_CMD);
  57                spin_unlock_irqrestore(&priv->lock, flags);
  58                break;
  59        case RTC_AIE_ON:
  60                /* Allow alarm interrupts.      */
  61                spin_lock_irqsave(&priv->lock, flags);
  62                val = ds1286_rtc_read(priv, RTC_CMD);
  63                val &=  ~RTC_TDM;
  64                ds1286_rtc_write(priv, val, RTC_CMD);
  65                spin_unlock_irqrestore(&priv->lock, flags);
  66                break;
  67        case RTC_WIE_OFF:
  68                /* Mask watchdog int. enab. bit */
  69                spin_lock_irqsave(&priv->lock, flags);
  70                val = ds1286_rtc_read(priv, RTC_CMD);
  71                val |= RTC_WAM;
  72                ds1286_rtc_write(priv, val, RTC_CMD);
  73                spin_unlock_irqrestore(&priv->lock, flags);
  74                break;
  75        case RTC_WIE_ON:
  76                /* Allow watchdog interrupts.   */
  77                spin_lock_irqsave(&priv->lock, flags);
  78                val = ds1286_rtc_read(priv, RTC_CMD);
  79                val &= ~RTC_WAM;
  80                ds1286_rtc_write(priv, val, RTC_CMD);
  81                spin_unlock_irqrestore(&priv->lock, flags);
  82                break;
  83        default:
  84                return -ENOIOCTLCMD;
  85        }
  86        return 0;
  87}
  88
  89#else
  90#define ds1286_ioctl    NULL
  91#endif
  92
  93#ifdef CONFIG_PROC_FS
  94
  95static int ds1286_proc(struct device *dev, struct seq_file *seq)
  96{
  97        struct ds1286_priv *priv = dev_get_drvdata(dev);
  98        unsigned char month, cmd, amode;
  99        const char *s;
 100
 101        month = ds1286_rtc_read(priv, RTC_MONTH);
 102        seq_printf(seq,
 103                   "oscillator\t: %s\n"
 104                   "square_wave\t: %s\n",
 105                   (month & RTC_EOSC) ? "disabled" : "enabled",
 106                   (month & RTC_ESQW) ? "disabled" : "enabled");
 107
 108        amode = ((ds1286_rtc_read(priv, RTC_MINUTES_ALARM) & 0x80) >> 5) |
 109                ((ds1286_rtc_read(priv, RTC_HOURS_ALARM) & 0x80) >> 6) |
 110                ((ds1286_rtc_read(priv, RTC_DAY_ALARM) & 0x80) >> 7);
 111        switch (amode) {
 112        case 7:
 113                s = "each minute";
 114                break;
 115        case 3:
 116                s = "minutes match";
 117                break;
 118        case 1:
 119                s = "hours and minutes match";
 120                break;
 121        case 0:
 122                s = "days, hours and minutes match";
 123                break;
 124        default:
 125                s = "invalid";
 126                break;
 127        }
 128        seq_printf(seq, "alarm_mode\t: %s\n", s);
 129
 130        cmd = ds1286_rtc_read(priv, RTC_CMD);
 131        seq_printf(seq,
 132                   "alarm_enable\t: %s\n"
 133                   "wdog_alarm\t: %s\n"
 134                   "alarm_mask\t: %s\n"
 135                   "wdog_alarm_mask\t: %s\n"
 136                   "interrupt_mode\t: %s\n"
 137                   "INTB_mode\t: %s_active\n"
 138                   "interrupt_pins\t: %s\n",
 139                   (cmd & RTC_TDF) ? "yes" : "no",
 140                   (cmd & RTC_WAF) ? "yes" : "no",
 141                   (cmd & RTC_TDM) ? "disabled" : "enabled",
 142                   (cmd & RTC_WAM) ? "disabled" : "enabled",
 143                   (cmd & RTC_PU_LVL) ? "pulse" : "level",
 144                   (cmd & RTC_IBH_LO) ? "low" : "high",
 145                   (cmd & RTC_IPSW) ? "unswapped" : "swapped");
 146        return 0;
 147}
 148
 149#else
 150#define ds1286_proc     NULL
 151#endif
 152
 153static int ds1286_read_time(struct device *dev, struct rtc_time *tm)
 154{
 155        struct ds1286_priv *priv = dev_get_drvdata(dev);
 156        unsigned char save_control;
 157        unsigned long flags;
 158        unsigned long uip_watchdog = jiffies;
 159
 160        /*
 161         * read RTC once any update in progress is done. The update
 162         * can take just over 2ms. We wait 10 to 20ms. There is no need to
 163         * to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP.
 164         * If you need to know *exactly* when a second has started, enable
 165         * periodic update complete interrupts, (via ioctl) and then
 166         * immediately read /dev/rtc which will block until you get the IRQ.
 167         * Once the read clears, read the RTC time (again via ioctl). Easy.
 168         */
 169
 170        if (ds1286_rtc_read(priv, RTC_CMD) & RTC_TE)
 171                while (time_before(jiffies, uip_watchdog + 2*HZ/100))
 172                        barrier();
 173
 174        /*
 175         * Only the values that we read from the RTC are set. We leave
 176         * tm_wday, tm_yday and tm_isdst untouched. Even though the
 177         * RTC has RTC_DAY_OF_WEEK, we ignore it, as it is only updated
 178         * by the RTC when initially set to a non-zero value.
 179         */
 180        spin_lock_irqsave(&priv->lock, flags);
 181        save_control = ds1286_rtc_read(priv, RTC_CMD);
 182        ds1286_rtc_write(priv, (save_control|RTC_TE), RTC_CMD);
 183
 184        tm->tm_sec = ds1286_rtc_read(priv, RTC_SECONDS);
 185        tm->tm_min = ds1286_rtc_read(priv, RTC_MINUTES);
 186        tm->tm_hour = ds1286_rtc_read(priv, RTC_HOURS) & 0x3f;
 187        tm->tm_mday = ds1286_rtc_read(priv, RTC_DATE);
 188        tm->tm_mon = ds1286_rtc_read(priv, RTC_MONTH) & 0x1f;
 189        tm->tm_year = ds1286_rtc_read(priv, RTC_YEAR);
 190
 191        ds1286_rtc_write(priv, save_control, RTC_CMD);
 192        spin_unlock_irqrestore(&priv->lock, flags);
 193
 194        tm->tm_sec = bcd2bin(tm->tm_sec);
 195        tm->tm_min = bcd2bin(tm->tm_min);
 196        tm->tm_hour = bcd2bin(tm->tm_hour);
 197        tm->tm_mday = bcd2bin(tm->tm_mday);
 198        tm->tm_mon = bcd2bin(tm->tm_mon);
 199        tm->tm_year = bcd2bin(tm->tm_year);
 200
 201        /*
 202         * Account for differences between how the RTC uses the values
 203         * and how they are defined in a struct rtc_time;
 204         */
 205        if (tm->tm_year < 45)
 206                tm->tm_year += 30;
 207        tm->tm_year += 40;
 208        if (tm->tm_year < 70)
 209                tm->tm_year += 100;
 210
 211        tm->tm_mon--;
 212
 213        return rtc_valid_tm(tm);
 214}
 215
 216static int ds1286_set_time(struct device *dev, struct rtc_time *tm)
 217{
 218        struct ds1286_priv *priv = dev_get_drvdata(dev);
 219        unsigned char mon, day, hrs, min, sec;
 220        unsigned char save_control;
 221        unsigned int yrs;
 222        unsigned long flags;
 223
 224        yrs = tm->tm_year + 1900;
 225        mon = tm->tm_mon + 1;   /* tm_mon starts at zero */
 226        day = tm->tm_mday;
 227        hrs = tm->tm_hour;
 228        min = tm->tm_min;
 229        sec = tm->tm_sec;
 230
 231        if (yrs < 1970)
 232                return -EINVAL;
 233
 234        yrs -= 1940;
 235        if (yrs > 255)    /* They are unsigned */
 236                return -EINVAL;
 237
 238        if (yrs >= 100)
 239                yrs -= 100;
 240
 241        sec = bin2bcd(sec);
 242        min = bin2bcd(min);
 243        hrs = bin2bcd(hrs);
 244        day = bin2bcd(day);
 245        mon = bin2bcd(mon);
 246        yrs = bin2bcd(yrs);
 247
 248        spin_lock_irqsave(&priv->lock, flags);
 249        save_control = ds1286_rtc_read(priv, RTC_CMD);
 250        ds1286_rtc_write(priv, (save_control|RTC_TE), RTC_CMD);
 251
 252        ds1286_rtc_write(priv, yrs, RTC_YEAR);
 253        ds1286_rtc_write(priv, mon, RTC_MONTH);
 254        ds1286_rtc_write(priv, day, RTC_DATE);
 255        ds1286_rtc_write(priv, hrs, RTC_HOURS);
 256        ds1286_rtc_write(priv, min, RTC_MINUTES);
 257        ds1286_rtc_write(priv, sec, RTC_SECONDS);
 258        ds1286_rtc_write(priv, 0, RTC_HUNDREDTH_SECOND);
 259
 260        ds1286_rtc_write(priv, save_control, RTC_CMD);
 261        spin_unlock_irqrestore(&priv->lock, flags);
 262        return 0;
 263}
 264
 265static int ds1286_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
 266{
 267        struct ds1286_priv *priv = dev_get_drvdata(dev);
 268        unsigned char cmd;
 269        unsigned long flags;
 270
 271        /*
 272         * Only the values that we read from the RTC are set. That
 273         * means only tm_wday, tm_hour, tm_min.
 274         */
 275        spin_lock_irqsave(&priv->lock, flags);
 276        alm->time.tm_min = ds1286_rtc_read(priv, RTC_MINUTES_ALARM) & 0x7f;
 277        alm->time.tm_hour = ds1286_rtc_read(priv, RTC_HOURS_ALARM)  & 0x1f;
 278        alm->time.tm_wday = ds1286_rtc_read(priv, RTC_DAY_ALARM)    & 0x07;
 279        cmd = ds1286_rtc_read(priv, RTC_CMD);
 280        spin_unlock_irqrestore(&priv->lock, flags);
 281
 282        alm->time.tm_min = bcd2bin(alm->time.tm_min);
 283        alm->time.tm_hour = bcd2bin(alm->time.tm_hour);
 284        alm->time.tm_sec = 0;
 285        return 0;
 286}
 287
 288static int ds1286_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
 289{
 290        struct ds1286_priv *priv = dev_get_drvdata(dev);
 291        unsigned char hrs, min, sec;
 292
 293        hrs = alm->time.tm_hour;
 294        min = alm->time.tm_min;
 295        sec = alm->time.tm_sec;
 296
 297        if (hrs >= 24)
 298                hrs = 0xff;
 299
 300        if (min >= 60)
 301                min = 0xff;
 302
 303        if (sec != 0)
 304                return -EINVAL;
 305
 306        min = bin2bcd(min);
 307        hrs = bin2bcd(hrs);
 308
 309        spin_lock(&priv->lock);
 310        ds1286_rtc_write(priv, hrs, RTC_HOURS_ALARM);
 311        ds1286_rtc_write(priv, min, RTC_MINUTES_ALARM);
 312        spin_unlock(&priv->lock);
 313
 314        return 0;
 315}
 316
 317static const struct rtc_class_ops ds1286_ops = {
 318        .ioctl          = ds1286_ioctl,
 319        .proc           = ds1286_proc,
 320        .read_time      = ds1286_read_time,
 321        .set_time       = ds1286_set_time,
 322        .read_alarm     = ds1286_read_alarm,
 323        .set_alarm      = ds1286_set_alarm,
 324};
 325
 326static int __devinit ds1286_probe(struct platform_device *pdev)
 327{
 328        struct rtc_device *rtc;
 329        struct resource *res;
 330        struct ds1286_priv *priv;
 331        int ret = 0;
 332
 333        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 334        if (!res)
 335                return -ENODEV;
 336        priv = kzalloc(sizeof(struct ds1286_priv), GFP_KERNEL);
 337        if (!priv)
 338                return -ENOMEM;
 339
 340        priv->size = res->end - res->start + 1;
 341        if (!request_mem_region(res->start, priv->size, pdev->name)) {
 342                ret = -EBUSY;
 343                goto out;
 344        }
 345        priv->baseaddr = res->start;
 346        priv->rtcregs = ioremap(priv->baseaddr, priv->size);
 347        if (!priv->rtcregs) {
 348                ret = -ENOMEM;
 349                goto out;
 350        }
 351        spin_lock_init(&priv->lock);
 352        rtc = rtc_device_register("ds1286", &pdev->dev,
 353                                  &ds1286_ops, THIS_MODULE);
 354        if (IS_ERR(rtc)) {
 355                ret = PTR_ERR(rtc);
 356                goto out;
 357        }
 358        priv->rtc = rtc;
 359        platform_set_drvdata(pdev, priv);
 360        return 0;
 361
 362out:
 363        if (priv->rtc)
 364                rtc_device_unregister(priv->rtc);
 365        if (priv->rtcregs)
 366                iounmap(priv->rtcregs);
 367        if (priv->baseaddr)
 368                release_mem_region(priv->baseaddr, priv->size);
 369        kfree(priv);
 370        return ret;
 371}
 372
 373static int __devexit ds1286_remove(struct platform_device *pdev)
 374{
 375        struct ds1286_priv *priv = platform_get_drvdata(pdev);
 376
 377        rtc_device_unregister(priv->rtc);
 378        iounmap(priv->rtcregs);
 379        release_mem_region(priv->baseaddr, priv->size);
 380        kfree(priv);
 381        return 0;
 382}
 383
 384static struct platform_driver ds1286_platform_driver = {
 385        .driver         = {
 386                .name   = "rtc-ds1286",
 387                .owner  = THIS_MODULE,
 388        },
 389        .probe          = ds1286_probe,
 390        .remove         = __devexit_p(ds1286_remove),
 391};
 392
 393static int __init ds1286_init(void)
 394{
 395        return platform_driver_register(&ds1286_platform_driver);
 396}
 397
 398static void __exit ds1286_exit(void)
 399{
 400        platform_driver_unregister(&ds1286_platform_driver);
 401}
 402
 403MODULE_AUTHOR("Thomas Bogendoerfer <tsbogend@alpha.franken.de>");
 404MODULE_DESCRIPTION("DS1286 RTC driver");
 405MODULE_LICENSE("GPL");
 406MODULE_VERSION(DRV_VERSION);
 407MODULE_ALIAS("platform:rtc-ds1286");
 408
 409module_init(ds1286_init);
 410module_exit(ds1286_exit);
 411