kernel / drivers / i2c / chips / m41t00.c

/*
 * I2C client/driver for the ST M41T00 family of i2c rtc chips.
 *
 * Author: Mark A. Greer <[e-mail]>
 *
 * 2005, 2006 (c) MontaVista Software, Inc. This file is licensed under
 * the terms of the GNU General Public License version 2. This program
 * is licensed "as is" without any warranty of any kind, whether express
 * or implied.
 */
/*
 * This i2c client/driver wedges between the drivers/char/genrtc.c RTC
 * interface and the SMBus interface of the i2c subsystem.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/i2c.h>
#include <linux/rtc.h>
#include <linux/bcd.h>
#include <linux/workqueue.h>
#include <linux/platform_device.h>
#include <linux/m41t00.h>
#include <asm/time.h>
#include <asm/rtc.h>

static struct i2c_driver m41t00_driver;
static struct i2c_client *save_client;

static unsigned short ignore[] = { I2C_CLIENT_END };
static unsigned short normal_addr[] = { I2C_CLIENT_END, I2C_CLIENT_END };

static struct i2c_client_address_data addr_data = {
	.normal_i2c	= normal_addr,
	.probe		= ignore,
	.ignore		= ignore,
};

struct m41t00_chip_info {
	u8	type;
	char	*name;
	u8	read_limit;
	u8	sec;		/* Offsets for chip regs */
	u8	min;
	u8	hour;
	u8	day;
	u8	mon;
	u8	year;
	u8	alarm_mon;
	u8	alarm_hour;
	u8	sqw;
	u8	sqw_freq;
};

static struct m41t00_chip_info m41t00_chip_info_tbl[] = {
	{
		.type		= M41T00_TYPE_M41T00,
		.name		= "m41t00",
		.read_limit	= 5,
		.sec		= 0,
		.min		= 1,
		.hour		= 2,
		.day		= 4,
		.mon		= 5,
		.year		= 6,
	},
	{
		.type		= M41T00_TYPE_M41T81,
		.name		= "m41t81",
		.read_limit	= 1,
		.sec		= 1,
		.min		= 2,
		.hour		= 3,
		.day		= 5,
		.mon		= 6,
		.year		= 7,
		.alarm_mon	= 0xa,
		.alarm_hour	= 0xc,
		.sqw		= 0x13,
	},
	{
		.type		= M41T00_TYPE_M41T85,
		.name		= "m41t85",
		.read_limit	= 1,
		.sec		= 1,
		.min		= 2,
		.hour		= 3,
		.day		= 5,
		.mon		= 6,
		.year		= 7,
		.alarm_mon	= 0xa,
		.alarm_hour	= 0xc,
		.sqw		= 0x13,
	},
};
static struct m41t00_chip_info *m41t00_chip;

ulong
m41t00_get_rtc_time(void)
{
	s32 sec, min, hour, day, mon, year;
	s32 sec1, min1, hour1, day1, mon1, year1;
	u8 reads = 0;
	u8 buf[8], msgbuf[1] = { 0 }; /* offset into rtc's regs */
	struct i2c_msg msgs[] = {
		{
			.addr	= save_client->addr,
			.flags	= 0,
			.len	= 1,
			.buf	= msgbuf,
		},
		{
			.addr	= save_client->addr,
			.flags	= I2C_M_RD,
			.len	= 8,
			.buf	= buf,
		},
	};

	sec = min = hour = day = mon = year = 0;

	do {
		if (i2c_transfer(save_client->adapter, msgs, 2) < 0)
			goto read_err;

		sec1 = sec;
		min1 = min;
		hour1 = hour;
		day1 = day;
		mon1 = mon;
		year1 = year;

		sec = buf[m41t00_chip->sec] & 0x7f;
		min = buf[m41t00_chip->min] & 0x7f;
		hour = buf[m41t00_chip->hour] & 0x3f;
		day = buf[m41t00_chip->day] & 0x3f;
		mon = buf[m41t00_chip->mon] & 0x1f;
		year = buf[m41t00_chip->year];
	} while ((++reads < m41t00_chip->read_limit) && ((sec != sec1)
			|| (min != min1) || (hour != hour1) || (day != day1)
			|| (mon != mon1) || (year != year1)));

	if ((m41t00_chip->read_limit > 1) && ((sec != sec1) || (min != min1)
			|| (hour != hour1) || (day != day1) || (mon != mon1)
			|| (year != year1)))
		goto read_err;

	sec = BCD2BIN(sec);
	min = BCD2BIN(min);
	hour = BCD2BIN(hour);
	day = BCD2BIN(day);
	mon = BCD2BIN(mon);
	year = BCD2BIN(year);

	year += 1900;
	if (year < 1970)
		year += 100;

	return mktime(year, mon, day, hour, min, sec);

read_err:
	dev_err(&save_client->dev, "m41t00_get_rtc_time: Read error\n");
	return 0;
}
EXPORT_SYMBOL_GPL(m41t00_get_rtc_time);

