aboutsummaryrefslogtreecommitdiff
path: root/drivers/acorn/char/i2c.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/acorn/char/i2c.c')
-rw-r--r--drivers/acorn/char/i2c.c369
1 files changed, 369 insertions, 0 deletions
diff --git a/drivers/acorn/char/i2c.c b/drivers/acorn/char/i2c.c
new file mode 100644
index 00000000000..c22bb9dca1e
--- /dev/null
+++ b/drivers/acorn/char/i2c.c
@@ -0,0 +1,369 @@
+/*
+ * linux/drivers/acorn/char/i2c.c
+ *
+ * Copyright (C) 2000 Russell King
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ARM IOC/IOMD i2c driver.
+ *
+ * On Acorn machines, the following i2c devices are on the bus:
+ * - PCF8583 real time clock & static RAM
+ */
+#include <linux/init.h>
+#include <linux/sched.h>
+#include <linux/time.h>
+#include <linux/miscdevice.h>
+#include <linux/rtc.h>
+#include <linux/i2c.h>
+#include <linux/i2c-algo-bit.h>
+#include <linux/fs.h>
+
+#include <asm/hardware.h>
+#include <asm/io.h>
+#include <asm/hardware/ioc.h>
+#include <asm/system.h>
+#include <asm/uaccess.h>
+
+#include "pcf8583.h"
+
+extern int (*set_rtc)(void);
+
+static struct i2c_client *rtc_client;
+static const unsigned char days_in_mon[] =
+ { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+
+#define CMOS_CHECKSUM (63)
+
+/*
+ * Acorn machines store the year in the static RAM at
+ * location 128.
+ */
+#define CMOS_YEAR (64 + 128)
+
+static inline int rtc_command(int cmd, void *data)
+{
+ int ret = -EIO;
+
+ if (rtc_client)
+ ret = rtc_client->driver->command(rtc_client, cmd, data);
+
+ return ret;
+}
+
+/*
+ * Update the century + year bytes in the CMOS RAM, ensuring
+ * that the check byte is correctly adjusted for the change.
+ */
+static int rtc_update_year(unsigned int new_year)
+{
+ unsigned char yr[2], chk;
+ struct mem cmos_year = { CMOS_YEAR, sizeof(yr), yr };
+ struct mem cmos_check = { CMOS_CHECKSUM, 1, &chk };
+ int ret;
+
+ ret = rtc_command(MEM_READ, &cmos_check);
+ if (ret)
+ goto out;
+ ret = rtc_command(MEM_READ, &cmos_year);
+ if (ret)
+ goto out;
+
+ chk -= yr[1] + yr[0];
+
+ yr[1] = new_year / 100;
+ yr[0] = new_year % 100;
+
+ chk += yr[1] + yr[0];
+
+ ret = rtc_command(MEM_WRITE, &cmos_year);
+ if (ret == 0)
+ ret = rtc_command(MEM_WRITE, &cmos_check);
+ out:
+ return ret;
+}
+
+/*
+ * Read the current RTC time and date, and update xtime.
+ */
+static void get_rtc_time(struct rtc_tm *rtctm, unsigned int *year)
+{
+ unsigned char ctrl, yr[2];
+ struct mem rtcmem = { CMOS_YEAR, sizeof(yr), yr };
+ int real_year, year_offset;
+
+ /*
+ * Ensure that the RTC is running.
+ */
+ rtc_command(RTC_GETCTRL, &ctrl);
+ if (ctrl & 0xc0) {
+ unsigned char new_ctrl = ctrl & ~0xc0;
+
+ printk(KERN_WARNING "RTC: resetting control %02x -> %02x\n",
+ ctrl, new_ctrl);
+
+ rtc_command(RTC_SETCTRL, &new_ctrl);
+ }
+
+ if (rtc_command(RTC_GETDATETIME, rtctm) ||
+ rtc_command(MEM_READ, &rtcmem))
+ return;
+
+ real_year = yr[0];
+
+ /*
+ * The RTC year holds the LSB two bits of the current
+ * year, which should reflect the LSB two bits of the
+ * CMOS copy of the year. Any difference indicates
+ * that we have to correct the CMOS version.
+ */
+ year_offset = rtctm->year_off - (real_year & 3);
+ if (year_offset < 0)
+ /*
+ * RTC year wrapped. Adjust it appropriately.
+ */
+ year_offset += 4;
+
+ *year = real_year + year_offset + yr[1] * 100;
+}
+
+static int set_rtc_time(struct rtc_tm *rtctm, unsigned int year)
+{
+ unsigned char leap;
+ int ret;
+
+ leap = (!(year % 4) && (year % 100)) || !(year % 400);
+
+ if (rtctm->mon > 12 || rtctm->mon == 0 || rtctm->mday == 0)
+ return -EINVAL;
+
+ if (rtctm->mday > (days_in_mon[rtctm->mon] + (rtctm->mon == 2 && leap)))
+ return -EINVAL;
+
+ if (rtctm->hours >= 24 || rtctm->mins >= 60 || rtctm->secs >= 60)
+ return -EINVAL;
+
+ /*
+ * The RTC's own 2-bit year must reflect the least
+ * significant two bits of the CMOS year.
+ */
+ rtctm->year_off = (year % 100) & 3;
+
+ ret = rtc_command(RTC_SETDATETIME, rtctm);
+ if (ret == 0)
+ ret = rtc_update_year(year);
+
+ return ret;
+}
+
+/*
+ * Set the RTC time only. Note that
+ * we do not touch the date.
+ */
+static int k_set_rtc_time(void)
+{
+ struct rtc_tm new_rtctm, old_rtctm;
+ unsigned long nowtime = xtime.tv_sec;
+
+ if (rtc_command(RTC_GETDATETIME, &old_rtctm))
+ return 0;
+
+ new_rtctm.cs = xtime.tv_nsec / 10000000;
+ new_rtctm.secs = nowtime % 60; nowtime /= 60;
+ new_rtctm.mins = nowtime % 60; nowtime /= 60;
+ new_rtctm.hours = nowtime % 24;
+
+ /*
+ * avoid writing when we're going to change the day
+ * of the month. We will retry in the next minute.
+ * This basically means that if the RTC must not drift
+ * by more than 1 minute in 11 minutes.
+ *
+ * [ rtc: 1/1/2000 23:58:00, real 2/1/2000 00:01:00,
+ * rtc gets set to 1/1/2000 00:01:00 ]
+ */
+ if ((old_rtctm.hours == 23 && old_rtctm.mins == 59) ||
+ (new_rtctm.hours == 23 && new_rtctm.mins == 59))
+ return 1;
+
+ return rtc_command(RTC_SETTIME, &new_rtctm);
+}
+
+static int rtc_ioctl(struct inode *inode, struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ unsigned int year;
+ struct rtc_time rtctm;
+ struct rtc_tm rtc_raw;
+
+ switch (cmd) {
+ case RTC_ALM_READ:
+ case RTC_ALM_SET:
+ break;
+
+ case RTC_RD_TIME:
+ memset(&rtctm, 0, sizeof(struct rtc_time));
+ get_rtc_time(&rtc_raw, &year);
+ rtctm.tm_sec = rtc_raw.secs;
+ rtctm.tm_min = rtc_raw.mins;
+ rtctm.tm_hour = rtc_raw.hours;
+ rtctm.tm_mday = rtc_raw.mday;
+ rtctm.tm_mon = rtc_raw.mon - 1; /* month starts at 0 */
+ rtctm.tm_year = year - 1900; /* starts at 1900 */
+ return copy_to_user((void *)arg, &rtctm, sizeof(rtctm))
+ ? -EFAULT : 0;
+
+ case RTC_SET_TIME:
+ if (!capable(CAP_SYS_TIME))
+ return -EACCES;
+
+ if (copy_from_user(&rtctm, (void *)arg, sizeof(rtctm)))
+ return -EFAULT;
+ rtc_raw.secs = rtctm.tm_sec;
+ rtc_raw.mins = rtctm.tm_min;
+ rtc_raw.hours = rtctm.tm_hour;
+ rtc_raw.mday = rtctm.tm_mday;
+ rtc_raw.mon = rtctm.tm_mon + 1;
+ year = rtctm.tm_year + 1900;
+ return set_rtc_time(&rtc_raw, year);
+ break;
+
+ case RTC_EPOCH_READ:
+ return put_user(1900, (unsigned long *)arg);
+
+ }
+ return -EINVAL;
+}
+
+static struct file_operations rtc_fops = {
+ .ioctl = rtc_ioctl,
+};
+
+static struct miscdevice rtc_dev = {
+ .minor = RTC_MINOR,
+ .name = "rtc",
+ .fops = &rtc_fops,
+};
+
+/* IOC / IOMD i2c driver */
+
+#define FORCE_ONES 0xdc
+#define SCL 0x02
+#define SDA 0x01
+
+/*
+ * We must preserve all non-i2c output bits in IOC_CONTROL.
+ * Note also that we need to preserve the value of SCL and
+ * SDA outputs as well (which may be different from the
+ * values read back from IOC_CONTROL).
+ */
+static u_int force_ones;
+
+static void ioc_setscl(void *data, int state)
+{
+ u_int ioc_control = ioc_readb(IOC_CONTROL) & ~(SCL | SDA);
+ u_int ones = force_ones;
+
+ if (state)
+ ones |= SCL;
+ else
+ ones &= ~SCL;
+
+ force_ones = ones;
+
+ ioc_writeb(ioc_control | ones, IOC_CONTROL);
+}
+
+static void ioc_setsda(void *data, int state)
+{
+ u_int ioc_control = ioc_readb(IOC_CONTROL) & ~(SCL | SDA);
+ u_int ones = force_ones;
+
+ if (state)
+ ones |= SDA;
+ else
+ ones &= ~SDA;
+
+ force_ones = ones;
+
+ ioc_writeb(ioc_control | ones, IOC_CONTROL);
+}
+
+static int ioc_getscl(void *data)
+{
+ return (ioc_readb(IOC_CONTROL) & SCL) != 0;
+}
+
+static int ioc_getsda(void *data)
+{
+ return (ioc_readb(IOC_CONTROL) & SDA) != 0;
+}
+
+static struct i2c_algo_bit_data ioc_data = {
+ .setsda = ioc_setsda,
+ .setscl = ioc_setscl,
+ .getsda = ioc_getsda,
+ .getscl = ioc_getscl,
+ .udelay = 80,
+ .mdelay = 80,
+ .timeout = 100
+};
+
+static int ioc_client_reg(struct i2c_client *client)
+{
+ if (client->driver->id == I2C_DRIVERID_PCF8583 &&
+ client->addr == 0x50) {
+ struct rtc_tm rtctm;
+ unsigned int year;
+ struct timespec tv;
+
+ rtc_client = client;
+ get_rtc_time(&rtctm, &year);
+
+ tv.tv_nsec = rtctm.cs * 10000000;
+ tv.tv_sec = mktime(year, rtctm.mon, rtctm.mday,
+ rtctm.hours, rtctm.mins, rtctm.secs);
+ do_settimeofday(&tv);
+ set_rtc = k_set_rtc_time;
+ }
+
+ return 0;
+}
+
+static int ioc_client_unreg(struct i2c_client *client)
+{
+ if (client == rtc_client) {
+ set_rtc = NULL;
+ rtc_client = NULL;
+ }
+
+ return 0;
+}
+
+static struct i2c_adapter ioc_ops = {
+ .id = I2C_HW_B_IOC,
+ .algo_data = &ioc_data,
+ .client_register = ioc_client_reg,
+ .client_unregister = ioc_client_unreg,
+};
+
+static int __init i2c_ioc_init(void)
+{
+ int ret;
+
+ force_ones = FORCE_ONES | SCL | SDA;
+
+ ret = i2c_bit_add_bus(&ioc_ops);
+
+ if (ret >= 0){
+ ret = misc_register(&rtc_dev);
+ if(ret < 0)
+ i2c_bit_del_bus(&ioc_ops);
+ }
+
+ return ret;
+}
+
+__initcall(i2c_ioc_init);