![Linus Torvalds](/assets/img/avatar_default.png)
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!
370 lines
7.9 KiB
C
370 lines
7.9 KiB
C
/*
|
|
* 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);
|