rtc-stk17ta8.c 9.2 KB

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