diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 15:20:36 -0700 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 15:20:36 -0700 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/acorn/char/i2c.c |
Linux-2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'drivers/acorn/char/i2c.c')
-rw-r--r-- | drivers/acorn/char/i2c.c | 369 |
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 000000000000..c22bb9dca1ec --- /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); |