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