rtc-pcf8523.c 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (C) 2012 Avionic Design GmbH
  4. */
  5. #include <linux/bcd.h>
  6. #include <linux/i2c.h>
  7. #include <linux/module.h>
  8. #include <linux/rtc.h>
  9. #include <linux/of.h>
  10. #define DRIVER_NAME "rtc-pcf8523"
  11. #define REG_CONTROL1 0x00
  12. #define REG_CONTROL1_CAP_SEL (1 << 7)
  13. #define REG_CONTROL1_STOP (1 << 5)
  14. #define REG_CONTROL3 0x02
  15. #define REG_CONTROL3_PM_BLD (1 << 7) /* battery low detection disabled */
  16. #define REG_CONTROL3_PM_VDD (1 << 6) /* switch-over disabled */
  17. #define REG_CONTROL3_PM_DSM (1 << 5) /* direct switching mode */
  18. #define REG_CONTROL3_PM_MASK 0xe0
  19. #define REG_CONTROL3_BLF (1 << 2) /* battery low bit, read-only */
  20. #define REG_SECONDS 0x03
  21. #define REG_SECONDS_OS (1 << 7)
  22. #define REG_MINUTES 0x04
  23. #define REG_HOURS 0x05
  24. #define REG_DAYS 0x06
  25. #define REG_WEEKDAYS 0x07
  26. #define REG_MONTHS 0x08
  27. #define REG_YEARS 0x09
  28. #define REG_OFFSET 0x0e
  29. #define REG_OFFSET_MODE BIT(7)
  30. static int pcf8523_read(struct i2c_client *client, u8 reg, u8 *valuep)
  31. {
  32. struct i2c_msg msgs[2];
  33. u8 value = 0;
  34. int err;
  35. msgs[0].addr = client->addr;
  36. msgs[0].flags = 0;
  37. msgs[0].len = sizeof(reg);
  38. msgs[0].buf = &reg;
  39. msgs[1].addr = client->addr;
  40. msgs[1].flags = I2C_M_RD;
  41. msgs[1].len = sizeof(value);
  42. msgs[1].buf = &value;
  43. err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
  44. if (err < 0)
  45. return err;
  46. *valuep = value;
  47. return 0;
  48. }
  49. static int pcf8523_write(struct i2c_client *client, u8 reg, u8 value)
  50. {
  51. u8 buffer[2] = { reg, value };
  52. struct i2c_msg msg;
  53. int err;
  54. msg.addr = client->addr;
  55. msg.flags = 0;
  56. msg.len = sizeof(buffer);
  57. msg.buf = buffer;
  58. err = i2c_transfer(client->adapter, &msg, 1);
  59. if (err < 0)
  60. return err;
  61. return 0;
  62. }
  63. static int pcf8523_voltage_low(struct i2c_client *client)
  64. {
  65. u8 value;
  66. int err;
  67. err = pcf8523_read(client, REG_CONTROL3, &value);
  68. if (err < 0)
  69. return err;
  70. return !!(value & REG_CONTROL3_BLF);
  71. }
  72. static int pcf8523_load_capacitance(struct i2c_client *client)
  73. {
  74. u32 load;
  75. u8 value;
  76. int err;
  77. err = pcf8523_read(client, REG_CONTROL1, &value);
  78. if (err < 0)
  79. return err;
  80. load = 12500;
  81. of_property_read_u32(client->dev.of_node, "quartz-load-femtofarads",
  82. &load);
  83. switch (load) {
  84. default:
  85. dev_warn(&client->dev, "Unknown quartz-load-femtofarads value: %d. Assuming 12500",
  86. load);
  87. fallthrough;
  88. case 12500:
  89. value |= REG_CONTROL1_CAP_SEL;
  90. break;
  91. case 7000:
  92. value &= ~REG_CONTROL1_CAP_SEL;
  93. break;
  94. }
  95. err = pcf8523_write(client, REG_CONTROL1, value);
  96. return err;
  97. }
  98. static int pcf8523_set_pm(struct i2c_client *client, u8 pm)
  99. {
  100. u8 value;
  101. int err;
  102. err = pcf8523_read(client, REG_CONTROL3, &value);
  103. if (err < 0)
  104. return err;
  105. value = (value & ~REG_CONTROL3_PM_MASK) | pm;
  106. err = pcf8523_write(client, REG_CONTROL3, value);
  107. if (err < 0)
  108. return err;
  109. return 0;
  110. }
  111. static int pcf8523_stop_rtc(struct i2c_client *client)
  112. {
  113. u8 value;
  114. int err;
  115. err = pcf8523_read(client, REG_CONTROL1, &value);
  116. if (err < 0)
  117. return err;
  118. value |= REG_CONTROL1_STOP;
  119. err = pcf8523_write(client, REG_CONTROL1, value);
  120. if (err < 0)
  121. return err;
  122. return 0;
  123. }
  124. static int pcf8523_start_rtc(struct i2c_client *client)
  125. {
  126. u8 value;
  127. int err;
  128. err = pcf8523_read(client, REG_CONTROL1, &value);
  129. if (err < 0)
  130. return err;
  131. value &= ~REG_CONTROL1_STOP;
  132. err = pcf8523_write(client, REG_CONTROL1, value);
  133. if (err < 0)
  134. return err;
  135. return 0;
  136. }
  137. static int pcf8523_rtc_read_time(struct device *dev, struct rtc_time *tm)
  138. {
  139. struct i2c_client *client = to_i2c_client(dev);
  140. u8 start = REG_SECONDS, regs[7];
  141. struct i2c_msg msgs[2];
  142. int err;
  143. err = pcf8523_voltage_low(client);
  144. if (err < 0) {
  145. return err;
  146. } else if (err > 0) {
  147. dev_err(dev, "low voltage detected, time is unreliable\n");
  148. return -EINVAL;
  149. }
  150. msgs[0].addr = client->addr;
  151. msgs[0].flags = 0;
  152. msgs[0].len = 1;
  153. msgs[0].buf = &start;
  154. msgs[1].addr = client->addr;
  155. msgs[1].flags = I2C_M_RD;
  156. msgs[1].len = sizeof(regs);
  157. msgs[1].buf = regs;
  158. err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
  159. if (err < 0)
  160. return err;
  161. if (regs[0] & REG_SECONDS_OS)
  162. return -EINVAL;
  163. tm->tm_sec = bcd2bin(regs[0] & 0x7f);
  164. tm->tm_min = bcd2bin(regs[1] & 0x7f);
  165. tm->tm_hour = bcd2bin(regs[2] & 0x3f);
  166. tm->tm_mday = bcd2bin(regs[3] & 0x3f);
  167. tm->tm_wday = regs[4] & 0x7;
  168. tm->tm_mon = bcd2bin(regs[5] & 0x1f) - 1;
  169. tm->tm_year = bcd2bin(regs[6]) + 100;
  170. return 0;
  171. }
  172. static int pcf8523_rtc_set_time(struct device *dev, struct rtc_time *tm)
  173. {
  174. struct i2c_client *client = to_i2c_client(dev);
  175. struct i2c_msg msg;
  176. u8 regs[8];
  177. int err;
  178. /*
  179. * The hardware can only store values between 0 and 99 in it's YEAR
  180. * register (with 99 overflowing to 0 on increment).
  181. * After 2100-02-28 we could start interpreting the year to be in the
  182. * interval [2100, 2199], but there is no path to switch in a smooth way
  183. * because the chip handles YEAR=0x00 (and the out-of-spec
  184. * YEAR=0xa0) as a leap year, but 2100 isn't.
  185. */
  186. if (tm->tm_year < 100 || tm->tm_year >= 200)
  187. return -EINVAL;
  188. err = pcf8523_stop_rtc(client);
  189. if (err < 0)
  190. return err;
  191. regs[0] = REG_SECONDS;
  192. /* This will purposely overwrite REG_SECONDS_OS */
  193. regs[1] = bin2bcd(tm->tm_sec);
  194. regs[2] = bin2bcd(tm->tm_min);
  195. regs[3] = bin2bcd(tm->tm_hour);
  196. regs[4] = bin2bcd(tm->tm_mday);
  197. regs[5] = tm->tm_wday;
  198. regs[6] = bin2bcd(tm->tm_mon + 1);
  199. regs[7] = bin2bcd(tm->tm_year - 100);
  200. msg.addr = client->addr;
  201. msg.flags = 0;
  202. msg.len = sizeof(regs);
  203. msg.buf = regs;
  204. err = i2c_transfer(client->adapter, &msg, 1);
  205. if (err < 0) {
  206. /*
  207. * If the time cannot be set, restart the RTC anyway. Note
  208. * that errors are ignored if the RTC cannot be started so
  209. * that we have a chance to propagate the original error.
  210. */
  211. pcf8523_start_rtc(client);
  212. return err;
  213. }
  214. return pcf8523_start_rtc(client);
  215. }
  216. #ifdef CONFIG_RTC_INTF_DEV
  217. static int pcf8523_rtc_ioctl(struct device *dev, unsigned int cmd,
  218. unsigned long arg)
  219. {
  220. struct i2c_client *client = to_i2c_client(dev);
  221. int ret;
  222. switch (cmd) {
  223. case RTC_VL_READ:
  224. ret = pcf8523_voltage_low(client);
  225. if (ret < 0)
  226. return ret;
  227. if (ret)
  228. ret = RTC_VL_BACKUP_LOW;
  229. return put_user(ret, (unsigned int __user *)arg);
  230. default:
  231. return -ENOIOCTLCMD;
  232. }
  233. }
  234. #else
  235. #define pcf8523_rtc_ioctl NULL
  236. #endif
  237. static int pcf8523_rtc_read_offset(struct device *dev, long *offset)
  238. {
  239. struct i2c_client *client = to_i2c_client(dev);
  240. int err;
  241. u8 value;
  242. s8 val;
  243. err = pcf8523_read(client, REG_OFFSET, &value);
  244. if (err < 0)
  245. return err;
  246. /* sign extend the 7-bit offset value */
  247. val = value << 1;
  248. *offset = (value & REG_OFFSET_MODE ? 4069 : 4340) * (val >> 1);
  249. return 0;
  250. }
  251. static int pcf8523_rtc_set_offset(struct device *dev, long offset)
  252. {
  253. struct i2c_client *client = to_i2c_client(dev);
  254. long reg_m0, reg_m1;
  255. u8 value;
  256. reg_m0 = clamp(DIV_ROUND_CLOSEST(offset, 4340), -64L, 63L);
  257. reg_m1 = clamp(DIV_ROUND_CLOSEST(offset, 4069), -64L, 63L);
  258. if (abs(reg_m0 * 4340 - offset) < abs(reg_m1 * 4069 - offset))
  259. value = reg_m0 & 0x7f;
  260. else
  261. value = (reg_m1 & 0x7f) | REG_OFFSET_MODE;
  262. return pcf8523_write(client, REG_OFFSET, value);
  263. }
  264. static const struct rtc_class_ops pcf8523_rtc_ops = {
  265. .read_time = pcf8523_rtc_read_time,
  266. .set_time = pcf8523_rtc_set_time,
  267. .ioctl = pcf8523_rtc_ioctl,
  268. .read_offset = pcf8523_rtc_read_offset,
  269. .set_offset = pcf8523_rtc_set_offset,
  270. };
  271. static int pcf8523_probe(struct i2c_client *client,
  272. const struct i2c_device_id *id)
  273. {
  274. struct rtc_device *rtc;
  275. int err;
  276. if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
  277. return -ENODEV;
  278. err = pcf8523_load_capacitance(client);
  279. if (err < 0)
  280. dev_warn(&client->dev, "failed to set xtal load capacitance: %d",
  281. err);
  282. err = pcf8523_set_pm(client, 0);
  283. if (err < 0)
  284. return err;
  285. rtc = devm_rtc_device_register(&client->dev, DRIVER_NAME,
  286. &pcf8523_rtc_ops, THIS_MODULE);
  287. if (IS_ERR(rtc))
  288. return PTR_ERR(rtc);
  289. return 0;
  290. }
  291. static const struct i2c_device_id pcf8523_id[] = {
  292. { "pcf8523", 0 },
  293. { }
  294. };
  295. MODULE_DEVICE_TABLE(i2c, pcf8523_id);
  296. #ifdef CONFIG_OF
  297. static const struct of_device_id pcf8523_of_match[] = {
  298. { .compatible = "nxp,pcf8523" },
  299. { .compatible = "microcrystal,rv8523" },
  300. { }
  301. };
  302. MODULE_DEVICE_TABLE(of, pcf8523_of_match);
  303. #endif
  304. static struct i2c_driver pcf8523_driver = {
  305. .driver = {
  306. .name = DRIVER_NAME,
  307. .of_match_table = of_match_ptr(pcf8523_of_match),
  308. },
  309. .probe = pcf8523_probe,
  310. .id_table = pcf8523_id,
  311. };
  312. module_i2c_driver(pcf8523_driver);
  313. MODULE_AUTHOR("Thierry Reding <thierry.reding@avionic-design.de>");
  314. MODULE_DESCRIPTION("NXP PCF8523 RTC driver");
  315. MODULE_LICENSE("GPL v2");