Subversion Repositories or1k

/*

 * linux/drivers/char/ds1742.c

 *

 * Dallas DS1742 Real Time Clock driver

 *

 * Copyright (C) 2003 TimeSys Corp.

 *                    S. James Hill (James.Hill@timesys.com)

 *                                  (sjhill@realitydiluted.com)

 *

 * Copyright (C) 2001 MontaVista Software Inc.

 *                    ahennessy@mvista.com

 *

 * Copyright (C) 2000-2001 Toshiba Corporation

 *

 *  This program is free software; you can redistribute it and/or modify it

 *  under the terms of the GNU General Public License as published by the

 *  Free Software Foundation; either version 2 of the License, or (at your

 *  option) any later version.

 *

 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED

 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

 *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS

 *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

 *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR

 *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE

 *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 *  You should have received a copy of the GNU General Public License along

 *  with this program; if not, write to the Free Software Foundation, Inc.,

 *  675 Mass Ave, Cambridge, MA 02139, USA.

 */

#include <linux/init.h>

#include <linux/kernel.h>

#include <linux/fcntl.h>

#include <linux/miscdevice.h>

#include <linux/module.h>

#include <linux/proc_fs.h>

#include <linux/spinlock.h>

#include <linux/types.h>

#include <asm/debug.h>

#include <asm/mc146818rtc.h>

#include <asm/time.h>

#include <asm/uaccess.h>

#define DS1742_VERSION          "2.0"

/*

 * Registers

 */

#define RTC_CONTROL             (rtc_base + 0x7f8)

#define RTC_CENTURY             (rtc_base + 0x7f8)

#define RTC_SECONDS             (rtc_base + 0x7f9)

#define RTC_MINUTES             (rtc_base + 0x7fa)

#define RTC_HOURS               (rtc_base + 0x7fb)

#define RTC_DAY                 (rtc_base + 0x7fc)

#define RTC_DATE                (rtc_base + 0x7fd)

#define RTC_MONTH               (rtc_base + 0x7fe)

#define RTC_YEAR                (rtc_base + 0x7ff)

#define RTC_CENTURY_MASK        0x3f

#define RTC_SECONDS_MASK        0x7f

#define RTC_DAY_MASK            0x07

/*

 * Bits in the Control/Century register

 */

#define RTC_WRITE               0x80

#define RTC_READ                0x40

/*

 * Bits in the Seconds register

 */

#define RTC_STOP                0x80

/*

 * Bits in the Day register

 */

#define RTC_BATT_FLAG           0x80

#define RTC_FREQ_TEST           0x40

/*

 * Conversion between binary and BCD

 */

#define BCD_TO_BIN(val)         (((val)&15) + ((val)>>4)*10)

#define BIN_TO_BCD(val)         ((((val)/10)<<4) + (val)%10)

/*

 * CMOS Year Epoch

 */

#define EPOCH                   2000

/*

 * The entry /dev/rtc is being used

 */

#define RTC_IS_OPEN             0x1

static unsigned long rtc_base = 0;

static unsigned long rtc_status = 0;

static spinlock_t rtc_lock;

extern void to_tm(unsigned long tim, struct rtc_time * tm);

static unsigned long rtc_ds1742_get_time(void)

{

        unsigned int year, month, day, hour, minute, second;

        unsigned int century;

        CMOS_WRITE(RTC_READ, RTC_CONTROL);

        second = BCD_TO_BIN(CMOS_READ(RTC_SECONDS) & RTC_SECONDS_MASK);

        minute = BCD_TO_BIN(CMOS_READ(RTC_MINUTES));

        hour = BCD_TO_BIN(CMOS_READ(RTC_HOURS));

        day = BCD_TO_BIN(CMOS_READ(RTC_DATE));

        month = BCD_TO_BIN(CMOS_READ(RTC_MONTH));

        year = BCD_TO_BIN(CMOS_READ(RTC_YEAR));

        century = BCD_TO_BIN(CMOS_READ(RTC_CENTURY) & RTC_CENTURY_MASK);

        CMOS_WRITE(0, RTC_CONTROL);

        year += century * 100;

        return mktime(year, month, day, hour, minute, second);

}

