[deliverable/linux.git] / drivers / rtc / rtc-max6900.c

/*
 * rtc class driver for the Maxim MAX6900 chip
 *
 * Author: Dale Farnsworth <dale@farnsworth.org>
 *
 * based on previously existing rtc class drivers
 *
 * 2007 (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.
 */

#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/bcd.h>
#include <linux/rtc.h>
#include <linux/delay.h>

#define DRV_NAME "max6900"
#define DRV_VERSION "0.1"

/*
 * register indices
 */
#define MAX6900_REG_SC			0	/* seconds	00-59 */
#define MAX6900_REG_MN			1	/* minutes	00-59 */
#define MAX6900_REG_HR			2	/* hours	00-23 */
#define MAX6900_REG_DT			3	/* day of month	00-31 */
#define MAX6900_REG_MO			4	/* month	01-12 */
#define MAX6900_REG_DW			5	/* day of week	 1-7  */
#define MAX6900_REG_YR			6	/* year		00-99 */
#define MAX6900_REG_CT			7	/* control */
						/* register 8 is undocumented */
#define MAX6900_REG_CENTURY		9	/* century */
#define MAX6900_REG_LEN			10

#define MAX6900_BURST_LEN		8	/* can burst r/w first 8 regs */

#define MAX6900_REG_CT_WP		(1 << 7)	/* Write Protect */


/*
 * register read/write commands
 */
#define MAX6900_REG_CONTROL_WRITE	0x8e
#define MAX6900_REG_CENTURY_WRITE	0x92
#define MAX6900_REG_CENTURY_READ	0x93
#define MAX6900_REG_RESERVED_READ	0x96
#define MAX6900_REG_BURST_WRITE		0xbe
#define MAX6900_REG_BURST_READ		0xbf

#define MAX6900_IDLE_TIME_AFTER_WRITE	3	/* specification says 2.5 mS */

#define MAX6900_I2C_ADDR		0xa0

static const unsigned short normal_i2c[] = {
	MAX6900_I2C_ADDR >> 1,
	I2C_CLIENT_END
};

I2C_CLIENT_INSMOD;			/* defines addr_data */

static int max6900_probe(struct i2c_adapter *adapter, int addr, int kind);

static int max6900_i2c_read_regs(struct i2c_client *client, u8 *buf)
{
	u8 reg_burst_read[1] = { MAX6900_REG_BURST_READ };
	u8 reg_century_read[1] = { MAX6900_REG_CENTURY_READ };
	struct i2c_msg msgs[4] = {
		{
			.addr	= client->addr,
			.flags	= 0, /* write */
			.len	= sizeof(reg_burst_read),
			.buf	= reg_burst_read
		},
		{
			.addr	= client->addr,
			.flags	= I2C_M_RD,
			.len	= MAX6900_BURST_LEN,
			.buf	= buf
		},
		{
			.addr	= client->addr,
			.flags	= 0, /* write */
			.len	= sizeof(reg_century_read),
			.buf	= reg_century_read
		},
		{
			.addr	= client->addr,
			.flags	= I2C_M_RD,
			.len	= sizeof(buf[MAX6900_REG_CENTURY]),
			.buf	= &buf[MAX6900_REG_CENTURY]
		}
	};
	int rc;

	rc = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
	if (rc != ARRAY_SIZE(msgs)) {
		dev_err(&client->dev, "%s: register read failed\n",
			__func__);
		return -EIO;
	}
	return 0;
}

static int max6900_i2c_write_regs(struct i2c_client *client, u8 const *buf)
{
	u8 i2c_century_buf[1 + 1] = { MAX6900_REG_CENTURY_WRITE };
	struct i2c_msg century_msgs[1] = {
		{
			.addr	= client->addr,
			.flags	= 0, /* write */
			.len	= sizeof(i2c_century_buf),
			.buf	= i2c_century_buf
		}
	};
	u8 i2c_burst_buf[MAX6900_BURST_LEN + 1] = { MAX6900_REG_BURST_WRITE };
	struct i2c_msg burst_msgs[1] = {
		{
			.addr	= client->addr,
			.flags	= 0, /* write */
			.len	= sizeof(i2c_burst_buf),
			.buf	= i2c_burst_buf
		}
	};
	int rc;

	/*
	 * We have to make separate calls to i2c_transfer because of
	 * the need to delay after each write to the chip.  Also,
	 * we write the century byte first, since we set the write-protect
	 * bit as part of the burst write.
	 */
	i2c_century_buf[1] = buf[MAX6900_REG_CENTURY];
	rc = i2c_transfer(client->adapter, century_msgs,
			  ARRAY_SIZE(century_msgs));
	if (rc != ARRAY_SIZE(century_msgs))
		goto write_failed;
	msleep(MAX6900_IDLE_TIME_AFTER_WRITE);

	memcpy(&i2c_burst_buf[1], buf, MAX6900_BURST_LEN);

	rc = i2c_transfer(client->adapter, burst_msgs, ARRAY_SIZE(burst_msgs));
	if (rc != ARRAY_SIZE(burst_msgs))
		goto write_failed;
	msleep(MAX6900_IDLE_TIME_AFTER_WRITE);

	return 0;

write_failed:
	dev_err(&client->dev, "%s: register write failed\n",
		__func__);
	return -EIO;
}

