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

   1/*
   2 * ST M48T59 RTC driver
   3 *
   4 * Copyright (c) 2007 Wind River Systems, Inc.
   5 *
   6 * Author: Mark Zhan <rongkai.zhan@windriver.com>
   7 *
   8 * This program is free software; you can redistribute it and/or modify
   9 * it under the terms of the GNU General Public License version 2 as
  10 * published by the Free Software Foundation.
  11 */
  12
  13#include <linux/kernel.h>
  14#include <linux/module.h>
  15#include <linux/init.h>
  16#include <linux/io.h>
  17#include <linux/device.h>
  18#include <linux/platform_device.h>
  19#include <linux/rtc.h>
  20#include <linux/rtc/m48t59.h>
  21#include <linux/bcd.h>
  22#include <linux/slab.h>
  23
  24#ifndef NO_IRQ
  25#define NO_IRQ  (-1)
  26#endif
  27
  28#define M48T59_READ(reg) (pdata->read_byte(dev, pdata->offset + reg))
  29#define M48T59_WRITE(val, reg) \
  30        (pdata->write_byte(dev, pdata->offset + reg, val))
  31
  32#define M48T59_SET_BITS(mask, reg)      \
  33        M48T59_WRITE((M48T59_READ(reg) | (mask)), (reg))
  34#define M48T59_CLEAR_BITS(mask, reg)    \
  35        M48T59_WRITE((M48T59_READ(reg) & ~(mask)), (reg))
  36
  37struct m48t59_private {
  38        void __iomem *ioaddr;
  39        int irq;
  40        struct rtc_device *rtc;
  41        spinlock_t lock; /* serialize the NVRAM and RTC access */
  42};
  43
  44/*
  45 * This is the generic access method when the chip is memory-mapped
  46 */
  47static void
  48m48t59_mem_writeb(struct device *dev, u32 ofs, u8 val)
  49{
  50        struct platform_device *pdev = to_platform_device(dev);
  51        struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
  52
  53        writeb(val, m48t59->ioaddr+ofs);
  54}
  55
  56static u8
  57m48t59_mem_readb(struct device *dev, u32 ofs)
  58{
  59        struct platform_device *pdev = to_platform_device(dev);
  60        struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
  61
  62        return readb(m48t59->ioaddr+ofs);
  63}
  64
  65/*
  66 * NOTE: M48T59 only uses BCD mode
  67 */
  68static int m48t59_rtc_read_time(struct device *dev, struct rtc_time *tm)
  69{
  70        struct platform_device *pdev = to_platform_device(dev);
  71        struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
  72        struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
  73        unsigned long flags;
  74        u8 val;
  75
  76        spin_lock_irqsave(&m48t59->lock, flags);
  77        /* Issue the READ command */
  78        M48T59_SET_BITS(M48T59_CNTL_READ, M48T59_CNTL);
  79
  80        tm->tm_year     = bcd2bin(M48T59_READ(M48T59_YEAR));
  81        /* tm_mon is 0-11 */
  82        tm->tm_mon      = bcd2bin(M48T59_READ(M48T59_MONTH)) - 1;
  83        tm->tm_mday     = bcd2bin(M48T59_READ(M48T59_MDAY));
  84
  85        val = M48T59_READ(M48T59_WDAY);
  86        if ((pdata->type == M48T59RTC_TYPE_M48T59) &&
  87            (val & M48T59_WDAY_CEB) && (val & M48T59_WDAY_CB)) {
  88                dev_dbg(dev, "Century bit is enabled\n");
  89                tm->tm_year += 100;     /* one century */
  90        }
  91#ifdef CONFIG_SPARC
  92        /* Sun SPARC machines count years since 1968 */
  93        tm->tm_year += 68;
  94#endif
  95
  96        tm->tm_wday     = bcd2bin(val & 0x07);
  97        tm->tm_hour     = bcd2bin(M48T59_READ(M48T59_HOUR) & 0x3F);
  98        tm->tm_min      = bcd2bin(M48T59_READ(M48T59_MIN) & 0x7F);
  99        tm->tm_sec      = bcd2bin(M48T59_READ(M48T59_SEC) & 0x7F);
 100
 101        /* Clear the READ bit */
 102        M48T59_CLEAR_BITS(M48T59_CNTL_READ, M48T59_CNTL);
 103        spin_unlock_irqrestore(&m48t59->lock, flags);
 104
 105        dev_dbg(dev, "RTC read time %04d-%02d-%02d %02d/%02d/%02d\n",
 106                tm->tm_year + 1900, tm->tm_mon, tm->tm_mday,
 107                tm->tm_hour, tm->tm_min, tm->tm_sec);
 108        return rtc_valid_tm(tm);
 109}
 110
 111static int m48t59_rtc_set_time(struct device *dev, struct rtc_time *tm)
 112{
 113        struct platform_device *pdev = to_platform_device(dev);
 114        struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
 115        struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
 116        unsigned long flags;
 117        u8 val = 0;
 118        int year = tm->tm_year;
 119
 120#ifdef CONFIG_SPARC
 121        /* Sun SPARC machines count years since 1968 */
 122        year -= 68;
 123#endif
 124
 125        dev_dbg(dev, "RTC set time %04d-%02d-%02d %02d/%02d/%02d\n",
 126                year + 1900, tm->tm_mon, tm->tm_mday,
 127                tm->tm_hour, tm->tm_min, tm->tm_sec);
 128
 129        if (year < 0)
 130                return -EINVAL;
 131
 132        spin_lock_irqsave(&m48t59->lock, flags);
 133        /* Issue the WRITE command */
 134        M48T59_SET_BITS(M48T59_CNTL_WRITE, M48T59_CNTL);
 135
 136        M48T59_WRITE((bin2bcd(tm->tm_sec) & 0x7F), M48T59_SEC);
 137        M48T59_WRITE((bin2bcd(tm->tm_min) & 0x7F), M48T59_MIN);
 138        M48T59_WRITE((bin2bcd(tm->tm_hour) & 0x3F), M48T59_HOUR);
 139        M48T59_WRITE((bin2bcd(tm->tm_mday) & 0x3F), M48T59_MDAY);
 140        /* tm_mon is 0-11 */
 141        M48T59_WRITE((bin2bcd(tm->tm_mon + 1) & 0x1F), M48T59_MONTH);
 142        M48T59_WRITE(bin2bcd(year % 100), M48T59_YEAR);
 143
 144        if (pdata->type == M48T59RTC_TYPE_M48T59 && (year / 100))
 145                val = (M48T59_WDAY_CEB | M48T59_WDAY_CB);
 146        val |= (bin2bcd(tm->tm_wday) & 0x07);
 147        M48T59_WRITE(val, M48T59_WDAY);
 148
 149        /* Clear the WRITE bit */
 150        M48T59_CLEAR_BITS(M48T59_CNTL_WRITE, M48T59_CNTL);
 151        spin_unlock_irqrestore(&m48t59->lock, flags);
 152        return 0;
 153}
 154
 155/*
 156 * Read alarm time and date in RTC
 157 */
 158static int m48t59_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
 159{
 160        struct platform_device *pdev = to_platform_device(dev);
 161        struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
 162        struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
 163        struct rtc_time *tm = &alrm->time;
 164        unsigned long flags;
 165        u8 val;
 166
 167        /* If no irq, we don't support ALARM */
 168        if (m48t59->irq == NO_IRQ)
 169                return -EIO;
 170
 171        spin_lock_irqsave(&m48t59->lock, flags);
 172        /* Issue the READ command */
 173        M48T59_SET_BITS(M48T59_CNTL_READ, M48T59_CNTL);
 174
 175        tm->tm_year = bcd2bin(M48T59_READ(M48T59_YEAR));
 176#ifdef CONFIG_SPARC
 177        /* Sun SPARC machines count years since 1968 */
 178        tm->tm_year += 68;
 179#endif
 180        /* tm_mon is 0-11 */
 181        tm->tm_mon = bcd2bin(M48T59_READ(M48T59_MONTH)) - 1;
 182
 183        val = M48T59_READ(M48T59_WDAY);
 184        if ((val & M48T59_WDAY_CEB) && (val & M48T59_WDAY_CB))
 185                tm->tm_year += 100;     /* one century */
 186
 187        tm->tm_mday = bcd2bin(M48T59_READ(M48T59_ALARM_DATE));
 188        tm->tm_hour = bcd2bin(M48T59_READ(M48T59_ALARM_HOUR));
 189        tm->tm_min = bcd2bin(M48T59_READ(M48T59_ALARM_MIN));
 190        tm->tm_sec = bcd2bin(M48T59_READ(M48T59_ALARM_SEC));
 191
 192        /* Clear the READ bit */
 193        M48T59_CLEAR_BITS(M48T59_CNTL_READ, M48T59_CNTL);
 194        spin_unlock_irqrestore(&m48t59->lock, flags);
 195
 196        dev_dbg(dev, "RTC read alarm time %04d-%02d-%02d %02d/%02d/%02d\n",
 197                tm->tm_year + 1900, tm->tm_mon, tm->tm_mday,
 198                tm->tm_hour, tm->tm_min, tm->tm_sec);
 199        return rtc_valid_tm(tm);
 200}
 201
 202/*
 203 * Set alarm time and date in RTC
 204 */
 205static int m48t59_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
 206{
 207        struct platform_device *pdev = to_platform_device(dev);
 208        struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
 209        struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
 210        struct rtc_time *tm = &alrm->time;
 211        u8 mday, hour, min, sec;
 212        unsigned long flags;
 213        int year = tm->tm_year;
 214
 215#ifdef CONFIG_SPARC
 216        /* Sun SPARC machines count years since 1968 */
 217        year -= 68;
 218#endif
 219
 220        /* If no irq, we don't support ALARM */
 221        if (m48t59->irq == NO_IRQ)
 222                return -EIO;
 223
 224        if (year < 0)
 225                return -EINVAL;
 226
 227        /*
 228         * 0xff means "always match"
 229         */
 230        mday = tm->tm_mday;
 231        mday = (mday >= 1 && mday <= 31) ? bin2bcd(mday) : 0xff;
 232        if (mday == 0xff)
 233                mday = M48T59_READ(M48T59_MDAY);
 234
 235        hour = tm->tm_hour;
 236        hour = (hour < 24) ? bin2bcd(hour) : 0x00;
 237
 238        min = tm->tm_min;
 239        min = (min < 60) ? bin2bcd(min) : 0x00;
 240
 241        sec = tm->tm_sec;
 242        sec = (sec < 60) ? bin2bcd(sec) : 0x00;
 243
 244        spin_lock_irqsave(&m48t59->lock, flags);
 245        /* Issue the WRITE command */
 246        M48T59_SET_BITS(M48T59_CNTL_WRITE, M48T59_CNTL);
 247
 248        M48T59_WRITE(mday, M48T59_ALARM_DATE);
 249        M48T59_WRITE(hour, M48T59_ALARM_HOUR);
 250        M48T59_WRITE(min, M48T59_ALARM_MIN);
 251        M48T59_WRITE(sec, M48T59_ALARM_SEC);
 252
 253        /* Clear the WRITE bit */
 254        M48T59_CLEAR_BITS(M48T59_CNTL_WRITE, M48T59_CNTL);
 255        spin_unlock_irqrestore(&m48t59->lock, flags);
 256
 257        dev_dbg(dev, "RTC set alarm time %04d-%02d-%02d %02d/%02d/%02d\n",
 258                year + 1900, tm->tm_mon, tm->tm_mday,
 259                tm->tm_hour, tm->tm_min, tm->tm_sec);
 260        return 0;
 261}
 262
 263/*
 264 * Handle commands from user-space
 265 */
 266static int m48t59_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 267{
 268        struct platform_device *pdev = to_platform_device(dev);
 269        struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
 270        struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
 271        unsigned long flags;
 272
 273        spin_lock_irqsave(&m48t59->lock, flags);
 274        if (enabled)
 275                M48T59_WRITE(M48T59_INTR_AFE, M48T59_INTR);
 276        else
 277                M48T59_WRITE(0x00, M48T59_INTR);
 278        spin_unlock_irqrestore(&m48t59->lock, flags);
 279
 280        return 0;
 281}
 282
 283static int m48t59_rtc_proc(struct device *dev, struct seq_file *seq)
 284{
 285        struct platform_device *pdev = to_platform_device(dev);
 286        struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
 287        struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
 288        unsigned long flags;
 289        u8 val;
 290
 291        spin_lock_irqsave(&m48t59->lock, flags);
 292        val = M48T59_READ(M48T59_FLAGS);
 293        spin_unlock_irqrestore(&m48t59->lock, flags);
 294
 295        seq_printf(seq, "battery\t\t: %s\n",
 296                 (val & M48T59_FLAGS_BF) ? "low" : "normal");
 297        return 0;
 298}
 299
 300/*
 301 * IRQ handler for the RTC
 302 */
 303static irqreturn_t m48t59_rtc_interrupt(int irq, void *dev_id)
 304{
 305        struct device *dev = (struct device *)dev_id;
 306        struct platform_device *pdev = to_platform_device(dev);
 307        struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
 308        struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
 309        u8 event;
 310
 311        spin_lock(&m48t59->lock);
 312        event = M48T59_READ(M48T59_FLAGS);
 313        spin_unlock(&m48t59->lock);
 314
 315        if (event & M48T59_FLAGS_AF) {
 316                rtc_update_irq(m48t59->rtc, 1, (RTC_AF | RTC_IRQF));
 317                return IRQ_HANDLED;
 318        }
 319
 320        return IRQ_NONE;
 321}
 322
 323static const struct rtc_class_ops m48t59_rtc_ops = {
 324        .read_time      = m48t59_rtc_read_time,
 325        .set_time       = m48t59_rtc_set_time,
 326        .read_alarm     = m48t59_rtc_readalarm,
 327        .set_alarm      = m48t59_rtc_setalarm,
 328        .proc           = m48t59_rtc_proc,
 329        .alarm_irq_enable = m48t59_rtc_alarm_irq_enable,
 330};
 331
 332static const struct rtc_class_ops m48t02_rtc_ops = {
 333        .read_time      = m48t59_rtc_read_time,
 334        .set_time       = m48t59_rtc_set_time,
 335};
 336
 337static ssize_t m48t59_nvram_read(struct file *filp, struct kobject *kobj,
 338                                struct bin_attribute *bin_attr,
 339                                char *buf, loff_t pos, size_t size)
 340{
 341        struct device *dev = container_of(kobj, struct device, kobj);
 342        struct platform_device *pdev = to_platform_device(dev);
 343        struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
 344        struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
 345        ssize_t cnt = 0;
 346        unsigned long flags;
 347
 348        spin_lock_irqsave(&m48t59->lock, flags);
 349
 350        for (; cnt < size; cnt++)
 351                *buf++ = M48T59_READ(cnt);
 352
 353        spin_unlock_irqrestore(&m48t59->lock, flags);
 354
 355        return cnt;
 356}
 357
 358static ssize_t m48t59_nvram_write(struct file *filp, struct kobject *kobj,
 359                                struct bin_attribute *bin_attr,
 360                                char *buf, loff_t pos, size_t size)
 361{
 362        struct device *dev = container_of(kobj, struct device, kobj);
 363        struct platform_device *pdev = to_platform_device(dev);
 364        struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
 365        struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
 366        ssize_t cnt = 0;
 367        unsigned long flags;
 368
 369        spin_lock_irqsave(&m48t59->lock, flags);
 370
 371        for (; cnt < size; cnt++)
 372                M48T59_WRITE(*buf++, cnt);
 373
 374        spin_unlock_irqrestore(&m48t59->lock, flags);
 375
 376        return cnt;
 377}
 378
 379static struct bin_attribute m48t59_nvram_attr = {
 380        .attr = {
 381                .name = "nvram",
 382                .mode = S_IRUGO | S_IWUSR,
 383        },
 384        .read = m48t59_nvram_read,
 385        .write = m48t59_nvram_write,
 386};
 387
 388static int m48t59_rtc_probe(struct platform_device *pdev)
 389{
 390        struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
 391        struct m48t59_private *m48t59 = NULL;
 392        struct resource *res;
 393        int ret = -ENOMEM;
 394        char *name;
 395        const struct rtc_class_ops *ops;
 396
 397        /* This chip could be memory-mapped or I/O-mapped */
 398        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 399        if (!res) {
 400                res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 401                if (!res)
 402                        return -EINVAL;
 403        }
 404
 405        if (res->flags & IORESOURCE_IO) {
 406                /* If we are I/O-mapped, the platform should provide
 407                 * the operations accessing chip registers.
 408                 */
 409                if (!pdata || !pdata->write_byte || !pdata->read_byte)
 410                        return -EINVAL;
 411        } else if (res->flags & IORESOURCE_MEM) {
 412                /* we are memory-mapped */
 413                if (!pdata) {
 414                        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata),
 415                                                GFP_KERNEL);
 416                        if (!pdata)
 417                                return -ENOMEM;
 418                        /* Ensure we only kmalloc platform data once */
 419                        pdev->dev.platform_data = pdata;
 420                }
 421                if (!pdata->type)
 422                        pdata->type = M48T59RTC_TYPE_M48T59;
 423
 424                /* Try to use the generic memory read/write ops */
 425                if (!pdata->write_byte)
 426                        pdata->write_byte = m48t59_mem_writeb;
 427                if (!pdata->read_byte)
 428                        pdata->read_byte = m48t59_mem_readb;
 429        }
 430
 431        m48t59 = devm_kzalloc(&pdev->dev, sizeof(*m48t59), GFP_KERNEL);
 432        if (!m48t59)
 433                return -ENOMEM;
 434
 435        m48t59->ioaddr = pdata->ioaddr;
 436
 437        if (!m48t59->ioaddr) {
 438                /* ioaddr not mapped externally */
 439                m48t59->ioaddr = devm_ioremap(&pdev->dev, res->start,
 440                                                resource_size(res));
 441                if (!m48t59->ioaddr)
 442                        return ret;
 443        }
 444
 445        /* Try to get irq number. We also can work in
 446         * the mode without IRQ.
 447         */
 448        m48t59->irq = platform_get_irq(pdev, 0);
 449        if (m48t59->irq <= 0)
 450                m48t59->irq = NO_IRQ;
 451
 452        if (m48t59->irq != NO_IRQ) {
 453                ret = devm_request_irq(&pdev->dev, m48t59->irq,
 454                                m48t59_rtc_interrupt, IRQF_SHARED,
 455                                "rtc-m48t59", &pdev->dev);
 456                if (ret)
 457                        return ret;
 458        }
 459        switch (pdata->type) {
 460        case M48T59RTC_TYPE_M48T59:
 461                name = "m48t59";
 462                ops = &m48t59_rtc_ops;
 463                pdata->offset = 0x1ff0;
 464                break;
 465        case M48T59RTC_TYPE_M48T02:
 466                name = "m48t02";
 467                ops = &m48t02_rtc_ops;
 468                pdata->offset = 0x7f0;
 469                break;
 470        case M48T59RTC_TYPE_M48T08:
 471                name = "m48t08";
 472                ops = &m48t02_rtc_ops;
 473                pdata->offset = 0x1ff0;
 474                break;
 475        default:
 476                dev_err(&pdev->dev, "Unknown RTC type\n");
 477                return -ENODEV;
 478        }
 479
 480        spin_lock_init(&m48t59->lock);
 481        platform_set_drvdata(pdev, m48t59);
 482
 483        m48t59->rtc = devm_rtc_device_register(&pdev->dev, name, ops,
 484                                                THIS_MODULE);
 485        if (IS_ERR(m48t59->rtc))
 486                return PTR_ERR(m48t59->rtc);
 487
 488        m48t59_nvram_attr.size = pdata->offset;
 489
 490        ret = sysfs_create_bin_file(&pdev->dev.kobj, &m48t59_nvram_attr);
 491        if (ret)
 492                return ret;
 493
 494        return 0;
 495}
 496
 497static int m48t59_rtc_remove(struct platform_device *pdev)
 498{
 499        sysfs_remove_bin_file(&pdev->dev.kobj, &m48t59_nvram_attr);
 500        return 0;
 501}
 502
 503/* work with hotplug and coldplug */
 504MODULE_ALIAS("platform:rtc-m48t59");
 505
 506static struct platform_driver m48t59_rtc_driver = {
 507        .driver         = {
 508                .name   = "rtc-m48t59",
 509        },
 510        .probe          = m48t59_rtc_probe,
 511        .remove         = m48t59_rtc_remove,
 512};
 513
 514module_platform_driver(m48t59_rtc_driver);
 515
 516MODULE_AUTHOR("Mark Zhan <rongkai.zhan@windriver.com>");
 517MODULE_DESCRIPTION("M48T59/M48T02/M48T08 RTC driver");
 518MODULE_LICENSE("GPL");
 519