static int rtc_ds1742_set_time(unsigned long t)

{

        struct rtc_time tm;

        u8 year, month, day, hour, minute, second;

        u8 cmos_year, cmos_month, cmos_day, cmos_hour, cmos_minute, cmos_second;

        int cmos_century;

        CMOS_WRITE(RTC_READ, RTC_CONTROL);

        cmos_second = (u8)(CMOS_READ(RTC_SECONDS) & RTC_SECONDS_MASK);

        cmos_minute = (u8)CMOS_READ(RTC_MINUTES);

        cmos_hour = (u8)CMOS_READ(RTC_HOURS);

        cmos_day = (u8)CMOS_READ(RTC_DATE);

        cmos_month = (u8)CMOS_READ(RTC_MONTH);

        cmos_year = (u8)CMOS_READ(RTC_YEAR);

        cmos_century = CMOS_READ(RTC_CENTURY) & RTC_CENTURY_MASK;

        CMOS_WRITE(RTC_WRITE, RTC_CONTROL);

        /* convert */

        to_tm(t, &tm);

        /* check each field one by one */

        year = BIN_TO_BCD(tm.tm_year - EPOCH);

        if (year != cmos_year) {

                CMOS_WRITE(year,RTC_YEAR);

        }

        month = BIN_TO_BCD(tm.tm_mon + 1);

        if (month != (cmos_month & 0x1f)) {

                CMOS_WRITE((month & 0x1f) | (cmos_month & ~0x1f),RTC_MONTH);

        }

        day = BIN_TO_BCD(tm.tm_mday);

        if (day != cmos_day)

                CMOS_WRITE(day, RTC_DATE);

        if (cmos_hour & 0x40) {

                /* 12 hour format */

                hour = 0x40;

                if (tm.tm_hour > 12) {

                        hour |= 0x20 | (BIN_TO_BCD(hour-12) & 0x1f);

                } else {

                        hour |= BIN_TO_BCD(tm.tm_hour);

                }

        } else {

                /* 24 hour format */

                hour = BIN_TO_BCD(tm.tm_hour) & 0x3f;

        }

        if (hour != cmos_hour) CMOS_WRITE(hour, RTC_HOURS);

        minute = BIN_TO_BCD(tm.tm_min);

        if (minute !=  cmos_minute) {

                CMOS_WRITE(minute, RTC_MINUTES);

        }

        second = BIN_TO_BCD(tm.tm_sec);

        if (second !=  cmos_second) {

                CMOS_WRITE(second & RTC_SECONDS_MASK,RTC_SECONDS);

        }

        /* RTC_CENTURY and RTC_CONTROL share same address... */

        CMOS_WRITE(cmos_century, RTC_CONTROL);

        return 0;

}

void __init rtc_ds1742_init(unsigned long base)

{

        u8  cmos_second;

        /* remember the base */

        rtc_base = base;

        db_assert((rtc_base & 0xe0000000) == KSEG1);

        /* set the function pointers */

        rtc_get_time = rtc_ds1742_get_time;

        rtc_set_time = rtc_ds1742_set_time;

        /* clear oscillator stop bit */

        CMOS_WRITE(RTC_READ, RTC_CONTROL);

        cmos_second = (u8)(CMOS_READ(RTC_SECONDS) & RTC_SECONDS_MASK);

        CMOS_WRITE(RTC_WRITE, RTC_CONTROL);

        CMOS_WRITE(cmos_second, RTC_SECONDS); /* clear msb */

        CMOS_WRITE(0, RTC_CONTROL);

}

static int get_ds1742_status(char *buf)

