Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9edae7bc authored by Alessandro Zummo's avatar Alessandro Zummo Committed by Linus Torvalds
Browse files

rtc-isl1208: new style conversion and minor bug fixes 



[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: default avatarAlessandro Zummo <a.zummo@towertech.it>
Cc: Herbert Valerio Riedel <hvr@gnu.org>
Cc: David Brownell <david-b@pacbell.net>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent c7500900

drivers/rtc/rtc-isl1208.c

+170 −187
Original line number Diff line number Diff line
@@ -15,8 +15,7 @@ 
#include <linux/bcd.h>

#include <linux/rtc.h>



#define DRV_NAME "isl1208"

#define DRV_VERSION "0.2"

#define DRV_VERSION "0.3"



/* Register map */

/* rtc section */
@@ -58,25 +57,7 @@ 
#define ISL1208_REG_USR2 0x13

#define ISL1208_USR_SECTION_LEN 2



/* i2c configuration */

#define ISL1208_I2C_ADDR 0xde



static const unsigned short normal_i2c[] = {

	ISL1208_I2C_ADDR>>1, I2C_CLIENT_END

};

I2C_CLIENT_INSMOD; /* defines addr_data */



static int isl1208_attach_adapter(struct i2c_adapter *adapter);

static int isl1208_detach_client(struct i2c_client *client);



static struct i2c_driver isl1208_driver = {

	.driver		= {

		.name	= DRV_NAME,

	},

	.id		= I2C_DRIVERID_ISL1208,

	.attach_adapter = &isl1208_attach_adapter,

	.detach_client	= &isl1208_detach_client,

};

static struct i2c_driver isl1208_driver;



/* block read */

static int
@@ -85,12 +66,12 @@ isl1208_i2c_read_regs(struct i2c_client *client, u8 reg, u8 buf[], 
{

	u8 reg_addr[1] = { reg };

	struct i2c_msg msgs[2] = {

		{ client->addr, client->flags, sizeof(reg_addr), reg_addr },

		{ client->addr, client->flags | I2C_M_RD, len, buf }

		{client->addr, 0, sizeof(reg_addr), reg_addr}

		,

		{client->addr, I2C_M_RD, len, buf}

	};

	int ret;



	BUG_ON(len == 0);

	BUG_ON(reg > ISL1208_REG_USR2);

	BUG_ON(reg + len > ISL1208_REG_USR2 + 1);
@@ -107,11 +88,10 @@ isl1208_i2c_set_regs(struct i2c_client *client, u8 reg, u8 const buf[], 
{

	u8 i2c_buf[ISL1208_REG_USR2 + 2];

	struct i2c_msg msgs[1] = {

		{ client->addr, client->flags, len + 1, i2c_buf }

		{client->addr, 0, len + 1, i2c_buf}

	};

	int ret;



	BUG_ON(len == 0);

	BUG_ON(reg > ISL1208_REG_USR2);

	BUG_ON(reg + len > ISL1208_REG_USR2 + 1);
@@ -125,7 +105,8 @@ isl1208_i2c_set_regs(struct i2c_client *client, u8 reg, u8 const buf[], 
}



/* simple check to see wether we have a isl1208 */

static int isl1208_i2c_validate_client(struct i2c_client *client)

static int

isl1208_i2c_validate_client(struct i2c_client *client)

{

	u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };

	u8 zero_mask[ISL1208_RTC_SECTION_LEN] = {
@@ -146,17 +127,22 @@ static int isl1208_i2c_validate_client(struct i2c_client *client) 
	return 0;

}



static int isl1208_i2c_get_sr(struct i2c_client *client)

static int

isl1208_i2c_get_sr(struct i2c_client *client)

{

	return i2c_smbus_read_byte_data(client, ISL1208_REG_SR) == -1 ? -EIO:0;

	int sr = i2c_smbus_read_byte_data(client, ISL1208_REG_SR);

	if (sr < 0)

		return -EIO;



	return sr;

}



static int isl1208_i2c_get_atr(struct i2c_client *client)

static int

isl1208_i2c_get_atr(struct i2c_client *client)

{

	int atr = i2c_smbus_read_byte_data(client, ISL1208_REG_ATR);



	if (atr < 0)

		return -EIO;

		return atr;



	/* The 6bit value in the ATR register controls the load

	 * capacitance C_load * in steps of 0.25pF
@@ -176,10 +162,10 @@ static int isl1208_i2c_get_atr(struct i2c_client *client) 
	return atr;

}



static int isl1208_i2c_get_dtr(struct i2c_client *client)

static int

isl1208_i2c_get_dtr(struct i2c_client *client)

{

	int dtr = i2c_smbus_read_byte_data(client, ISL1208_REG_DTR);



	if (dtr < 0)

		return -EIO;
@@ -189,7 +175,8 @@ static int isl1208_i2c_get_dtr(struct i2c_client *client) 
	return dtr;

}



static int isl1208_i2c_get_usr(struct i2c_client *client)

static int

isl1208_i2c_get_usr(struct i2c_client *client)

{

	u8 buf[ISL1208_USR_SECTION_LEN] = { 0, };

	int ret;
@@ -202,7 +189,8 @@ static int isl1208_i2c_get_usr(struct i2c_client *client) 
	return (buf[1] << 8) | buf[0];

}



static int isl1208_i2c_set_usr(struct i2c_client *client, u16 usr)

static int

isl1208_i2c_set_usr(struct i2c_client *client, u16 usr)

{

	u8 buf[ISL1208_USR_SECTION_LEN];
@@ -213,7 +201,8 @@ static int isl1208_i2c_set_usr(struct i2c_client *client, u16 usr) 
				    ISL1208_USR_SECTION_LEN);

}



static int isl1208_rtc_proc(struct device *dev, struct seq_file *seq)

static int

isl1208_rtc_proc(struct device *dev, struct seq_file *seq)

{

	struct i2c_client *const client = to_i2c_client(dev);

	int sr, dtr, atr, usr;
@@ -230,8 +219,7 @@ static int isl1208_rtc_proc(struct device *dev, struct seq_file *seq) 
		   (sr & ISL1208_REG_SR_ALM) ? " ALM" : "",

		   (sr & ISL1208_REG_SR_WRTC) ? " WRTC" : "",

		   (sr & ISL1208_REG_SR_XTOSCB) ? " XTOSCB" : "",

		   (sr & ISL1208_REG_SR_ARST) ? " ARST" : "",

		   sr);

		   (sr & ISL1208_REG_SR_ARST) ? " ARST" : "", sr);



	seq_printf(seq, "batt_status\t: %s\n",

		   (sr & ISL1208_REG_SR_RTCF) ? "bad" : "okay");
@@ -252,9 +240,8 @@ static int isl1208_rtc_proc(struct device *dev, struct seq_file *seq) 
	return 0;

}





static int isl1208_i2c_read_time(struct i2c_client *client,

				 struct rtc_time *tm)

static int

isl1208_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)

{

	int sr;

	u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
@@ -274,11 +261,14 @@ static int isl1208_i2c_read_time(struct i2c_client *client, 


	tm->tm_sec = BCD2BIN(regs[ISL1208_REG_SC]);

	tm->tm_min = BCD2BIN(regs[ISL1208_REG_MN]);

	{ /* HR field has a more complex interpretation */



	/* HR field has a more complex interpretation */

	{

		const u8 _hr = regs[ISL1208_REG_HR];

		if (_hr & ISL1208_REG_HR_MIL)	/* 24h format */

			tm->tm_hour = BCD2BIN(_hr & 0x3f);

		else { // 12h format

		else {

			/* 12h format */

			tm->tm_hour = BCD2BIN(_hr & 0x1f);

			if (_hr & ISL1208_REG_HR_PM)	/* PM flag set */

				tm->tm_hour += 12;
@@ -293,8 +283,8 @@ static int isl1208_i2c_read_time(struct i2c_client *client, 
	return 0;

}



static int isl1208_i2c_read_alarm(struct i2c_client *client,

				  struct rtc_wkalrm *alarm)

static int

isl1208_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)

{

	struct rtc_time *const tm = &alarm->time;

	u8 regs[ISL1208_ALARM_SECTION_LEN] = { 0, };
@@ -319,19 +309,21 @@ static int isl1208_i2c_read_alarm(struct i2c_client *client, 
	tm->tm_min = BCD2BIN(regs[ISL1208_REG_MNA - ISL1208_REG_SCA] & 0x7f);

	tm->tm_hour = BCD2BIN(regs[ISL1208_REG_HRA - ISL1208_REG_SCA] & 0x3f);

	tm->tm_mday = BCD2BIN(regs[ISL1208_REG_DTA - ISL1208_REG_SCA] & 0x3f);

	tm->tm_mon  = BCD2BIN(regs[ISL1208_REG_MOA-ISL1208_REG_SCA] & 0x1f)-1;

	tm->tm_mon =

		BCD2BIN(regs[ISL1208_REG_MOA - ISL1208_REG_SCA] & 0x1f) - 1;

	tm->tm_wday = BCD2BIN(regs[ISL1208_REG_DWA - ISL1208_REG_SCA] & 0x03);



	return 0;

}



static int isl1208_rtc_read_time(struct device *dev, struct rtc_time *tm)

static int

isl1208_rtc_read_time(struct device *dev, struct rtc_time *tm)

{

	return isl1208_i2c_read_time(to_i2c_client(dev), tm);

}



static int isl1208_i2c_set_time(struct i2c_client *client,

				struct rtc_time const *tm)

static int

isl1208_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm)

{

	int sr;

	u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
@@ -380,12 +372,14 @@ static int isl1208_i2c_set_time(struct i2c_client *client, 
}





static int isl1208_rtc_set_time(struct device *dev, struct rtc_time *tm)

static int

isl1208_rtc_set_time(struct device *dev, struct rtc_time *tm)

{

	return isl1208_i2c_set_time(to_i2c_client(dev), tm);

}



static int isl1208_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)

static int

isl1208_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)

{

	return isl1208_i2c_read_alarm(to_i2c_client(dev), alarm);

}
@@ -395,53 +389,50 @@ static const struct rtc_class_ops isl1208_rtc_ops = { 
	.read_time = isl1208_rtc_read_time,

	.set_time = isl1208_rtc_set_time,

	.read_alarm = isl1208_rtc_read_alarm,

	//.set_alarm	= isl1208_rtc_set_alarm,

	/*.set_alarm    = isl1208_rtc_set_alarm, */

};



/* sysfs interface */



static ssize_t isl1208_sysfs_show_atrim(struct device *dev,

					struct device_attribute *attr,

					char *buf)

static ssize_t

isl1208_sysfs_show_atrim(struct device *dev,

			 struct device_attribute *attr, char *buf)

{

	int atr;



	atr = isl1208_i2c_get_atr(to_i2c_client(dev));

	int atr = isl1208_i2c_get_atr(to_i2c_client(dev));

	if (atr < 0)

		return atr;



	return sprintf(buf, "%d.%.2d pF\n", atr >> 2, (atr & 0x3) * 25);

}



static DEVICE_ATTR(atrim, S_IRUGO, isl1208_sysfs_show_atrim, NULL);



static ssize_t isl1208_sysfs_show_dtrim(struct device *dev,

					struct device_attribute *attr,

					char *buf)

static ssize_t

isl1208_sysfs_show_dtrim(struct device *dev,

			 struct device_attribute *attr, char *buf)

{

	int dtr;



	dtr = isl1208_i2c_get_dtr(to_i2c_client(dev));

	int dtr = isl1208_i2c_get_dtr(to_i2c_client(dev));

	if (dtr < 0)

		return dtr;



	return sprintf(buf, "%d ppm\n", dtr);

}



static DEVICE_ATTR(dtrim, S_IRUGO, isl1208_sysfs_show_dtrim, NULL);



static ssize_t isl1208_sysfs_show_usr(struct device *dev,

				       struct device_attribute *attr,

				       char *buf)

static ssize_t

isl1208_sysfs_show_usr(struct device *dev,

		       struct device_attribute *attr, char *buf)

{

	int usr;



	usr = isl1208_i2c_get_usr(to_i2c_client(dev));

	int usr = isl1208_i2c_get_usr(to_i2c_client(dev));

	if (usr < 0)

		return usr;



	return sprintf(buf, "0x%.4x\n", usr);

}



static ssize_t isl1208_sysfs_store_usr(struct device *dev,

static ssize_t

isl1208_sysfs_store_usr(struct device *dev,

			struct device_attribute *attr,

			const char *buf, size_t count)

{
@@ -460,124 +451,116 @@ static ssize_t isl1208_sysfs_store_usr(struct device *dev, 


	return isl1208_i2c_set_usr(to_i2c_client(dev), usr) ? -EIO : count;

}



static DEVICE_ATTR(usr, S_IRUGO | S_IWUSR, isl1208_sysfs_show_usr,

		   isl1208_sysfs_store_usr);



static int

isl1208_probe(struct i2c_adapter *adapter, int addr, int kind)

isl1208_sysfs_register(struct device *dev)

{

	int rc = 0;

	struct i2c_client *new_client = NULL;

	struct rtc_device *rtc = NULL;

	int err;



	if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {

		rc = -ENODEV;

		goto failout;

	err = device_create_file(dev, &dev_attr_atrim);

	if (err)

		return err;



	err = device_create_file(dev, &dev_attr_dtrim);

	if (err) {

		device_remove_file(dev, &dev_attr_atrim);

		return err;

	}



	err = device_create_file(dev, &dev_attr_usr);

	if (err) {

		device_remove_file(dev, &dev_attr_atrim);

		device_remove_file(dev, &dev_attr_dtrim);

	}



	new_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);

	if (new_client == NULL) {

		rc = -ENOMEM;

		goto failout;

	return 0;

}



	new_client->addr = addr;

	new_client->adapter = adapter;

	new_client->driver = &isl1208_driver;

	new_client->flags = 0;

	strcpy(new_client->name, DRV_NAME);

static int

isl1208_sysfs_unregister(struct device *dev)

{

	device_remove_file(dev, &dev_attr_atrim);

	device_remove_file(dev, &dev_attr_atrim);

	device_remove_file(dev, &dev_attr_usr);



	if (kind < 0) {

		rc = isl1208_i2c_validate_client(new_client);

		if (rc < 0)

			goto failout;

	return 0;

}



	rc = i2c_attach_client(new_client);

	if (rc < 0)

		goto failout;

static int

isl1208_probe(struct i2c_client *client)

{

	int rc = 0;

	struct rtc_device *rtc;



	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))

		return -ENODEV;



	if (isl1208_i2c_validate_client(client) < 0)

		return -ENODEV;



	dev_info(&new_client->dev,

	dev_info(&client->dev,

		 "chip found, driver version " DRV_VERSION "\n");



	rtc = rtc_device_register(isl1208_driver.driver.name,

				  &new_client->dev,

				  &isl1208_rtc_ops, THIS_MODULE);



	if (IS_ERR(rtc)) {

		rc = PTR_ERR(rtc);

		goto failout_detach;

	}

				  &client->dev, &isl1208_rtc_ops,

				  THIS_MODULE);

	if (IS_ERR(rtc))

		return PTR_ERR(rtc);



	i2c_set_clientdata(new_client, rtc);

	i2c_set_clientdata(client, rtc);



	rc = isl1208_i2c_get_sr(new_client);

	rc = isl1208_i2c_get_sr(client);

	if (rc < 0) {

		dev_err(&new_client->dev, "reading status failed\n");

		goto failout_unregister;

		dev_err(&client->dev, "reading status failed\n");

		goto exit_unregister;

	}



	if (rc & ISL1208_REG_SR_RTCF)

		dev_warn(&new_client->dev, "rtc power failure detected, "

		dev_warn(&client->dev, "rtc power failure detected, "

			 "please set clock.\n");



	rc = device_create_file(&new_client->dev, &dev_attr_atrim);

	if (rc < 0)

		goto failout_unregister;

	rc = device_create_file(&new_client->dev, &dev_attr_dtrim);

	if (rc < 0)

		goto failout_atrim;

	rc = device_create_file(&new_client->dev, &dev_attr_usr);

	if (rc < 0)

		goto failout_dtrim;

	rc = isl1208_sysfs_register(&client->dev);

	if (rc)

		goto exit_unregister;



	return 0;



 failout_dtrim:

	device_remove_file(&new_client->dev, &dev_attr_dtrim);

 failout_atrim:

	device_remove_file(&new_client->dev, &dev_attr_atrim);

 failout_unregister:

exit_unregister:

	rtc_device_unregister(rtc);

 failout_detach:

	i2c_detach_client(new_client);

 failout:

	kfree(new_client);

	return rc;

}



static int

isl1208_attach_adapter (struct i2c_adapter *adapter)

{

	return i2c_probe(adapter, &addr_data, isl1208_probe);

	return rc;

}



static int

isl1208_detach_client(struct i2c_client *client)

isl1208_remove(struct i2c_client *client)

{

	int rc;

	struct rtc_device *const rtc = i2c_get_clientdata(client);

	struct rtc_device *rtc = i2c_get_clientdata(client);



	if (rtc)

		rtc_device_unregister(rtc); /* do we need to kfree? */



	rc = i2c_detach_client(client);

	if (rc)

		return rc;



	kfree(client);

	isl1208_sysfs_unregister(&client->dev);

	rtc_device_unregister(rtc);



	return 0;

}



/* module management */

static struct i2c_driver isl1208_driver = {

	.driver = {

		   .name = "rtc-isl1208",

		   },

	.probe = isl1208_probe,

	.remove = isl1208_remove,

};



static int __init isl1208_init(void)

static int __init

isl1208_init(void)

{

	return i2c_add_driver(&isl1208_driver);

}



static void __exit isl1208_exit(void)

static void __exit

isl1208_exit(void)

{

	i2c_del_driver(&isl1208_driver);

}