static void
m41t00_set(void *arg)
{
	struct rtc_time	tm;
	int nowtime = *(int *)arg;
	s32 sec, min, hour, day, mon, year;
	u8 wbuf[9], *buf = &wbuf[1], msgbuf[1] = { 0 };
	struct i2c_msg msgs[] = {
		{
			.addr	= save_client->addr,
			.flags	= 0,
			.len	= 1,
			.buf	= msgbuf,
		},
		{
			.addr	= save_client->addr,
			.flags	= I2C_M_RD,
			.len	= 8,
			.buf	= buf,
		},
	};

	to_tm(nowtime, &tm);
	tm.tm_year = (tm.tm_year - 1900) % 100;

	sec = BIN2BCD(tm.tm_sec);
	min = BIN2BCD(tm.tm_min);
	hour = BIN2BCD(tm.tm_hour);
	day = BIN2BCD(tm.tm_mday);
	mon = BIN2BCD(tm.tm_mon);
	year = BIN2BCD(tm.tm_year);

	/* Read reg values into buf[0..7]/wbuf[1..8] */
	if (i2c_transfer(save_client->adapter, msgs, 2) < 0) {
		dev_err(&save_client->dev, "m41t00_set: Read error\n");
		return;
	}

	wbuf[0] = 0; /* offset into rtc's regs */
	buf[m41t00_chip->sec] = (buf[m41t00_chip->sec] & ~0x7f) | (sec & 0x7f);
	buf[m41t00_chip->min] = (buf[m41t00_chip->min] & ~0x7f) | (min & 0x7f);
	buf[m41t00_chip->hour] = (buf[m41t00_chip->hour] & ~0x3f) | (hour& 0x3f);
	buf[m41t00_chip->day] = (buf[m41t00_chip->day] & ~0x3f) | (day & 0x3f);
	buf[m41t00_chip->mon] = (buf[m41t00_chip->mon] & ~0x1f) | (mon & 0x1f);
	buf[m41t00_chip->year] = year;

	if (i2c_master_send(save_client, wbuf, 9) < 0)
		dev_err(&save_client->dev, "m41t00_set: Write error\n");
}

static ulong new_time;
/* well, isn't this API just _lovely_? */
static void
m41t00_barf(struct work_struct *unusable)
{
	m41t00_set(&new_time);
}

static struct workqueue_struct *m41t00_wq;
static DECLARE_WORK(m41t00_work, m41t00_barf);

int
m41t00_set_rtc_time(ulong nowtime)
{
	new_time = nowtime;

	if (in_interrupt())
		queue_work(m41t00_wq, &m41t00_work);
	else
		m41t00_set(&new_time);

	return 0;
}
EXPORT_SYMBOL_GPL(m41t00_set_rtc_time);

/*
 *****************************************************************************
 *
 *	platform_data Driver Interface
 *
 *****************************************************************************
 */
static int __init
m41t00_platform_probe(struct platform_device *pdev)
{
	struct m41t00_platform_data *pdata;
	int i;

	if (pdev && (pdata = pdev->dev.platform_data)) {
		normal_addr[0] = pdata->i2c_addr;

		for (i=0; i<ARRAY_SIZE(m41t00_chip_info_tbl); i++)
			if (m41t00_chip_info_tbl[i].type == pdata->type) {
				m41t00_chip = &m41t00_chip_info_tbl[i];
				m41t00_chip->sqw_freq = pdata->sqw_freq;
				return 0;
			}
	}
	return -ENODEV;
}

static int __exit
m41t00_platform_remove(struct platform_device *pdev)
{
	return 0;
}