static int max6900_i2c_validate_client(struct i2c_client *client)
{
	u8 regs[MAX6900_REG_LEN];
	u8 zero_mask[] = {
		0x80,	/* seconds */
		0x80,	/* minutes */
		0x40,	/* hours */
		0xc0,	/* day of month */
		0xe0,	/* month */
		0xf8,	/* day of week */
		0x00,	/* year */
		0x7f,	/* control */
	};
	int i;
	int rc;
	int reserved;

	reserved = i2c_smbus_read_byte_data(client, MAX6900_REG_RESERVED_READ);
	if (reserved != 0x07)
		return -ENODEV;

	rc = max6900_i2c_read_regs(client, regs);
	if (rc < 0)
		return rc;

	for (i = 0; i < ARRAY_SIZE(zero_mask); ++i) {
		if (regs[i] & zero_mask[i])
			return -ENODEV;
	}

	return 0;
}

static int max6900_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
{
	int rc;
	u8 regs[MAX6900_REG_LEN];

	rc = max6900_i2c_read_regs(client, regs);
	if (rc < 0)
		return rc;

	tm->tm_sec = BCD2BIN(regs[MAX6900_REG_SC]);
	tm->tm_min = BCD2BIN(regs[MAX6900_REG_MN]);
	tm->tm_hour = BCD2BIN(regs[MAX6900_REG_HR] & 0x3f);
	tm->tm_mday = BCD2BIN(regs[MAX6900_REG_DT]);
	tm->tm_mon = BCD2BIN(regs[MAX6900_REG_MO]) - 1;
	tm->tm_year = BCD2BIN(regs[MAX6900_REG_YR]) +
		      BCD2BIN(regs[MAX6900_REG_CENTURY]) * 100 - 1900;
	tm->tm_wday = BCD2BIN(regs[MAX6900_REG_DW]);

	return 0;
}

static int max6900_i2c_clear_write_protect(struct i2c_client *client)
{
	int rc;
	rc = i2c_smbus_write_byte_data (client, MAX6900_REG_CONTROL_WRITE, 0);
	if (rc < 0) {
		dev_err(&client->dev, "%s: control register write failed\n",
			__func__);
		return -EIO;
	}
	return 0;
}

static int max6900_i2c_set_time(struct i2c_client *client,
				struct rtc_time const *tm)
{
	u8 regs[MAX6900_REG_LEN];
	int rc;

	rc = max6900_i2c_clear_write_protect(client);
	if (rc < 0)
		return rc;

	regs[MAX6900_REG_SC] = BIN2BCD(tm->tm_sec);
	regs[MAX6900_REG_MN] = BIN2BCD(tm->tm_min);
	regs[MAX6900_REG_HR] = BIN2BCD(tm->tm_hour);
	regs[MAX6900_REG_DT] = BIN2BCD(tm->tm_mday);
	regs[MAX6900_REG_MO] = BIN2BCD(tm->tm_mon + 1);
	regs[MAX6900_REG_DW] = BIN2BCD(tm->tm_wday);
	regs[MAX6900_REG_YR] = BIN2BCD(tm->tm_year % 100);
	regs[MAX6900_REG_CENTURY] = BIN2BCD((tm->tm_year + 1900) / 100);
	/* set write protect */
	regs[MAX6900_REG_CT] = MAX6900_REG_CT_WP;

	rc = max6900_i2c_write_regs(client, regs);
	if (rc < 0)
		return rc;

	return 0;
}

