1da177e4c3
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!
394 lines
8.8 KiB
C
394 lines
8.8 KiB
C
/*
|
|
* linux/drivers/i2c/chips/rtc8564.c
|
|
*
|
|
* Copyright (C) 2002-2004 Stefan Eletzhofer
|
|
*
|
|
* based on linux/drivers/acron/char/pcf8583.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.
|
|
*
|
|
* Driver for system3's EPSON RTC 8564 chip
|
|
*/
|
|
#include <linux/module.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/string.h>
|
|
#include <linux/rtc.h> /* get the user-level API */
|
|
#include <linux/init.h>
|
|
#include <linux/init.h>
|
|
|
|
#include "rtc8564.h"
|
|
|
|
#ifdef DEBUG
|
|
# define _DBG(x, fmt, args...) do{ if (debug>=x) printk(KERN_DEBUG"%s: " fmt "\n", __FUNCTION__, ##args); } while(0);
|
|
#else
|
|
# define _DBG(x, fmt, args...) do { } while(0);
|
|
#endif
|
|
|
|
#define _DBGRTCTM(x, rtctm) if (debug>=x) printk("%s: secs=%d, mins=%d, hours=%d, mday=%d, " \
|
|
"mon=%d, year=%d, wday=%d VL=%d\n", __FUNCTION__, \
|
|
(rtctm).secs, (rtctm).mins, (rtctm).hours, (rtctm).mday, \
|
|
(rtctm).mon, (rtctm).year, (rtctm).wday, (rtctm).vl);
|
|
|
|
struct rtc8564_data {
|
|
struct i2c_client client;
|
|
u16 ctrl;
|
|
};
|
|
|
|
static inline u8 _rtc8564_ctrl1(struct i2c_client *client)
|
|
{
|
|
struct rtc8564_data *data = i2c_get_clientdata(client);
|
|
return data->ctrl & 0xff;
|
|
}
|
|
static inline u8 _rtc8564_ctrl2(struct i2c_client *client)
|
|
{
|
|
struct rtc8564_data *data = i2c_get_clientdata(client);
|
|
return (data->ctrl & 0xff00) >> 8;
|
|
}
|
|
|
|
#define CTRL1(c) _rtc8564_ctrl1(c)
|
|
#define CTRL2(c) _rtc8564_ctrl2(c)
|
|
|
|
#define BCD_TO_BIN(val) (((val)&15) + ((val)>>4)*10)
|
|
#define BIN_TO_BCD(val) ((((val)/10)<<4) + (val)%10)
|
|
|
|
static int debug;;
|
|
module_param(debug, int, S_IRUGO | S_IWUSR);
|
|
|
|
static struct i2c_driver rtc8564_driver;
|
|
|
|
static unsigned short ignore[] = { I2C_CLIENT_END };
|
|
static unsigned short normal_addr[] = { 0x51, I2C_CLIENT_END };
|
|
|
|
static struct i2c_client_address_data addr_data = {
|
|
.normal_i2c = normal_addr,
|
|
.normal_i2c_range = ignore,
|
|
.probe = ignore,
|
|
.probe_range = ignore,
|
|
.ignore = ignore,
|
|
.ignore_range = ignore,
|
|
.force = ignore,
|
|
};
|
|
|
|
static int rtc8564_read_mem(struct i2c_client *client, struct mem *mem);
|
|
static int rtc8564_write_mem(struct i2c_client *client, struct mem *mem);
|
|
|
|
static int rtc8564_read(struct i2c_client *client, unsigned char adr,
|
|
unsigned char *buf, unsigned char len)
|
|
{
|
|
int ret = -EIO;
|
|
unsigned char addr[1] = { adr };
|
|
struct i2c_msg msgs[2] = {
|
|
{client->addr, 0, 1, addr},
|
|
{client->addr, I2C_M_RD, len, buf}
|
|
};
|
|
|
|
_DBG(1, "client=%p, adr=%d, buf=%p, len=%d", client, adr, buf, len);
|
|
|
|
if (!buf) {
|
|
ret = -EINVAL;
|
|
goto done;
|
|
}
|
|
|
|
ret = i2c_transfer(client->adapter, msgs, 2);
|
|
if (ret == 2) {
|
|
ret = 0;
|
|
}
|
|
|
|
done:
|
|
return ret;
|
|
}
|
|
|
|
static int rtc8564_write(struct i2c_client *client, unsigned char adr,
|
|
unsigned char *data, unsigned char len)
|
|
{
|
|
int ret = 0;
|
|
unsigned char _data[16];
|
|
struct i2c_msg wr;
|
|
int i;
|
|
|
|
if (!data || len > 15) {
|
|
ret = -EINVAL;
|
|
goto done;
|
|
}
|
|
|
|
_DBG(1, "client=%p, adr=%d, buf=%p, len=%d", client, adr, data, len);
|
|
|
|
_data[0] = adr;
|
|
for (i = 0; i < len; i++) {
|
|
_data[i + 1] = data[i];
|
|
_DBG(5, "data[%d] = 0x%02x (%d)", i, data[i], data[i]);
|
|
}
|
|
|
|
wr.addr = client->addr;
|
|
wr.flags = 0;
|
|
wr.len = len + 1;
|
|
wr.buf = _data;
|
|
|
|
ret = i2c_transfer(client->adapter, &wr, 1);
|
|
if (ret == 1) {
|
|
ret = 0;
|
|
}
|
|
|
|
done:
|
|
return ret;
|
|
}
|
|
|
|
static int rtc8564_attach(struct i2c_adapter *adap, int addr, int kind)
|
|
{
|
|
int ret;
|
|
struct i2c_client *new_client;
|
|
struct rtc8564_data *d;
|
|
unsigned char data[10];
|
|
unsigned char ad[1] = { 0 };
|
|
struct i2c_msg ctrl_wr[1] = {
|
|
{addr, 0, 2, data}
|
|
};
|
|
struct i2c_msg ctrl_rd[2] = {
|
|
{addr, 0, 1, ad},
|
|
{addr, I2C_M_RD, 2, data}
|
|
};
|
|
|
|
d = kmalloc(sizeof(struct rtc8564_data), GFP_KERNEL);
|
|
if (!d) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
memset(d, 0, sizeof(struct rtc8564_data));
|
|
new_client = &d->client;
|
|
|
|
strlcpy(new_client->name, "RTC8564", I2C_NAME_SIZE);
|
|
i2c_set_clientdata(new_client, d);
|
|
new_client->flags = I2C_CLIENT_ALLOW_USE | I2C_DF_NOTIFY;
|
|
new_client->addr = addr;
|
|
new_client->adapter = adap;
|
|
new_client->driver = &rtc8564_driver;
|
|
|
|
_DBG(1, "client=%p", new_client);
|
|
|
|
/* init ctrl1 reg */
|
|
data[0] = 0;
|
|
data[1] = 0;
|
|
ret = i2c_transfer(new_client->adapter, ctrl_wr, 1);
|
|
if (ret != 1) {
|
|
printk(KERN_INFO "rtc8564: cant init ctrl1\n");
|
|
ret = -ENODEV;
|
|
goto done;
|
|
}
|
|
|
|
/* read back ctrl1 and ctrl2 */
|
|
ret = i2c_transfer(new_client->adapter, ctrl_rd, 2);
|
|
if (ret != 2) {
|
|
printk(KERN_INFO "rtc8564: cant read ctrl\n");
|
|
ret = -ENODEV;
|
|
goto done;
|
|
}
|
|
|
|
d->ctrl = data[0] | (data[1] << 8);
|
|
|
|
_DBG(1, "RTC8564_REG_CTRL1=%02x, RTC8564_REG_CTRL2=%02x",
|
|
data[0], data[1]);
|
|
|
|
ret = i2c_attach_client(new_client);
|
|
done:
|
|
if (ret) {
|
|
kfree(d);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int rtc8564_probe(struct i2c_adapter *adap)
|
|
{
|
|
return i2c_probe(adap, &addr_data, rtc8564_attach);
|
|
}
|
|
|
|
static int rtc8564_detach(struct i2c_client *client)
|
|
{
|
|
i2c_detach_client(client);
|
|
kfree(i2c_get_clientdata(client));
|
|
return 0;
|
|
}
|
|
|
|
static int rtc8564_get_datetime(struct i2c_client *client, struct rtc_tm *dt)
|
|
{
|
|
int ret = -EIO;
|
|
unsigned char buf[15];
|
|
|
|
_DBG(1, "client=%p, dt=%p", client, dt);
|
|
|
|
if (!dt)
|
|
return -EINVAL;
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
|
ret = rtc8564_read(client, 0, buf, 15);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* century stored in minute alarm reg */
|
|
dt->year = BCD_TO_BIN(buf[RTC8564_REG_YEAR]);
|
|
dt->year += 100 * BCD_TO_BIN(buf[RTC8564_REG_AL_MIN] & 0x3f);
|
|
dt->mday = BCD_TO_BIN(buf[RTC8564_REG_DAY] & 0x3f);
|
|
dt->wday = BCD_TO_BIN(buf[RTC8564_REG_WDAY] & 7);
|
|
dt->mon = BCD_TO_BIN(buf[RTC8564_REG_MON_CENT] & 0x1f);
|
|
|
|
dt->secs = BCD_TO_BIN(buf[RTC8564_REG_SEC] & 0x7f);
|
|
dt->vl = (buf[RTC8564_REG_SEC] & 0x80) == 0x80;
|
|
dt->mins = BCD_TO_BIN(buf[RTC8564_REG_MIN] & 0x7f);
|
|
dt->hours = BCD_TO_BIN(buf[RTC8564_REG_HR] & 0x3f);
|
|
|
|
_DBGRTCTM(2, *dt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
rtc8564_set_datetime(struct i2c_client *client, struct rtc_tm *dt, int datetoo)
|
|
{
|
|
int ret, len = 5;
|
|
unsigned char buf[15];
|
|
|
|
_DBG(1, "client=%p, dt=%p", client, dt);
|
|
|
|
if (!dt)
|
|
return -EINVAL;
|
|
|
|
_DBGRTCTM(2, *dt);
|
|
|
|
buf[RTC8564_REG_CTRL1] = CTRL1(client) | RTC8564_CTRL1_STOP;
|
|
buf[RTC8564_REG_CTRL2] = CTRL2(client);
|
|
buf[RTC8564_REG_SEC] = BIN_TO_BCD(dt->secs);
|
|
buf[RTC8564_REG_MIN] = BIN_TO_BCD(dt->mins);
|
|
buf[RTC8564_REG_HR] = BIN_TO_BCD(dt->hours);
|
|
|
|
if (datetoo) {
|
|
len += 5;
|
|
buf[RTC8564_REG_DAY] = BIN_TO_BCD(dt->mday);
|
|
buf[RTC8564_REG_WDAY] = BIN_TO_BCD(dt->wday);
|
|
buf[RTC8564_REG_MON_CENT] = BIN_TO_BCD(dt->mon) & 0x1f;
|
|
/* century stored in minute alarm reg */
|
|
buf[RTC8564_REG_YEAR] = BIN_TO_BCD(dt->year % 100);
|
|
buf[RTC8564_REG_AL_MIN] = BIN_TO_BCD(dt->year / 100);
|
|
}
|
|
|
|
ret = rtc8564_write(client, 0, buf, len);
|
|
if (ret) {
|
|
_DBG(1, "error writing data! %d", ret);
|
|
}
|
|
|
|
buf[RTC8564_REG_CTRL1] = CTRL1(client);
|
|
ret = rtc8564_write(client, 0, buf, 1);
|
|
if (ret) {
|
|
_DBG(1, "error writing data! %d", ret);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int rtc8564_get_ctrl(struct i2c_client *client, unsigned int *ctrl)
|
|
{
|
|
struct rtc8564_data *data = i2c_get_clientdata(client);
|
|
|
|
if (!ctrl)
|
|
return -1;
|
|
|
|
*ctrl = data->ctrl;
|
|
return 0;
|
|
}
|
|
|
|
static int rtc8564_set_ctrl(struct i2c_client *client, unsigned int *ctrl)
|
|
{
|
|
struct rtc8564_data *data = i2c_get_clientdata(client);
|
|
unsigned char buf[2];
|
|
|
|
if (!ctrl)
|
|
return -1;
|
|
|
|
buf[0] = *ctrl & 0xff;
|
|
buf[1] = (*ctrl & 0xff00) >> 8;
|
|
data->ctrl = *ctrl;
|
|
|
|
return rtc8564_write(client, 0, buf, 2);
|
|
}
|
|
|
|
static int rtc8564_read_mem(struct i2c_client *client, struct mem *mem)
|
|
{
|
|
|
|
if (!mem)
|
|
return -EINVAL;
|
|
|
|
return rtc8564_read(client, mem->loc, mem->data, mem->nr);
|
|
}
|
|
|
|
static int rtc8564_write_mem(struct i2c_client *client, struct mem *mem)
|
|
{
|
|
|
|
if (!mem)
|
|
return -EINVAL;
|
|
|
|
return rtc8564_write(client, mem->loc, mem->data, mem->nr);
|
|
}
|
|
|
|
static int
|
|
rtc8564_command(struct i2c_client *client, unsigned int cmd, void *arg)
|
|
{
|
|
|
|
_DBG(1, "cmd=%d", cmd);
|
|
|
|
switch (cmd) {
|
|
case RTC_GETDATETIME:
|
|
return rtc8564_get_datetime(client, arg);
|
|
|
|
case RTC_SETTIME:
|
|
return rtc8564_set_datetime(client, arg, 0);
|
|
|
|
case RTC_SETDATETIME:
|
|
return rtc8564_set_datetime(client, arg, 1);
|
|
|
|
case RTC_GETCTRL:
|
|
return rtc8564_get_ctrl(client, arg);
|
|
|
|
case RTC_SETCTRL:
|
|
return rtc8564_set_ctrl(client, arg);
|
|
|
|
case MEM_READ:
|
|
return rtc8564_read_mem(client, arg);
|
|
|
|
case MEM_WRITE:
|
|
return rtc8564_write_mem(client, arg);
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
static struct i2c_driver rtc8564_driver = {
|
|
.owner = THIS_MODULE,
|
|
.name = "RTC8564",
|
|
.id = I2C_DRIVERID_RTC8564,
|
|
.flags = I2C_DF_NOTIFY,
|
|
.attach_adapter = rtc8564_probe,
|
|
.detach_client = rtc8564_detach,
|
|
.command = rtc8564_command
|
|
};
|
|
|
|
static __init int rtc8564_init(void)
|
|
{
|
|
return i2c_add_driver(&rtc8564_driver);
|
|
}
|
|
|
|
static __exit void rtc8564_exit(void)
|
|
{
|
|
i2c_del_driver(&rtc8564_driver);
|
|
}
|
|
|
|
MODULE_AUTHOR("Stefan Eletzhofer <Stefan.Eletzhofer@eletztrick.de>");
|
|
MODULE_DESCRIPTION("EPSON RTC8564 Driver");
|
|
MODULE_LICENSE("GPL");
|
|
|
|
module_init(rtc8564_init);
|
|
module_exit(rtc8564_exit);
|