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

   1/*
   2 * Dallas DS1216 RTC driver
   3 *
   4 * Copyright (c) 2007 Thomas Bogendoerfer
   5 *
   6 */
   7
   8#include <linux/module.h>
   9#include <linux/rtc.h>
  10#include <linux/platform_device.h>
  11#include <linux/bcd.h>
  12#include <linux/slab.h>
  13
  14#define DRV_VERSION "0.2"
  15
  16struct ds1216_regs {
  17        u8 tsec;
  18        u8 sec;
  19        u8 min;
  20        u8 hour;
  21        u8 wday;
  22        u8 mday;
  23        u8 month;
  24        u8 year;
  25};
  26
  27#define DS1216_HOUR_1224        (1 << 7)
  28#define DS1216_HOUR_AMPM        (1 << 5)
  29
  30struct ds1216_priv {
  31        struct rtc_device *rtc;
  32        void __iomem *ioaddr;
  33};
  34
  35static const u8 magic[] = {
  36        0xc5, 0x3a, 0xa3, 0x5c, 0xc5, 0x3a, 0xa3, 0x5c
  37};
  38
  39/*
  40 * Read the 64 bit we'd like to have - It a series
  41 * of 64 bits showing up in the LSB of the base register.
  42 *
  43 */
  44static void ds1216_read(u8 __iomem *ioaddr, u8 *buf)
  45{
  46        unsigned char c;
  47        int i, j;
  48
  49        for (i = 0; i < 8; i++) {
  50                c = 0;
  51                for (j = 0; j < 8; j++)
  52                        c |= (readb(ioaddr) & 0x1) << j;
  53                buf[i] = c;
  54        }
  55}
  56
  57static void ds1216_write(u8 __iomem *ioaddr, const u8 *buf)
  58{
  59        unsigned char c;
  60        int i, j;
  61
  62        for (i = 0; i < 8; i++) {
  63                c = buf[i];
  64                for (j = 0; j < 8; j++) {
  65                        writeb(c, ioaddr);
  66                        c = c >> 1;
  67                }
  68        }
  69}
  70
  71static void ds1216_switch_ds_to_clock(u8 __iomem *ioaddr)
  72{
  73        /* Reset magic pointer */
  74        readb(ioaddr);
  75        /* Write 64 bit magic to DS1216 */
  76        ds1216_write(ioaddr, magic);
  77}
  78
  79static int ds1216_rtc_read_time(struct device *dev, struct rtc_time *tm)
  80{
  81        struct platform_device *pdev = to_platform_device(dev);
  82        struct ds1216_priv *priv = platform_get_drvdata(pdev);
  83        struct ds1216_regs regs;
  84
  85        ds1216_switch_ds_to_clock(priv->ioaddr);
  86        ds1216_read(priv->ioaddr, (u8 *)&regs);
  87
  88        tm->tm_sec = bcd2bin(regs.sec);
  89        tm->tm_min = bcd2bin(regs.min);
  90        if (regs.hour & DS1216_HOUR_1224) {
  91                /* AM/PM mode */
  92                tm->tm_hour = bcd2bin(regs.hour & 0x1f);
  93                if (regs.hour & DS1216_HOUR_AMPM)
  94                        tm->tm_hour += 12;
  95        } else
  96                tm->tm_hour = bcd2bin(regs.hour & 0x3f);
  97        tm->tm_wday = (regs.wday & 7) - 1;
  98        tm->tm_mday = bcd2bin(regs.mday & 0x3f);
  99        tm->tm_mon = bcd2bin(regs.month & 0x1f);
 100        tm->tm_year = bcd2bin(regs.year);
 101        if (tm->tm_year < 70)
 102                tm->tm_year += 100;
 103
 104        return rtc_valid_tm(tm);
 105}
 106
 107static int ds1216_rtc_set_time(struct device *dev, struct rtc_time *tm)
 108{
 109        struct platform_device *pdev = to_platform_device(dev);
 110        struct ds1216_priv *priv = platform_get_drvdata(pdev);
 111        struct ds1216_regs regs;
 112
 113        ds1216_switch_ds_to_clock(priv->ioaddr);
 114        ds1216_read(priv->ioaddr, (u8 *)&regs);
 115
 116        regs.tsec = 0; /* clear 0.1 and 0.01 seconds */
 117        regs.sec = bin2bcd(tm->tm_sec);
 118        regs.min = bin2bcd(tm->tm_min);
 119        regs.hour &= DS1216_HOUR_1224;
 120        if (regs.hour && tm->tm_hour > 12) {
 121                regs.hour |= DS1216_HOUR_AMPM;
 122                tm->tm_hour -= 12;
 123        }
 124        regs.hour |= bin2bcd(tm->tm_hour);
 125        regs.wday &= ~7;
 126        regs.wday |= tm->tm_wday;
 127        regs.mday = bin2bcd(tm->tm_mday);
 128        regs.month = bin2bcd(tm->tm_mon);
 129        regs.year = bin2bcd(tm->tm_year % 100);
 130
 131        ds1216_switch_ds_to_clock(priv->ioaddr);
 132        ds1216_write(priv->ioaddr, (u8 *)&regs);
 133        return 0;
 134}
 135
 136static const struct rtc_class_ops ds1216_rtc_ops = {
 137        .read_time      = ds1216_rtc_read_time,
 138        .set_time       = ds1216_rtc_set_time,
 139};
 140
 141static int __init ds1216_rtc_probe(struct platform_device *pdev)
 142{
 143        struct resource *res;
 144        struct ds1216_priv *priv;
 145        u8 dummy[8];
 146
 147        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 148        if (!res)
 149                return -ENODEV;
 150        priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
 151        if (!priv)
 152                return -ENOMEM;
 153
 154        platform_set_drvdata(pdev, priv);
 155
 156        priv->ioaddr = devm_ioremap_resource(&pdev->dev, res);
 157        if (IS_ERR(priv->ioaddr))
 158                return PTR_ERR(priv->ioaddr);
 159
 160        priv->rtc = devm_rtc_device_register(&pdev->dev, "ds1216",
 161                                        &ds1216_rtc_ops, THIS_MODULE);
 162        if (IS_ERR(priv->rtc))
 163                return PTR_ERR(priv->rtc);
 164
 165        /* dummy read to get clock into a known state */
 166        ds1216_read(priv->ioaddr, dummy);
 167        return 0;
 168}
 169
 170static struct platform_driver ds1216_rtc_platform_driver = {
 171        .driver         = {
 172                .name   = "rtc-ds1216",
 173        },
 174};
 175
 176module_platform_driver_probe(ds1216_rtc_platform_driver, ds1216_rtc_probe);
 177
 178MODULE_AUTHOR("Thomas Bogendoerfer <tsbogend@alpha.franken.de>");
 179MODULE_DESCRIPTION("DS1216 RTC driver");
 180MODULE_LICENSE("GPL");
 181MODULE_VERSION(DRV_VERSION);
 182MODULE_ALIAS("platform:rtc-ds1216");
 183