static int max6900_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	return max6900_i2c_read_time(to_i2c_client(dev), tm);
}

static int max6900_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	return max6900_i2c_set_time(to_i2c_client(dev), tm);
}

static int max6900_attach_adapter(struct i2c_adapter *adapter)
{
	return i2c_probe(adapter, &addr_data, max6900_probe);
}

static int max6900_detach_client(struct i2c_client *client)
{
	struct rtc_device *const rtc = i2c_get_clientdata(client);

	if (rtc)
		rtc_device_unregister(rtc);

	return i2c_detach_client(client);
}

static struct i2c_driver max6900_driver = {
	.driver		= {
		.name	= DRV_NAME,
	},
	.id		= I2C_DRIVERID_MAX6900,
	.attach_adapter = max6900_attach_adapter,
	.detach_client	= max6900_detach_client,
};

static const struct rtc_class_ops max6900_rtc_ops = {
	.read_time	= max6900_rtc_read_time,
	.set_time	= max6900_rtc_set_time,
};

static int max6900_probe(struct i2c_adapter *adapter, int addr, int kind)
{
	int rc = 0;
	struct i2c_client *client = NULL;
	struct rtc_device *rtc = NULL;

	if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
		rc = -ENODEV;
		goto failout;
	}

	client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
	if (client == NULL) {
		rc = -ENOMEM;
		goto failout;
	}

	client->addr = addr;
	client->adapter = adapter;
	client->driver = &max6900_driver;
	strlcpy(client->name, DRV_NAME, I2C_NAME_SIZE);

	if (kind < 0) {
		rc = max6900_i2c_validate_client(client);
		if (rc < 0)
			goto failout;
	}

	rc = i2c_attach_client(client);
	if (rc < 0)
		goto failout;

	dev_info(&client->dev,
		 "chip found, driver version " DRV_VERSION "\n");

	rtc = rtc_device_register(max6900_driver.driver.name,
				  &client->dev,
				  &max6900_rtc_ops, THIS_MODULE);
	if (IS_ERR(rtc)) {
		rc = PTR_ERR(rtc);
		goto failout_detach;
	}

	i2c_set_clientdata(client, rtc);

	return 0;

failout_detach:
	i2c_detach_client(client);
failout:
	kfree(client);
	return rc;
}

static int __init max6900_init(void)
{
	return i2c_add_driver(&max6900_driver);
}

static void __exit max6900_exit(void)
{
	i2c_del_driver(&max6900_driver);
}

MODULE_DESCRIPTION("Maxim MAX6900 RTC driver");
MODULE_LICENSE("GPL");
MODULE_VERSION(DRV_VERSION);

module_init(max6900_init);
module_exit(max6900_exit);
Commit	Line	Data
aa5bd7e9 DF	1	/*
	2	* rtc class driver for the Maxim MAX6900 chip
	3	*
	4	* Author: Dale Farnsworth <dale@farnsworth.org>
	5	*
	6	* based on previously existing rtc class drivers
	7	*
	8	* 2007 (c) MontaVista, Software, Inc. This file is licensed under
	9	* the terms of the GNU General Public License version 2. This program
	10	* is licensed "as is" without any warranty of any kind, whether express
	11	* or implied.
	12	*/
	13
	14	#include <linux/module.h>
	15	#include <linux/i2c.h>
	16	#include <linux/bcd.h>
	17	#include <linux/rtc.h>
	18	#include <linux/delay.h>
	19
	20	#define DRV_NAME "max6900"
	21	#define DRV_VERSION "0.1"
	22
	23	/*
	24	* register indices
	25	*/
	26	#define MAX6900_REG_SC 0 /* seconds 00-59 */
	27	#define MAX6900_REG_MN 1 /* minutes 00-59 */
	28	#define MAX6900_REG_HR 2 /* hours 00-23 */
	29	#define MAX6900_REG_DT 3 /* day of month 00-31 */
	30	#define MAX6900_REG_MO 4 /* month 01-12 */
	31	#define MAX6900_REG_DW 5 /* day of week 1-7 */
	32	#define MAX6900_REG_YR 6 /* year 00-99 */
	33	#define MAX6900_REG_CT 7 /* control */
8a2601f6 DF	34	/* register 8 is undocumented */
	35	#define MAX6900_REG_CENTURY 9 /* century */
	36	#define MAX6900_REG_LEN 10
	37
	38	#define MAX6900_BURST_LEN 8 /* can burst r/w first 8 regs */
