rtc-s35390 driver

 

/*
 * Filename:rtc-s35390a.h
 * Author :xxx.zhjy
 * Date :2011.11.4
 */

const u8 byte_rev_table[256] = {
 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
};
static inline u8 bitrev8(u8 byte)
{
 return byte_rev_table[byte];
}

/*
 * Filename:rtc-s35390a.c
 * Author :xxx.zhjy
 * Date :2011.11.4
 */

/*Include files*/
#include
#include
#include
#include
#include
#include "rtc-s35390a.h"
#define S35390A_DEBUG 

#define S35390A_CMD_STATUS1 0
#define S35390A_CMD_STATUS2 1
#define S35390A_CMD_TIME1 2

#define S35390A_BYTE_YEAR 0
#define S35390A_BYTE_MONTH 1
#define S35390A_BYTE_DAY 2
#define S35390A_BYTE_WDAY 3
#define S35390A_BYTE_HOURS 4
#define S35390A_BYTE_MINS 5
#define S35390A_BYTE_SECS 6

#define S35390A_FLAG_POC 0x01
#define S35390A_FLAG_BLD 0x02
#define S35390A_FLAG_24H 0x40
#define S35390A_FLAG_RESET 0x80
#define S35390A_FLAG_TEST 0x01

#ifdef S35390A_DEBUG
#define S35390A_DBGINFO() printk(KERN_INFO "S35390A_DRV_DEBUG_INFO:%s, %s, %d!\n",__FILE__,__func__,__LINE__)
#else
#define S35390A_DBGINFO() do{ } while(0)
#endif

static unsigned short ignore[] = { I2C_CLIENT_END };
static unsigned short normal_addr[] = { 0x30, I2C_CLIENT_END };
static unsigned short *forces[] = { NULL };

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

struct s35390a {
 struct i2c_client client;
 struct rtc_device *rtc;
 unsigned char mode_24;
};

static int s35390a_set_reg(struct s35390a *s35390a, int reg, char *buf, int len)
{
 struct i2c_client *client = &s35390a->client;
 struct i2c_msg msg[] = {
  { client->addr + reg, 0, len, buf },
 };

 if ((i2c_transfer(client->adapter, msg, 1)) != 1)
  return -EIO;

 return 0;
}

static int s35390a_get_reg(struct s35390a *s35390a, int reg, char *buf, int len)
{
 struct i2c_client *client = &s35390a->client;
 struct i2c_msg msg[] = {
  { client->addr + reg, I2C_M_RD, len, buf },
 };

 if ((i2c_transfer(client->adapter, msg, 1)) != 1)
  return -EIO;

 return 0;
}

static char s35390a_hr2reg(struct s35390a *s35390a, int hour)
{
 if (s35390a->mode_24)
  return BIN2BCD(hour);

 if (hour < 12)
  return BIN2BCD(hour);

 return 0x40 | BIN2BCD(hour - 12);
}

static int s35390a_reg2hr(struct s35390a *s35390a, char reg)
{
 unsigned hour;

 if (s35390a->mode_24)
  return BCD2BIN(reg & 0x3f);

 hour = BCD2BIN(reg & 0x3f);
 if (reg & 0x40)
  hour += 12;

 return hour;
}

static int s35390a_set_datetime(struct i2c_client *client, struct rtc_time *tm)
{
 struct s35390a *s35390a = i2c_get_clientdata(client);
 int i, err;
 char buf[7];

 dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d mday=%d, "
  "mon=%d, year=%d, wday=%d\n", __func__, tm->tm_sec,
  tm->tm_min, tm->tm_hour, tm->tm_mday, tm->tm_mon, tm->tm_year,
  tm->tm_wday);

 buf[S35390A_BYTE_YEAR] = BIN2BCD(tm->tm_year - 100);
 buf[S35390A_BYTE_MONTH] = BIN2BCD(tm->tm_mon + 1);
 buf[S35390A_BYTE_DAY] = BIN2BCD(tm->tm_mday);
 buf[S35390A_BYTE_WDAY] = BIN2BCD(tm->tm_wday);
 buf[S35390A_BYTE_HOURS] = s35390a_hr2reg(s35390a, tm->tm_hour);
 buf[S35390A_BYTE_MINS] = BIN2BCD(tm->tm_min);
 buf[S35390A_BYTE_SECS] = BIN2BCD(tm->tm_sec);

 /* This chip expects the bits of each byte to be in reverse order */
 for (i = 0; i < 7; ++i)
  buf[i] = bitrev8(buf[i]);

 err = s35390a_set_reg(s35390a, S35390A_CMD_TIME1, buf, sizeof(buf));

 return err;
}

static int s35390a_get_datetime(struct i2c_client *client, struct rtc_time *tm)
{
 struct s35390a *s35390a = i2c_get_clientdata(client);
 char buf[7];
 int i, err;

 err = s35390a_get_reg(s35390a, S35390A_CMD_TIME1, buf, sizeof(buf));
 if (err < 0)
  return err;

 /* This chip returns the bits of each byte in reverse order */
 for (i = 0; i < 7; ++i)
  buf[i] = bitrev8(buf[i]);

 tm->tm_sec = BCD2BIN(buf[S35390A_BYTE_SECS]);
 tm->tm_min = BCD2BIN(buf[S35390A_BYTE_MINS]);
 tm->tm_hour = s35390a_reg2hr(s35390a, buf[S35390A_BYTE_HOURS]);
 tm->tm_wday = BCD2BIN(buf[S35390A_BYTE_WDAY]);
 tm->tm_mday = BCD2BIN(buf[S35390A_BYTE_DAY]);
 tm->tm_mon = BCD2BIN(buf[S35390A_BYTE_MONTH]) - 1;
 tm->tm_year = BCD2BIN(buf[S35390A_BYTE_YEAR]) + 100;

 dev_dbg(&client->dev,"%s: tm is secs=%d, mins=%d, hours=%d, mday=%d, "
  "mon=%d, year=%d, wday=%d\n", __func__, tm->tm_sec,
  tm->tm_min, tm->tm_hour, tm->tm_mday, tm->tm_mon, tm->tm_year,
  tm->tm_wday);

 return rtc_valid_tm(tm);
}

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

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

