rtc-moxart.c 8.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * MOXA ART RTC driver.
  4. *
  5. * Copyright (C) 2013 Jonas Jensen
  6. *
  7. * Jonas Jensen <jonas.jensen@gmail.com>
  8. *
  9. * Based on code from
  10. * Moxa Technology Co., Ltd. <www.moxa.com>
  11. */
  12. #include <linux/init.h>
  13. #include <linux/kernel.h>
  14. #include <linux/delay.h>
  15. #include <linux/rtc.h>
  16. #include <linux/platform_device.h>
  17. #include <linux/module.h>
  18. #include <linux/gpio.h>
  19. #include <linux/of_gpio.h>
  20. #define GPIO_RTC_RESERVED 0x0C
  21. #define GPIO_RTC_DATA_SET 0x10
  22. #define GPIO_RTC_DATA_CLEAR 0x14
  23. #define GPIO_RTC_PIN_PULL_ENABLE 0x18
  24. #define GPIO_RTC_PIN_PULL_TYPE 0x1C
  25. #define GPIO_RTC_INT_ENABLE 0x20
  26. #define GPIO_RTC_INT_RAW_STATE 0x24
  27. #define GPIO_RTC_INT_MASKED_STATE 0x28
  28. #define GPIO_RTC_INT_MASK 0x2C
  29. #define GPIO_RTC_INT_CLEAR 0x30
  30. #define GPIO_RTC_INT_TRIGGER 0x34
  31. #define GPIO_RTC_INT_BOTH 0x38
  32. #define GPIO_RTC_INT_RISE_NEG 0x3C
  33. #define GPIO_RTC_BOUNCE_ENABLE 0x40
  34. #define GPIO_RTC_BOUNCE_PRE_SCALE 0x44
  35. #define GPIO_RTC_PROTECT_W 0x8E
  36. #define GPIO_RTC_PROTECT_R 0x8F
  37. #define GPIO_RTC_YEAR_W 0x8C
  38. #define GPIO_RTC_YEAR_R 0x8D
  39. #define GPIO_RTC_DAY_W 0x8A
  40. #define GPIO_RTC_DAY_R 0x8B
  41. #define GPIO_RTC_MONTH_W 0x88
  42. #define GPIO_RTC_MONTH_R 0x89
  43. #define GPIO_RTC_DATE_W 0x86
  44. #define GPIO_RTC_DATE_R 0x87
  45. #define GPIO_RTC_HOURS_W 0x84
  46. #define GPIO_RTC_HOURS_R 0x85
  47. #define GPIO_RTC_MINUTES_W 0x82
  48. #define GPIO_RTC_MINUTES_R 0x83
  49. #define GPIO_RTC_SECONDS_W 0x80
  50. #define GPIO_RTC_SECONDS_R 0x81
  51. #define GPIO_RTC_DELAY_TIME 8
  52. struct moxart_rtc {
  53. struct rtc_device *rtc;
  54. spinlock_t rtc_lock;
  55. int gpio_data, gpio_sclk, gpio_reset;
  56. };
  57. static int day_of_year[12] = { 0, 31, 59, 90, 120, 151, 181,
  58. 212, 243, 273, 304, 334 };
  59. static void moxart_rtc_write_byte(struct device *dev, u8 data)
  60. {
  61. struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
  62. int i;
  63. for (i = 0; i < 8; i++, data >>= 1) {
  64. gpio_set_value(moxart_rtc->gpio_sclk, 0);
  65. gpio_set_value(moxart_rtc->gpio_data, ((data & 1) == 1));
  66. udelay(GPIO_RTC_DELAY_TIME);
  67. gpio_set_value(moxart_rtc->gpio_sclk, 1);
  68. udelay(GPIO_RTC_DELAY_TIME);
  69. }
  70. }
  71. static u8 moxart_rtc_read_byte(struct device *dev)
  72. {
  73. struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
  74. int i;
  75. u8 data = 0;
  76. for (i = 0; i < 8; i++) {
  77. gpio_set_value(moxart_rtc->gpio_sclk, 0);
  78. udelay(GPIO_RTC_DELAY_TIME);
  79. gpio_set_value(moxart_rtc->gpio_sclk, 1);
  80. udelay(GPIO_RTC_DELAY_TIME);
  81. if (gpio_get_value(moxart_rtc->gpio_data))
  82. data |= (1 << i);
  83. udelay(GPIO_RTC_DELAY_TIME);
  84. }
  85. return data;
  86. }
  87. static u8 moxart_rtc_read_register(struct device *dev, u8 cmd)
  88. {
  89. struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
  90. u8 data;
  91. unsigned long flags;
  92. local_irq_save(flags);
  93. gpio_direction_output(moxart_rtc->gpio_data, 0);
  94. gpio_set_value(moxart_rtc->gpio_reset, 1);
  95. udelay(GPIO_RTC_DELAY_TIME);
  96. moxart_rtc_write_byte(dev, cmd);
  97. gpio_direction_input(moxart_rtc->gpio_data);
  98. udelay(GPIO_RTC_DELAY_TIME);
  99. data = moxart_rtc_read_byte(dev);
  100. gpio_set_value(moxart_rtc->gpio_sclk, 0);
  101. gpio_set_value(moxart_rtc->gpio_reset, 0);
  102. udelay(GPIO_RTC_DELAY_TIME);
  103. local_irq_restore(flags);
  104. return data;
  105. }
  106. static void moxart_rtc_write_register(struct device *dev, u8 cmd, u8 data)
  107. {
  108. struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
  109. unsigned long flags;
  110. local_irq_save(flags);
  111. gpio_direction_output(moxart_rtc->gpio_data, 0);
  112. gpio_set_value(moxart_rtc->gpio_reset, 1);
  113. udelay(GPIO_RTC_DELAY_TIME);
  114. moxart_rtc_write_byte(dev, cmd);
  115. moxart_rtc_write_byte(dev, data);
  116. gpio_set_value(moxart_rtc->gpio_sclk, 0);
  117. gpio_set_value(moxart_rtc->gpio_reset, 0);
  118. udelay(GPIO_RTC_DELAY_TIME);
  119. local_irq_restore(flags);
  120. }
  121. static int moxart_rtc_set_time(struct device *dev, struct rtc_time *tm)
  122. {
  123. struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
  124. spin_lock_irq(&moxart_rtc->rtc_lock);
  125. moxart_rtc_write_register(dev, GPIO_RTC_PROTECT_W, 0);
  126. moxart_rtc_write_register(dev, GPIO_RTC_YEAR_W,
  127. (((tm->tm_year - 100) / 10) << 4) |
  128. ((tm->tm_year - 100) % 10));
  129. moxart_rtc_write_register(dev, GPIO_RTC_MONTH_W,
  130. (((tm->tm_mon + 1) / 10) << 4) |
  131. ((tm->tm_mon + 1) % 10));
  132. moxart_rtc_write_register(dev, GPIO_RTC_DATE_W,
  133. ((tm->tm_mday / 10) << 4) |
  134. (tm->tm_mday % 10));
  135. moxart_rtc_write_register(dev, GPIO_RTC_HOURS_W,
  136. ((tm->tm_hour / 10) << 4) |
  137. (tm->tm_hour % 10));
  138. moxart_rtc_write_register(dev, GPIO_RTC_MINUTES_W,
  139. ((tm->tm_min / 10) << 4) |
  140. (tm->tm_min % 10));
  141. moxart_rtc_write_register(dev, GPIO_RTC_SECONDS_W,
  142. ((tm->tm_sec / 10) << 4) |
  143. (tm->tm_sec % 10));
  144. moxart_rtc_write_register(dev, GPIO_RTC_PROTECT_W, 0x80);
  145. spin_unlock_irq(&moxart_rtc->rtc_lock);
  146. dev_dbg(dev, "%s: success tm_year=%d tm_mon=%d\n"
  147. "tm_mday=%d tm_hour=%d tm_min=%d tm_sec=%d\n",
  148. __func__, tm->tm_year, tm->tm_mon, tm->tm_mday,
  149. tm->tm_hour, tm->tm_min, tm->tm_sec);
  150. return 0;
  151. }
  152. static int moxart_rtc_read_time(struct device *dev, struct rtc_time *tm)
  153. {
  154. struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
  155. unsigned char v;
  156. spin_lock_irq(&moxart_rtc->rtc_lock);
  157. v = moxart_rtc_read_register(dev, GPIO_RTC_SECONDS_R);
  158. tm->tm_sec = (((v & 0x70) >> 4) * 10) + (v & 0x0F);
  159. v = moxart_rtc_read_register(dev, GPIO_RTC_MINUTES_R);
  160. tm->tm_min = (((v & 0x70) >> 4) * 10) + (v & 0x0F);
  161. v = moxart_rtc_read_register(dev, GPIO_RTC_HOURS_R);
  162. if (v & 0x80) { /* 12-hour mode */
  163. tm->tm_hour = (((v & 0x10) >> 4) * 10) + (v & 0x0F);
  164. if (v & 0x20) { /* PM mode */
  165. tm->tm_hour += 12;
  166. if (tm->tm_hour >= 24)
  167. tm->tm_hour = 0;
  168. }
  169. } else { /* 24-hour mode */
  170. tm->tm_hour = (((v & 0x30) >> 4) * 10) + (v & 0x0F);
  171. }
  172. v = moxart_rtc_read_register(dev, GPIO_RTC_DATE_R);
  173. tm->tm_mday = (((v & 0x30) >> 4) * 10) + (v & 0x0F);
  174. v = moxart_rtc_read_register(dev, GPIO_RTC_MONTH_R);
  175. tm->tm_mon = (((v & 0x10) >> 4) * 10) + (v & 0x0F);
  176. tm->tm_mon--;
  177. v = moxart_rtc_read_register(dev, GPIO_RTC_YEAR_R);
  178. tm->tm_year = (((v & 0xF0) >> 4) * 10) + (v & 0x0F);
  179. tm->tm_year += 100;
  180. if (tm->tm_year <= 69)
  181. tm->tm_year += 100;
  182. v = moxart_rtc_read_register(dev, GPIO_RTC_DAY_R);
  183. tm->tm_wday = (v & 0x0f) - 1;
  184. tm->tm_yday = day_of_year[tm->tm_mon];
  185. tm->tm_yday += (tm->tm_mday - 1);
  186. if (tm->tm_mon >= 2) {
  187. if (!(tm->tm_year % 4) && (tm->tm_year % 100))
  188. tm->tm_yday++;
  189. }
  190. tm->tm_isdst = 0;
  191. spin_unlock_irq(&moxart_rtc->rtc_lock);
  192. return 0;
  193. }
  194. static const struct rtc_class_ops moxart_rtc_ops = {
  195. .read_time = moxart_rtc_read_time,
  196. .set_time = moxart_rtc_set_time,
  197. };
  198. static int moxart_rtc_probe(struct platform_device *pdev)
  199. {
  200. struct moxart_rtc *moxart_rtc;
  201. int ret = 0;
  202. moxart_rtc = devm_kzalloc(&pdev->dev, sizeof(*moxart_rtc), GFP_KERNEL);
  203. if (!moxart_rtc)
  204. return -ENOMEM;
  205. moxart_rtc->gpio_data = of_get_named_gpio(pdev->dev.of_node,
  206. "gpio-rtc-data", 0);
  207. if (!gpio_is_valid(moxart_rtc->gpio_data)) {
  208. dev_err(&pdev->dev, "invalid gpio (data): %d\n",
  209. moxart_rtc->gpio_data);
  210. return moxart_rtc->gpio_data;
  211. }
  212. moxart_rtc->gpio_sclk = of_get_named_gpio(pdev->dev.of_node,
  213. "gpio-rtc-sclk", 0);
  214. if (!gpio_is_valid(moxart_rtc->gpio_sclk)) {
  215. dev_err(&pdev->dev, "invalid gpio (sclk): %d\n",
  216. moxart_rtc->gpio_sclk);
  217. return moxart_rtc->gpio_sclk;
  218. }
  219. moxart_rtc->gpio_reset = of_get_named_gpio(pdev->dev.of_node,
  220. "gpio-rtc-reset", 0);
  221. if (!gpio_is_valid(moxart_rtc->gpio_reset)) {
  222. dev_err(&pdev->dev, "invalid gpio (reset): %d\n",
  223. moxart_rtc->gpio_reset);
  224. return moxart_rtc->gpio_reset;
  225. }
  226. spin_lock_init(&moxart_rtc->rtc_lock);
  227. platform_set_drvdata(pdev, moxart_rtc);
  228. ret = devm_gpio_request(&pdev->dev, moxart_rtc->gpio_data, "rtc_data");
  229. if (ret) {
  230. dev_err(&pdev->dev, "can't get rtc_data gpio\n");
  231. return ret;
  232. }
  233. ret = devm_gpio_request_one(&pdev->dev, moxart_rtc->gpio_sclk,
  234. GPIOF_DIR_OUT, "rtc_sclk");
  235. if (ret) {
  236. dev_err(&pdev->dev, "can't get rtc_sclk gpio\n");
  237. return ret;
  238. }
  239. ret = devm_gpio_request_one(&pdev->dev, moxart_rtc->gpio_reset,
  240. GPIOF_DIR_OUT, "rtc_reset");
  241. if (ret) {
  242. dev_err(&pdev->dev, "can't get rtc_reset gpio\n");
  243. return ret;
  244. }
  245. moxart_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
  246. &moxart_rtc_ops,
  247. THIS_MODULE);
  248. if (IS_ERR(moxart_rtc->rtc)) {
  249. dev_err(&pdev->dev, "devm_rtc_device_register failed\n");
  250. return PTR_ERR(moxart_rtc->rtc);
  251. }
  252. return 0;
  253. }
  254. static const struct of_device_id moxart_rtc_match[] = {
  255. { .compatible = "moxa,moxart-rtc" },
  256. { },
  257. };
  258. MODULE_DEVICE_TABLE(of, moxart_rtc_match);
  259. static struct platform_driver moxart_rtc_driver = {
  260. .probe = moxart_rtc_probe,
  261. .driver = {
  262. .name = "moxart-rtc",
  263. .of_match_table = moxart_rtc_match,
  264. },
  265. };
  266. module_platform_driver(moxart_rtc_driver);
  267. MODULE_DESCRIPTION("MOXART RTC driver");
  268. MODULE_LICENSE("GPL");
  269. MODULE_AUTHOR("Jonas Jensen <jonas.jensen@gmail.com>");