aa5bd7e9 DF	39
	40	#define MAX6900_REG_CT_WP (1 << 7) /* Write Protect */
	41
8a2601f6	42
aa5bd7e9 DF	43	/*
	44	* register read/write commands
	45	*/
	46	#define MAX6900_REG_CONTROL_WRITE 0x8e
8a2601f6 DF	47	#define MAX6900_REG_CENTURY_WRITE 0x92
8a2601f6 DF	48	#define MAX6900_REG_CENTURY_READ 0x93
aa5bd7e9	49	#define MAX6900_REG_RESERVED_READ 0x96
8a2601f6 DF	50	#define MAX6900_REG_BURST_WRITE 0xbe
8a2601f6 DF	51	#define MAX6900_REG_BURST_READ 0xbf
aa5bd7e9 DF	52
	53	#define MAX6900_IDLE_TIME_AFTER_WRITE 3 /* specification says 2.5 mS */
	54
	55	#define MAX6900_I2C_ADDR 0xa0
	56
922539a0	57	static const unsigned short normal_i2c[] = {
aa5bd7e9 DF	58	MAX6900_I2C_ADDR >> 1,
	59	I2C_CLIENT_END
	60	};
	61
	62	I2C_CLIENT_INSMOD; /* defines addr_data */
	63
	64	static int max6900_probe(struct i2c_adapter *adapter, int addr, int kind);
	65
	66	static int max6900_i2c_read_regs(struct i2c_client client, u8 buf)
	67	{
8a2601f6 DF	68	u8 reg_burst_read[1] = { MAX6900_REG_BURST_READ };
	69	u8 reg_century_read[1] = { MAX6900_REG_CENTURY_READ };
	70	struct i2c_msg msgs[4] = {
aa5bd7e9 DF	71	{
	72	.addr = client->addr,
	73	.flags = 0, /* write */
8a2601f6 DF	74	.len = sizeof(reg_burst_read),
8a2601f6 DF	75	.buf = reg_burst_read
aa5bd7e9 DF	76	},
	77	{
	78	.addr = client->addr,
	79	.flags = I2C_M_RD,
8a2601f6	80	.len = MAX6900_BURST_LEN,
aa5bd7e9	81	.buf = buf
8a2601f6 DF	82	},
	83	{
	84	.addr = client->addr,
	85	.flags = 0, /* write */
	86	.len = sizeof(reg_century_read),
	87	.buf = reg_century_read
	88	},
	89	{
	90	.addr = client->addr,
	91	.flags = I2C_M_RD,
	92	.len = sizeof(buf[MAX6900_REG_CENTURY]),
	93	.buf = &buf[MAX6900_REG_CENTURY]
aa5bd7e9 DF	94	}
	95	};
	96	int rc;
	97
	98	rc = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
	99	if (rc != ARRAY_SIZE(msgs)) {
	100	dev_err(&client->dev, "%s: register read failed\n",
2a4e2b87	101	__func__);
aa5bd7e9 DF	102	return -EIO;
	103	}
	104	return 0;
	105	}
	106
	107	static int max6900_i2c_write_regs(struct i2c_client client, u8 const buf)
	108	{
8a2601f6 DF	109	u8 i2c_century_buf[1 + 1] = { MAX6900_REG_CENTURY_WRITE };
8a2601f6 DF	110	struct i2c_msg century_msgs[1] = {
aa5bd7e9 DF	111	{
	112	.addr = client->addr,
	113	.flags = 0, /* write */
8a2601f6 DF	114	.len = sizeof(i2c_century_buf),
	115	.buf = i2c_century_buf
	116	}
	117	};
	118	u8 i2c_burst_buf[MAX6900_BURST_LEN + 1] = { MAX6900_REG_BURST_WRITE };
	119	struct i2c_msg burst_msgs[1] = {
	120	{
	121	.addr = client->addr,
	122	.flags = 0, /* write */
	123	.len = sizeof(i2c_burst_buf),
	124	.buf = i2c_burst_buf
aa5bd7e9 DF	125	}
	126	};
	127	int rc;
	128
8a2601f6 DF	129	/*
	130	* We have to make separate calls to i2c_transfer because of
	131	* the need to delay after each write to the chip. Also,
	132	* we write the century byte first, since we set the write-protect
	133	* bit as part of the burst write.
	134	*/
	135	i2c_century_buf[1] = buf[MAX6900_REG_CENTURY];
	136	rc = i2c_transfer(client->adapter, century_msgs,
	137	ARRAY_SIZE(century_msgs));
	138	if (rc != ARRAY_SIZE(century_msgs))
	139	goto write_failed;
	140	msleep(MAX6900_IDLE_TIME_AFTER_WRITE);
aa5bd7e9	141
8a2601f6 DF	142	memcpy(&i2c_burst_buf[1], buf, MAX6900_BURST_LEN);
	143
	144	rc = i2c_transfer(client->adapter, burst_msgs, ARRAY_SIZE(burst_msgs));
	145	if (rc != ARRAY_SIZE(burst_msgs))
	146	goto write_failed;
aa5bd7e9	147	msleep(MAX6900_IDLE_TIME_AFTER_WRITE);
8a2601f6	148
aa5bd7e9	149	return 0;
8a2601f6 DF	150
	151	write_failed:
	152	dev_err(&client->dev, "%s: register write failed\n",
2a4e2b87	153	__func__);
8a2601f6	154	return -EIO;
aa5bd7e9 DF	155	}
	156
	157	static int max6900_i2c_validate_client(struct i2c_client *client)
	158	{
	159	u8 regs[MAX6900_REG_LEN];
8a2601f6	160	u8 zero_mask[] = {
aa5bd7e9 DF	161	0x80, /* seconds */
	162	0x80, /* minutes */
	163	0x40, /* hours */
	164	0xc0, /* day of month */
	165	0xe0, /* month */
	166	0xf8, /* day of week */
	167	0x00, /* year */
	168	0x7f, /* control */
	169	};
	170	int i;
	171	int rc;
	172	int reserved;
	173
	174	reserved = i2c_smbus_read_byte_data(client, MAX6900_REG_RESERVED_READ);
	175	if (reserved != 0x07)
	176	return -ENODEV;
	177
	178	rc = max6900_i2c_read_regs(client, regs);
	179	if (rc < 0)
	180	return rc;
	181
8a2601f6	182	for (i = 0; i < ARRAY_SIZE(zero_mask); ++i) {
aa5bd7e9 DF	183	if (regs[i] & zero_mask[i])
	184	return -ENODEV;
	185	}
	186
	187	return 0;
	188	}
	189
	190	static int max6900_i2c_read_time(struct i2c_client client, struct rtc_time tm)
	191	{
	192	int rc;
	193	u8 regs[MAX6900_REG_LEN];
	194
	195	rc = max6900_i2c_read_regs(client, regs);
	196	if (rc < 0)
	197	return rc;
	198
	199	tm->tm_sec = BCD2BIN(regs[MAX6900_REG_SC]);
	200	tm->tm_min = BCD2BIN(regs[MAX6900_REG_MN]);
	201	tm->tm_hour = BCD2BIN(regs[MAX6900_REG_HR] & 0x3f);
	202	tm->tm_mday = BCD2BIN(regs[MAX6900_REG_DT]);
	203	tm->tm_mon = BCD2BIN(regs[MAX6900_REG_MO]) - 1;
8a2601f6 DF	204	tm->tm_year = BCD2BIN(regs[MAX6900_REG_YR]) +
8a2601f6 DF	205	BCD2BIN(regs[MAX6900_REG_CENTURY]) * 100 - 1900;
aa5bd7e9 DF	206	tm->tm_wday = BCD2BIN(regs[MAX6900_REG_DW]);
	207
	208	return 0;
	209	}
	210
	211	static int max6900_i2c_clear_write_protect(struct i2c_client *client)
	212	{
	213	int rc;
	214	rc = i2c_smbus_write_byte_data (client, MAX6900_REG_CONTROL_WRITE, 0);
	215	if (rc < 0) {
	216	dev_err(&client->dev, "%s: control register write failed\n",
2a4e2b87	217	__func__);
aa5bd7e9 DF	218	return -EIO;
	219	}
	220	return 0;
	221	}
	222
	223	static int max6900_i2c_set_time(struct i2c_client *client,
	224	struct rtc_time const *tm)
	225	{
	226	u8 regs[MAX6900_REG_LEN];
	227	int rc;
	228
	229	rc = max6900_i2c_clear_write_protect(client);
	230	if (rc < 0)
	231	return rc;
	232
	233	regs[MAX6900_REG_SC] = BIN2BCD(tm->tm_sec);
	234	regs[MAX6900_REG_MN] = BIN2BCD(tm->tm_min);
	235	regs[MAX6900_REG_HR] = BIN2BCD(tm->tm_hour);
	236	regs[MAX6900_REG_DT] = BIN2BCD(tm->tm_mday);
	237	regs[MAX6900_REG_MO] = BIN2BCD(tm->tm_mon + 1);
aa5bd7e9	238	regs[MAX6900_REG_DW] = BIN2BCD(tm->tm_wday);
8a2601f6 DF	239	regs[MAX6900_REG_YR] = BIN2BCD(tm->tm_year % 100);
	240	regs[MAX6900_REG_CENTURY] = BIN2BCD((tm->tm_year + 1900) / 100);
	241	/* set write protect */
	242	regs[MAX6900_REG_CT] = MAX6900_REG_CT_WP;
aa5bd7e9 DF	243
	244	rc = max6900_i2c_write_regs(client, regs);
	245	if (rc < 0)
	246	return rc;
	247
	248	return 0;
	249	}
	250
	251	static int max6900_rtc_read_time(struct device dev, struct rtc_time tm)
	252	{
	253	return max6900_i2c_read_time(to_i2c_client(dev), tm);
	254	}
	255
	256	static int max6900_rtc_set_time(struct device dev, struct rtc_time tm)
	257	{
	258	return max6900_i2c_set_time(to_i2c_client(dev), tm);
	259	}
	260
	261	static int max6900_attach_adapter(struct i2c_adapter *adapter)
	262	{
	263	return i2c_probe(adapter, &addr_data, max6900_probe);
	264	}
	265
	266	static int max6900_detach_client(struct i2c_client *client)
	267	{
	268	struct rtc_device *const rtc = i2c_get_clientdata(client);
	269
	270	if (rtc)
	271	rtc_device_unregister(rtc);
	272
	273	return i2c_detach_client(client);
	274	}
	275
	276	static struct i2c_driver max6900_driver = {
	277	.driver = {
	278	.name = DRV_NAME,
	279	},
	280	.id = I2C_DRIVERID_MAX6900,
	281	.attach_adapter = max6900_attach_adapter,
	282	.detach_client = max6900_detach_client,
	283	};
	284
	285	static const struct rtc_class_ops max6900_rtc_ops = {
	286	.read_time = max6900_rtc_read_time,
	287	.set_time = max6900_rtc_set_time,
	288	};
	289
	290	static int max6900_probe(struct i2c_adapter *adapter, int addr, int kind)
	291	{
	292	int rc = 0;
	293	struct i2c_client *client = NULL;
	294	struct rtc_device *rtc = NULL;
	295
	296	if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
	297	rc = -ENODEV;
	298	goto failout;
	299	}
	300
	301	client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
	302	if (client == NULL) {
	303	rc = -ENOMEM;
	304	goto failout;
	305	}
	306