static struct platform_driver m41t00_platform_driver = {
	.probe  = m41t00_platform_probe,
	.remove = m41t00_platform_remove,
	.driver = {
		.owner = THIS_MODULE,
		.name  = M41T00_DRV_NAME,
	},
};

/*
 *****************************************************************************
 *
 *	Driver Interface
 *
 *****************************************************************************
 */
static int
m41t00_probe(struct i2c_adapter *adap, int addr, int kind)
{
	struct i2c_client *client;
	int rc;

	if (!i2c_check_functionality(adap, I2C_FUNC_I2C
			| I2C_FUNC_SMBUS_BYTE_DATA))
		return 0;

	client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
	if (!client)
		return -ENOMEM;

	strlcpy(client->name, m41t00_chip->name, I2C_NAME_SIZE);
	client->addr = addr;
	client->adapter = adap;
	client->driver = &m41t00_driver;

	if ((rc = i2c_attach_client(client)))
		goto attach_err;

	if (m41t00_chip->type != M41T00_TYPE_M41T00) {
		/* If asked, disable SQW, set SQW frequency & re-enable */
		if (m41t00_chip->sqw_freq)
			if (((rc = i2c_smbus_read_byte_data(client,
					m41t00_chip->alarm_mon)) < 0)
			 || ((rc = i2c_smbus_write_byte_data(client,
					m41t00_chip->alarm_mon, rc & ~0x40)) <0)
			 || ((rc = i2c_smbus_write_byte_data(client,
					m41t00_chip->sqw,
					m41t00_chip->sqw_freq)) < 0)
			 || ((rc = i2c_smbus_write_byte_data(client,
					m41t00_chip->alarm_mon, rc | 0x40)) <0))
				goto sqw_err;

		/* Make sure HT (Halt Update) bit is cleared */
		if ((rc = i2c_smbus_read_byte_data(client,
				m41t00_chip->alarm_hour)) < 0)
			goto ht_err;

		if (rc & 0x40)
			if ((rc = i2c_smbus_write_byte_data(client,
					m41t00_chip->alarm_hour, rc & ~0x40))<0)
				goto ht_err;
	}

	/* Make sure ST (stop) bit is cleared */
	if ((rc = i2c_smbus_read_byte_data(client, m41t00_chip->sec)) < 0)
		goto st_err;

	if (rc & 0x80)
		if ((rc = i2c_smbus_write_byte_data(client, m41t00_chip->sec,
				rc & ~0x80)) < 0)
			goto st_err;

	m41t00_wq = create_singlethread_workqueue(m41t00_chip->name);
	save_client = client;
	return 0;

st_err:
	dev_err(&client->dev, "m41t00_probe: Can't clear ST bit\n");
	goto attach_err;
ht_err:
	dev_err(&client->dev, "m41t00_probe: Can't clear HT bit\n");
	goto attach_err;
sqw_err:
	dev_err(&client->dev, "m41t00_probe: Can't set SQW Frequency\n");
attach_err:
	kfree(client);
	return rc;
}

static int
m41t00_attach(struct i2c_adapter *adap)
{
	return i2c_probe(adap, &addr_data, m41t00_probe);
}

static int
m41t00_detach(struct i2c_client *client)
{
	int rc;

	if ((rc = i2c_detach_client(client)) == 0) {
		kfree(client);
		destroy_workqueue(m41t00_wq);
	}
	return rc;
}

static struct i2c_driver m41t00_driver = {
	.driver = {
		.name	= M41T00_DRV_NAME,
	},
	.id		= I2C_DRIVERID_STM41T00,
	.attach_adapter	= m41t00_attach,
	.detach_client	= m41t00_detach,
};

static int __init
m41t00_init(void)
{
	int rc;

	if (!(rc = platform_driver_register(&m41t00_platform_driver)))
		rc = i2c_add_driver(&m41t00_driver);
	return rc;
}

static void __exit
m41t00_exit(void)
{
	i2c_del_driver(&m41t00_driver);
	platform_driver_unregister(&m41t00_platform_driver);
}

module_init(m41t00_init);
module_exit(m41t00_exit);

MODULE_AUTHOR("Mark A. Greer <[e-mail]>");
MODULE_DESCRIPTION("ST Microelectronics M41T00 RTC I2C Client Driver");
MODULE_LICENSE("GPL");