{

        char *p;

        struct rtc_time tm;

        unsigned long curr_time;

        curr_time = rtc_ds1742_get_time();

        to_tm(curr_time, &tm);

        p = buf;

        /*

         * There is no way to tell if the luser has the RTC set for local

         * time or for Universal Standard Time (GMT). Probably local though.

         */

        p += sprintf(p,

                     "rtc_time\t: %02d:%02d:%02d\n"

                     "rtc_date\t: %04d-%02d-%02d\n"

                     "rtc_epoch\t: %04lu\n",

                     tm.tm_hour, tm.tm_min, tm.tm_sec,

                     tm.tm_year, tm.tm_mon + 1, tm.tm_mday, 0L);

        return p - buf;

}

static int ds1742_read_proc(char *page, char **start, off_t off, int count,

                                int *eof, void *data)

{

        int len = get_ds1742_status(page);

        if (len <= off + count)

                *eof = 1;

        *start = page + off;

        len -= off;

        if (len > count)

                len = count;

        if (len < 0)

                len = 0;

        return len;

}

void rtc_ds1742_wait(void)

{

        while (CMOS_READ(RTC_SECONDS) & 1);

        while (!(CMOS_READ(RTC_SECONDS) & 1));

}

static int ds1742_ioctl(struct inode *inode, struct file *file,

                                unsigned int cmd, unsigned long arg)

{

        struct rtc_time rtc_tm;

        ulong curr_time;

        switch (cmd) {

        case RTC_RD_TIME:       /* Read the time/date from RTC  */

                curr_time = rtc_ds1742_get_time();

                to_tm(curr_time, &rtc_tm);

                rtc_tm.tm_year -= 1900;

                return copy_to_user((void *) arg, &rtc_tm, sizeof(rtc_tm)) ?

                        -EFAULT : 0;

        case RTC_SET_TIME:      /* Set the RTC */

                if (!capable(CAP_SYS_TIME))

                        return -EACCES;

                if (copy_from_user(&rtc_tm,

                                   (struct rtc_time *) arg,

                                   sizeof(struct rtc_time)))

                        return -EFAULT;

                curr_time = mktime(rtc_tm.tm_year + 1900,

                                   rtc_tm.tm_mon + 1, /* tm_mon starts from 0 */

                                   rtc_tm.tm_mday,

                                   rtc_tm.tm_hour,

                                   rtc_tm.tm_min,

                                   rtc_tm.tm_sec);

                return rtc_ds1742_set_time(curr_time);

        default:

                return -EINVAL;

        }

}

static int ds1742_open(struct inode *inode, struct file *file)

{

        spin_lock_irq(&rtc_lock);

        if (rtc_status & RTC_IS_OPEN) {

                spin_unlock_irq(&rtc_lock);

                return -EBUSY;

        }

        rtc_status |= RTC_IS_OPEN;

        spin_unlock_irq(&rtc_lock);

        return 0;

}

static int ds1742_release(struct inode *inode, struct file *file)

{

        spin_lock_irq(&rtc_lock);

        rtc_status &= ~RTC_IS_OPEN;

        spin_unlock_irq(&rtc_lock);

        return 0;

}

static struct file_operations ds1742_fops = {

        owner:THIS_MODULE,

        llseek:no_llseek,

        ioctl:ds1742_ioctl,

        open:ds1742_open,

        release:ds1742_release,

};

static struct miscdevice ds1742_dev = {

        RTC_MINOR,

        "rtc",

        &ds1742_fops

};

static int __init ds1742_init(void)

{

        printk(KERN_INFO "DS1742 Real Time Clock Driver v%s\n", DS1742_VERSION);

        misc_register(&ds1742_dev);

        create_proc_read_entry("driver/rtc", 0, 0, ds1742_read_proc, NULL);

        return 0;

}

static void __exit ds1742_exit(void)

{

        remove_proc_entry("driver/rtc", NULL);

        misc_deregister(&ds1742_dev);

}

module_init(ds1742_init);

module_exit(ds1742_exit);

EXPORT_NO_SYMBOLS;

MODULE_AUTHOR("Steven J. Hill");

MODULE_LICENSE("GPL");