307	client->addr = addr;
308	client->adapter = adapter;
309	client->driver = &max6900_driver;
310	strlcpy(client->name, DRV_NAME, I2C_NAME_SIZE);
311
312	if (kind < 0) {
313	rc = max6900_i2c_validate_client(client);
314	if (rc < 0)
315	goto failout;
316	}
317
318	rc = i2c_attach_client(client);
319	if (rc < 0)
320	goto failout;
321
322	dev_info(&client->dev,
323	"chip found, driver version " DRV_VERSION "\n");
324
325	rtc = rtc_device_register(max6900_driver.driver.name,
326	&client->dev,
327	&max6900_rtc_ops, THIS_MODULE);
328	if (IS_ERR(rtc)) {
329	rc = PTR_ERR(rtc);
330	goto failout_detach;
331	}
332
333	i2c_set_clientdata(client, rtc);
334
335	return 0;
336
337	failout_detach:
338	i2c_detach_client(client);
339	failout:
340	kfree(client);
341	return rc;
342	}
343
344	static int __init max6900_init(void)
345	{
346	return i2c_add_driver(&max6900_driver);
347	}
348
349	static void __exit max6900_exit(void)
350	{
351	i2c_del_driver(&max6900_driver);
352	}
353
354	MODULE_DESCRIPTION("Maxim MAX6900 RTC driver");
355	MODULE_LICENSE("GPL");
356	MODULE_VERSION(DRV_VERSION);
357
358	module_init(max6900_init);
359	module_exit(max6900_exit);