rtc-ds1553.c 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * An rtc driver for the Dallas DS1553
  4. *
  5. * Copyright (C) 2006 Atsushi Nemoto <anemo@mba.ocn.ne.jp>
  6. */
  7. #include <linux/bcd.h>
  8. #include <linux/init.h>
  9. #include <linux/kernel.h>
  10. #include <linux/gfp.h>
  11. #include <linux/delay.h>
  12. #include <linux/jiffies.h>
  13. #include <linux/interrupt.h>
  14. #include <linux/rtc.h>
  15. #include <linux/platform_device.h>
  16. #include <linux/io.h>
  17. #include <linux/module.h>
  18. #define RTC_REG_SIZE 0x2000
  19. #define RTC_OFFSET 0x1ff0
  20. #define RTC_FLAGS (RTC_OFFSET + 0)
  21. #define RTC_SECONDS_ALARM (RTC_OFFSET + 2)
  22. #define RTC_MINUTES_ALARM (RTC_OFFSET + 3)
  23. #define RTC_HOURS_ALARM (RTC_OFFSET + 4)
  24. #define RTC_DATE_ALARM (RTC_OFFSET + 5)
  25. #define RTC_INTERRUPTS (RTC_OFFSET + 6)
  26. #define RTC_WATCHDOG (RTC_OFFSET + 7)
  27. #define RTC_CONTROL (RTC_OFFSET + 8)
  28. #define RTC_CENTURY (RTC_OFFSET + 8)
  29. #define RTC_SECONDS (RTC_OFFSET + 9)
  30. #define RTC_MINUTES (RTC_OFFSET + 10)
  31. #define RTC_HOURS (RTC_OFFSET + 11)
  32. #define RTC_DAY (RTC_OFFSET + 12)
  33. #define RTC_DATE (RTC_OFFSET + 13)
  34. #define RTC_MONTH (RTC_OFFSET + 14)
  35. #define RTC_YEAR (RTC_OFFSET + 15)
  36. #define RTC_CENTURY_MASK 0x3f
  37. #define RTC_SECONDS_MASK 0x7f
  38. #define RTC_DAY_MASK 0x07
  39. /* Bits in the Control/Century register */
  40. #define RTC_WRITE 0x80
  41. #define RTC_READ 0x40
  42. /* Bits in the Seconds register */
  43. #define RTC_STOP 0x80
  44. /* Bits in the Flags register */
  45. #define RTC_FLAGS_AF 0x40
  46. #define RTC_FLAGS_BLF 0x10
  47. /* Bits in the Interrupts register */
  48. #define RTC_INTS_AE 0x80
  49. struct rtc_plat_data {
  50. struct rtc_device *rtc;
  51. void __iomem *ioaddr;
  52. unsigned long last_jiffies;
  53. int irq;
  54. unsigned int irqen;
  55. int alrm_sec;
  56. int alrm_min;
  57. int alrm_hour;
  58. int alrm_mday;
  59. spinlock_t lock;
  60. };
  61. static int ds1553_rtc_set_time(struct device *dev, struct rtc_time *tm)
  62. {
  63. struct rtc_plat_data *pdata = dev_get_drvdata(dev);
  64. void __iomem *ioaddr = pdata->ioaddr;
  65. u8 century;
  66. century = bin2bcd((tm->tm_year + 1900) / 100);
  67. writeb(RTC_WRITE, pdata->ioaddr + RTC_CONTROL);
  68. writeb(bin2bcd(tm->tm_year % 100), ioaddr + RTC_YEAR);
  69. writeb(bin2bcd(tm->tm_mon + 1), ioaddr + RTC_MONTH);
  70. writeb(bin2bcd(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
  71. writeb(bin2bcd(tm->tm_mday), ioaddr + RTC_DATE);
  72. writeb(bin2bcd(tm->tm_hour), ioaddr + RTC_HOURS);
  73. writeb(bin2bcd(tm->tm_min), ioaddr + RTC_MINUTES);
  74. writeb(bin2bcd(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
  75. /* RTC_CENTURY and RTC_CONTROL share same register */
  76. writeb(RTC_WRITE | (century & RTC_CENTURY_MASK), ioaddr + RTC_CENTURY);
  77. writeb(century & RTC_CENTURY_MASK, ioaddr + RTC_CONTROL);
  78. return 0;
  79. }
  80. static int ds1553_rtc_read_time(struct device *dev, struct rtc_time *tm)
  81. {
  82. struct rtc_plat_data *pdata = dev_get_drvdata(dev);
  83. void __iomem *ioaddr = pdata->ioaddr;
  84. unsigned int year, month, day, hour, minute, second, week;
  85. unsigned int century;
  86. /* give enough time to update RTC in case of continuous read */
  87. if (pdata->last_jiffies == jiffies)
  88. msleep(1);
  89. pdata->last_jiffies = jiffies;
  90. writeb(RTC_READ, ioaddr + RTC_CONTROL);
  91. second = readb(ioaddr + RTC_SECONDS) & RTC_SECONDS_MASK;
  92. minute = readb(ioaddr + RTC_MINUTES);
  93. hour = readb(ioaddr + RTC_HOURS);
  94. day = readb(ioaddr + RTC_DATE);
  95. week = readb(ioaddr + RTC_DAY) & RTC_DAY_MASK;
  96. month = readb(ioaddr + RTC_MONTH);
  97. year = readb(ioaddr + RTC_YEAR);
  98. century = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK;
  99. writeb(0, ioaddr + RTC_CONTROL);
  100. tm->tm_sec = bcd2bin(second);
  101. tm->tm_min = bcd2bin(minute);
  102. tm->tm_hour = bcd2bin(hour);
  103. tm->tm_mday = bcd2bin(day);
  104. tm->tm_wday = bcd2bin(week);
  105. tm->tm_mon = bcd2bin(month) - 1;
  106. /* year is 1900 + tm->tm_year */
  107. tm->tm_year = bcd2bin(year) + bcd2bin(century) * 100 - 1900;
  108. return 0;
  109. }
  110. static void ds1553_rtc_update_alarm(struct rtc_plat_data *pdata)
  111. {
  112. void __iomem *ioaddr = pdata->ioaddr;
  113. unsigned long flags;
  114. spin_lock_irqsave(&pdata->lock, flags);
  115. writeb(pdata->alrm_mday < 0 || (pdata->irqen & RTC_UF) ?
  116. 0x80 : bin2bcd(pdata->alrm_mday),
  117. ioaddr + RTC_DATE_ALARM);
  118. writeb(pdata->alrm_hour < 0 || (pdata->irqen & RTC_UF) ?
  119. 0x80 : bin2bcd(pdata->alrm_hour),
  120. ioaddr + RTC_HOURS_ALARM);
  121. writeb(pdata->alrm_min < 0 || (pdata->irqen & RTC_UF) ?
  122. 0x80 : bin2bcd(pdata->alrm_min),
  123. ioaddr + RTC_MINUTES_ALARM);
  124. writeb(pdata->alrm_sec < 0 || (pdata->irqen & RTC_UF) ?
  125. 0x80 : bin2bcd(pdata->alrm_sec),
  126. ioaddr + RTC_SECONDS_ALARM);
  127. writeb(pdata->irqen ? RTC_INTS_AE : 0, ioaddr + RTC_INTERRUPTS);
  128. readb(ioaddr + RTC_FLAGS); /* clear interrupts */
  129. spin_unlock_irqrestore(&pdata->lock, flags);
  130. }
  131. static int ds1553_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
  132. {
  133. struct rtc_plat_data *pdata = dev_get_drvdata(dev);
  134. if (pdata->irq <= 0)
  135. return -EINVAL;
  136. pdata->alrm_mday = alrm->time.tm_mday;
  137. pdata->alrm_hour = alrm->time.tm_hour;
  138. pdata->alrm_min = alrm->time.tm_min;
  139. pdata->alrm_sec = alrm->time.tm_sec;
  140. if (alrm->enabled)
  141. pdata->irqen |= RTC_AF;
  142. ds1553_rtc_update_alarm(pdata);
  143. return 0;
  144. }
  145. static int ds1553_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
  146. {
  147. struct rtc_plat_data *pdata = dev_get_drvdata(dev);
  148. if (pdata->irq <= 0)
  149. return -EINVAL;
  150. alrm->time.tm_mday = pdata->alrm_mday < 0 ? 0 : pdata->alrm_mday;
  151. alrm->time.tm_hour = pdata->alrm_hour < 0 ? 0 : pdata->alrm_hour;
  152. alrm->time.tm_min = pdata->alrm_min < 0 ? 0 : pdata->alrm_min;
  153. alrm->time.tm_sec = pdata->alrm_sec < 0 ? 0 : pdata->alrm_sec;
  154. alrm->enabled = (pdata->irqen & RTC_AF) ? 1 : 0;
  155. return 0;
  156. }
  157. static irqreturn_t ds1553_rtc_interrupt(int irq, void *dev_id)
  158. {
  159. struct platform_device *pdev = dev_id;
  160. struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
  161. void __iomem *ioaddr = pdata->ioaddr;
  162. unsigned long events = 0;
  163. spin_lock(&pdata->lock);
  164. /* read and clear interrupt */
  165. if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_AF) {
  166. events = RTC_IRQF;
  167. if (readb(ioaddr + RTC_SECONDS_ALARM) & 0x80)
  168. events |= RTC_UF;
  169. else
  170. events |= RTC_AF;
  171. rtc_update_irq(pdata->rtc, 1, events);
  172. }
  173. spin_unlock(&pdata->lock);
  174. return events ? IRQ_HANDLED : IRQ_NONE;
  175. }
  176. static int ds1553_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
  177. {
  178. struct rtc_plat_data *pdata = dev_get_drvdata(dev);
  179. if (pdata->irq <= 0)
  180. return -EINVAL;
  181. if (enabled)
  182. pdata->irqen |= RTC_AF;
  183. else
  184. pdata->irqen &= ~RTC_AF;
  185. ds1553_rtc_update_alarm(pdata);
  186. return 0;
  187. }
  188. static const struct rtc_class_ops ds1553_rtc_ops = {
  189. .read_time = ds1553_rtc_read_time,
  190. .set_time = ds1553_rtc_set_time,
  191. .read_alarm = ds1553_rtc_read_alarm,
  192. .set_alarm = ds1553_rtc_set_alarm,
  193. .alarm_irq_enable = ds1553_rtc_alarm_irq_enable,
  194. };
  195. static int ds1553_nvram_read(void *priv, unsigned int pos, void *val,
  196. size_t bytes)
  197. {
  198. struct platform_device *pdev = priv;
  199. struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
  200. void __iomem *ioaddr = pdata->ioaddr;
  201. u8 *buf = val;
  202. for (; bytes; bytes--)
  203. *buf++ = readb(ioaddr + pos++);
  204. return 0;
  205. }
  206. static int ds1553_nvram_write(void *priv, unsigned int pos, void *val,
  207. size_t bytes)
  208. {
  209. struct platform_device *pdev = priv;
  210. struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
  211. void __iomem *ioaddr = pdata->ioaddr;
  212. u8 *buf = val;
  213. for (; bytes; bytes--)
  214. writeb(*buf++, ioaddr + pos++);
  215. return 0;
  216. }
  217. static int ds1553_rtc_probe(struct platform_device *pdev)
  218. {
  219. unsigned int cen, sec;
  220. struct rtc_plat_data *pdata;
  221. void __iomem *ioaddr;
  222. int ret = 0;
  223. struct nvmem_config nvmem_cfg = {
  224. .name = "ds1553_nvram",
  225. .word_size = 1,
  226. .stride = 1,
  227. .size = RTC_OFFSET,
  228. .reg_read = ds1553_nvram_read,
  229. .reg_write = ds1553_nvram_write,
  230. .priv = pdev,
  231. };
  232. pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
  233. if (!pdata)
  234. return -ENOMEM;
  235. ioaddr = devm_platform_ioremap_resource(pdev, 0);
  236. if (IS_ERR(ioaddr))
  237. return PTR_ERR(ioaddr);
  238. pdata->ioaddr = ioaddr;
  239. pdata->irq = platform_get_irq(pdev, 0);
  240. /* turn RTC on if it was not on */
  241. sec = readb(ioaddr + RTC_SECONDS);
  242. if (sec & RTC_STOP) {
  243. sec &= RTC_SECONDS_MASK;
  244. cen = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK;
  245. writeb(RTC_WRITE, ioaddr + RTC_CONTROL);
  246. writeb(sec, ioaddr + RTC_SECONDS);
  247. writeb(cen & RTC_CENTURY_MASK, ioaddr + RTC_CONTROL);
  248. }
  249. if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_BLF)
  250. dev_warn(&pdev->dev, "voltage-low detected.\n");
  251. spin_lock_init(&pdata->lock);
  252. pdata->last_jiffies = jiffies;
  253. platform_set_drvdata(pdev, pdata);
  254. pdata->rtc = devm_rtc_allocate_device(&pdev->dev);
  255. if (IS_ERR(pdata->rtc))
  256. return PTR_ERR(pdata->rtc);
  257. pdata->rtc->ops = &ds1553_rtc_ops;
  258. pdata->rtc->nvram_old_abi = true;
  259. ret = rtc_register_device(pdata->rtc);
  260. if (ret)
  261. return ret;
  262. if (pdata->irq > 0) {
  263. writeb(0, ioaddr + RTC_INTERRUPTS);
  264. if (devm_request_irq(&pdev->dev, pdata->irq,
  265. ds1553_rtc_interrupt,
  266. 0, pdev->name, pdev) < 0) {
  267. dev_warn(&pdev->dev, "interrupt not available.\n");
  268. pdata->irq = 0;
  269. }
  270. }
  271. if (rtc_nvmem_register(pdata->rtc, &nvmem_cfg))
  272. dev_err(&pdev->dev, "unable to register nvmem\n");
  273. return 0;
  274. }
  275. /* work with hotplug and coldplug */
  276. MODULE_ALIAS("platform:rtc-ds1553");
  277. static struct platform_driver ds1553_rtc_driver = {
  278. .probe = ds1553_rtc_probe,
  279. .driver = {
  280. .name = "rtc-ds1553",
  281. },
  282. };
  283. module_platform_driver(ds1553_rtc_driver);
  284. MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
  285. MODULE_DESCRIPTION("Dallas DS1553 RTC driver");
  286. MODULE_LICENSE("GPL");