drivers/i2c/chips/m41t00.c - kernel/msm-4.19 - Gitiles

 /*
  * I2C client/driver for the ST M41T00 family of i2c rtc chips.
  *
  * Author: Mark A. Greer <mgreer@mvista.com>
  *
  * 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 <mgreer@mvista.com>");
 MODULE_DESCRIPTION("ST Microelectronics M41T00 RTC I2C Client Driver");
 MODULE_LICENSE("GPL");
	/*
	* I2C client/driver for the ST M41T00 family of i2c rtc chips.
	*
	* Author: Mark A. Greer <mgreer@mvista.com>
	*
	* 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 <mgreer@mvista.com>");
	MODULE_DESCRIPTION("ST Microelectronics M41T00 RTC I2C Client Driver");
	MODULE_LICENSE("GPL");