static int s35390a_reset(struct s35390a *s35390a)
{
 char buf[1];
 
 if (s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, buf, sizeof(buf)) < 0)
  return -EIO;

 if (!(buf[0] & (S35390A_FLAG_POC | S35390A_FLAG_BLD)))
 {
  return 0;
 }

 buf[0] |= (S35390A_FLAG_RESET | S35390A_FLAG_24H);
 buf[0] &= 0xf0;
 
 return s35390a_set_reg(s35390a, S35390A_CMD_STATUS1, buf, sizeof(buf));
}

static int s35390a_disable_test_mode(struct s35390a *s35390a)
{
 char buf[1];

 if (s35390a_get_reg(s35390a, S35390A_CMD_STATUS2, buf, sizeof(buf)) < 0)
  return -EIO;

 if (!(buf[0] & S35390A_FLAG_TEST))
  return 0;

 buf[0] &= ~S35390A_FLAG_TEST;
 return s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, buf, sizeof(buf));
}

static int s35390a_probe(struct i2c_adapter *adap, int addr, int kind);

static int s35390a_attach(struct i2c_adapter *adap)
{
 S35390A_DBGINFO();
 return i2c_probe(adap, &addr_data, s35390a_probe);
}

static int s35390a_detach(struct i2c_client *client)
{
 int err;
 struct rtc_device *rtc = i2c_get_clientdata(client);

 if (rtc)
  rtc_device_unregister(rtc);

 if ((err = i2c_detach_client(client)))
  return err;

 kfree(client);

 return 0;
}

static struct rtc_class_ops s35390a_rtc_ops = {
 .read_time = s35390a_rtc_read_time,
 .set_time = s35390a_rtc_set_time,
};

static struct i2c_driver s35390a_driver = {
 .driver = {
  .name = "S35390",
 },
 .id = I2C_DRIVERID_S35390,
 .attach_adapter = s35390a_attach,
 .detach_client = s35390a_detach,
};

static int s35390a_probe(struct i2c_adapter *adap, int addr, int kind)
{
 struct s35390a *s35390a;
 struct i2c_client *client;
 int err;
 char buf[1];
 struct rtc_time tm;
 
 S35390A_DBGINFO();
 
 if (!i2c_check_functionality(adap, I2C_FUNC_I2C)) {
  err = -ENODEV;
  goto exit;
 }
 
 s35390a = kzalloc(sizeof(struct s35390a), GFP_KERNEL);
 if(!s35390a)
 {
  return -ENOMEM;
 }
 
 client = &s35390a->client;
 client->addr = addr;
 client->adapter = adap;
 client->driver = &s35390a_driver;
 client->flags = 0;
 strlcpy(client->name, s35390a_driver.driver.name, I2C_NAME_SIZE);
 
 i2c_set_clientdata(client, s35390a);
 
 if ((err = i2c_attach_client(client)))
 {
  goto exit_kfree;
 }
 
 err = s35390a_reset(s35390a);
 if (err < 0) {
  dev_err(&client->dev, "error resetting chip\n");
  goto exit_detach;
 }
 
 err = s35390a_disable_test_mode(s35390a);
 if (err < 0) {
  dev_err(&client->dev, "error disabling test mode\n");
  goto exit_detach;
 }
 
 err = s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, buf, sizeof(buf));
 if (err < 0) {
  dev_err(&client->dev, "error checking 12/24 hour mode\n");
  goto exit_detach;
 }
 
 printk("%s,%s,%x\n",__FILE__,__func__,buf[0]);
 
 if (buf[0] & S35390A_FLAG_24H)
  s35390a->mode_24 = 1;
 else
  s35390a->mode_24 = 0;
  
 if (s35390a_get_datetime(client, &tm) < 0)
  dev_warn(&client->dev, "clock needs to be set\n");
 printk("%s: tm is secs=%d, mins=%d, hours=%d, mday=%d, "
  "mon=%d, year=%d, wday=%d\n", __func__, tm.tm_sec,
  tm.tm_min, tm.tm_hour, tm.tm_mday, tm.tm_mon, tm.tm_year,
  tm.tm_wday); 
   
 s35390a->rtc = rtc_device_register(s35390a_driver.driver.name, &client->dev,
    &s35390a_rtc_ops, THIS_MODULE);

 if (IS_ERR(s35390a->rtc))
 {
  err = PTR_ERR(s35390a->rtc);
  goto exit_detach;
 }
 
 return 0;
 
exit_detach:
 i2c_detach_client(client);
exit_kfree:
 kfree(s35390a);
exit:
 return err; 
}

static __init int s35390a_init(void)
{
 S35390A_DBGINFO();
 return i2c_add_driver(&s35390a_driver);
}

static __exit void s35390a_exit(void)
{
 S35390A_DBGINFO();
 i2c_del_driver(&s35390a_driver); 
}

module_init(s35390a_init);
module_exit(s35390a_exit);

MODULE_AUTHOR("kingtoneinfo.zhjy");
MODULE_DESCRIPTION("S-35390A I2C RTC driver");
MODULE_LICENSE("GPL");