rtc-rs5c372.c 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298
  1. /*
  2. * An I2C driver for the Ricoh RS5C372 RTC
  3. *
  4. * Copyright (C) 2005 Pavel Mironchik <pmironchik@optifacio.net>
  5. * Copyright (C) 2006 Tower Technologies
  6. *
  7. * This program is free software; you can redistribute it and/or modify
  8. * it under the terms of the GNU General Public License version 2 as
  9. * published by the Free Software Foundation.
  10. */
  11. #include <linux/i2c.h>
  12. #include <linux/rtc.h>
  13. #include <linux/bcd.h>
  14. #define DRV_VERSION "0.2"
  15. /* Addresses to scan */
  16. static unsigned short normal_i2c[] = { /* 0x32,*/ I2C_CLIENT_END };
  17. /* Insmod parameters */
  18. I2C_CLIENT_INSMOD;
  19. #define RS5C372_REG_SECS 0
  20. #define RS5C372_REG_MINS 1
  21. #define RS5C372_REG_HOURS 2
  22. #define RS5C372_REG_WDAY 3
  23. #define RS5C372_REG_DAY 4
  24. #define RS5C372_REG_MONTH 5
  25. #define RS5C372_REG_YEAR 6
  26. #define RS5C372_REG_TRIM 7
  27. #define RS5C372_TRIM_XSL 0x80
  28. #define RS5C372_TRIM_MASK 0x7F
  29. #define RS5C372_REG_BASE 0
  30. static int rs5c372_attach(struct i2c_adapter *adapter);
  31. static int rs5c372_detach(struct i2c_client *client);
  32. static int rs5c372_probe(struct i2c_adapter *adapter, int address, int kind);
  33. static struct i2c_driver rs5c372_driver = {
  34. .driver = {
  35. .name = "rs5c372",
  36. },
  37. .attach_adapter = &rs5c372_attach,
  38. .detach_client = &rs5c372_detach,
  39. };
  40. static int rs5c372_get_datetime(struct i2c_client *client, struct rtc_time *tm)
  41. {
  42. unsigned char buf[7] = { RS5C372_REG_BASE };
  43. /* this implements the 1st reading method, according
  44. * to the datasheet. buf[0] is initialized with
  45. * address ptr and transmission format register.
  46. */
  47. struct i2c_msg msgs[] = {
  48. { client->addr, 0, 1, buf },
  49. { client->addr, I2C_M_RD, 7, buf },
  50. };
  51. if ((i2c_transfer(client->adapter, msgs, 2)) != 2) {
  52. dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
  53. return -EIO;
  54. }
  55. tm->tm_sec = BCD2BIN(buf[RS5C372_REG_SECS] & 0x7f);
  56. tm->tm_min = BCD2BIN(buf[RS5C372_REG_MINS] & 0x7f);
  57. tm->tm_hour = BCD2BIN(buf[RS5C372_REG_HOURS] & 0x3f);
  58. tm->tm_wday = BCD2BIN(buf[RS5C372_REG_WDAY] & 0x07);
  59. tm->tm_mday = BCD2BIN(buf[RS5C372_REG_DAY] & 0x3f);
  60. /* tm->tm_mon is zero-based */
  61. tm->tm_mon = BCD2BIN(buf[RS5C372_REG_MONTH] & 0x1f) - 1;
  62. /* year is 1900 + tm->tm_year */
  63. tm->tm_year = BCD2BIN(buf[RS5C372_REG_YEAR]) + 100;
  64. dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
  65. "mday=%d, mon=%d, year=%d, wday=%d\n",
  66. __FUNCTION__,
  67. tm->tm_sec, tm->tm_min, tm->tm_hour,
  68. tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
  69. return 0;
  70. }
  71. static int rs5c372_set_datetime(struct i2c_client *client, struct rtc_time *tm)
  72. {
  73. unsigned char buf[8] = { RS5C372_REG_BASE };
  74. dev_dbg(&client->dev,
  75. "%s: secs=%d, mins=%d, hours=%d "
  76. "mday=%d, mon=%d, year=%d, wday=%d\n",
  77. __FUNCTION__, tm->tm_sec, tm->tm_min, tm->tm_hour,
  78. tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
  79. buf[1] = BIN2BCD(tm->tm_sec);
  80. buf[2] = BIN2BCD(tm->tm_min);
  81. buf[3] = BIN2BCD(tm->tm_hour);
  82. buf[4] = BIN2BCD(tm->tm_wday);
  83. buf[5] = BIN2BCD(tm->tm_mday);
  84. buf[6] = BIN2BCD(tm->tm_mon + 1);
  85. buf[7] = BIN2BCD(tm->tm_year - 100);
  86. if ((i2c_master_send(client, buf, 8)) != 8) {
  87. dev_err(&client->dev, "%s: write error\n", __FUNCTION__);
  88. return -EIO;
  89. }
  90. return 0;
  91. }
  92. static int rs5c372_get_trim(struct i2c_client *client, int *osc, int *trim)
  93. {
  94. unsigned char buf = RS5C372_REG_TRIM;
  95. struct i2c_msg msgs[] = {
  96. { client->addr, 0, 1, &buf },
  97. { client->addr, I2C_M_RD, 1, &buf },
  98. };
  99. if ((i2c_transfer(client->adapter, msgs, 2)) != 2) {
  100. dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
  101. return -EIO;
  102. }
  103. if (osc)
  104. *osc = (buf & RS5C372_TRIM_XSL) ? 32000 : 32768;
  105. if (trim) {
  106. *trim = buf & RS5C372_TRIM_MASK;
  107. dev_dbg(&client->dev, "%s: raw trim=%x\n", __FUNCTION__, *trim);
  108. }
  109. return 0;
  110. }
  111. static int rs5c372_rtc_read_time(struct device *dev, struct rtc_time *tm)
  112. {
  113. return rs5c372_get_datetime(to_i2c_client(dev), tm);
  114. }
  115. static int rs5c372_rtc_set_time(struct device *dev, struct rtc_time *tm)
  116. {
  117. return rs5c372_set_datetime(to_i2c_client(dev), tm);
  118. }
  119. static int rs5c372_rtc_proc(struct device *dev, struct seq_file *seq)
  120. {
  121. int err, osc, trim;
  122. err = rs5c372_get_trim(to_i2c_client(dev), &osc, &trim);
  123. if (err == 0) {
  124. seq_printf(seq, "%d.%03d KHz\n", osc / 1000, osc % 1000);
  125. seq_printf(seq, "trim\t: %d\n", trim);
  126. }
  127. return 0;
  128. }
  129. static const struct rtc_class_ops rs5c372_rtc_ops = {
  130. .proc = rs5c372_rtc_proc,
  131. .read_time = rs5c372_rtc_read_time,
  132. .set_time = rs5c372_rtc_set_time,
  133. };
  134. static ssize_t rs5c372_sysfs_show_trim(struct device *dev,
  135. struct device_attribute *attr, char *buf)
  136. {
  137. int err, trim;
  138. err = rs5c372_get_trim(to_i2c_client(dev), NULL, &trim);
  139. if (err)
  140. return err;
  141. return sprintf(buf, "0x%2x\n", trim);
  142. }
  143. static DEVICE_ATTR(trim, S_IRUGO, rs5c372_sysfs_show_trim, NULL);
  144. static ssize_t rs5c372_sysfs_show_osc(struct device *dev,
  145. struct device_attribute *attr, char *buf)
  146. {
  147. int err, osc;
  148. err = rs5c372_get_trim(to_i2c_client(dev), &osc, NULL);
  149. if (err)
  150. return err;
  151. return sprintf(buf, "%d.%03d KHz\n", osc / 1000, osc % 1000);
  152. }
  153. static DEVICE_ATTR(osc, S_IRUGO, rs5c372_sysfs_show_osc, NULL);
  154. static int rs5c372_attach(struct i2c_adapter *adapter)
  155. {
  156. return i2c_probe(adapter, &addr_data, rs5c372_probe);
  157. }
  158. static int rs5c372_probe(struct i2c_adapter *adapter, int address, int kind)
  159. {
  160. int err = 0;
  161. struct i2c_client *client;
  162. struct rtc_device *rtc;
  163. dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
  164. if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
  165. err = -ENODEV;
  166. goto exit;
  167. }
  168. if (!(client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL))) {
  169. err = -ENOMEM;
  170. goto exit;
  171. }
  172. /* I2C client */
  173. client->addr = address;
  174. client->driver = &rs5c372_driver;
  175. client->adapter = adapter;
  176. strlcpy(client->name, rs5c372_driver.driver.name, I2C_NAME_SIZE);
  177. /* Inform the i2c layer */
  178. if ((err = i2c_attach_client(client)))
  179. goto exit_kfree;
  180. dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
  181. rtc = rtc_device_register(rs5c372_driver.driver.name, &client->dev,
  182. &rs5c372_rtc_ops, THIS_MODULE);
  183. if (IS_ERR(rtc)) {
  184. err = PTR_ERR(rtc);
  185. goto exit_detach;
  186. }
  187. i2c_set_clientdata(client, rtc);
  188. err = device_create_file(&client->dev, &dev_attr_trim);
  189. if (err) goto exit_devreg;
  190. err = device_create_file(&client->dev, &dev_attr_osc);
  191. if (err) goto exit_trim;
  192. return 0;
  193. exit_trim:
  194. device_remove_file(&client->dev, &dev_attr_trim);
  195. exit_devreg:
  196. rtc_device_unregister(rtc);
  197. exit_detach:
  198. i2c_detach_client(client);
  199. exit_kfree:
  200. kfree(client);
  201. exit:
  202. return err;
  203. }
  204. static int rs5c372_detach(struct i2c_client *client)
  205. {
  206. int err;
  207. struct rtc_device *rtc = i2c_get_clientdata(client);
  208. if (rtc)
  209. rtc_device_unregister(rtc);
  210. if ((err = i2c_detach_client(client)))
  211. return err;
  212. kfree(client);
  213. return 0;
  214. }
  215. static __init int rs5c372_init(void)
  216. {
  217. return i2c_add_driver(&rs5c372_driver);
  218. }
  219. static __exit void rs5c372_exit(void)
  220. {
  221. i2c_del_driver(&rs5c372_driver);
  222. }
  223. module_init(rs5c372_init);
  224. module_exit(rs5c372_exit);
  225. MODULE_AUTHOR(
  226. "Pavel Mironchik <pmironchik@optifacio.net>, "
  227. "Alessandro Zummo <a.zummo@towertech.it>");
  228. MODULE_DESCRIPTION("Ricoh RS5C372 RTC driver");
  229. MODULE_LICENSE("GPL");
  230. MODULE_VERSION(DRV_VERSION);