rtc-ds1286.c 9.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * DS1286 Real Time Clock interface for Linux
  4. *
  5. * Copyright (C) 1998, 1999, 2000 Ralf Baechle
  6. * Copyright (C) 2008 Thomas Bogendoerfer
  7. *
  8. * Based on code written by Paul Gortmaker.
  9. */
  10. #include <linux/module.h>
  11. #include <linux/rtc.h>
  12. #include <linux/platform_device.h>
  13. #include <linux/bcd.h>
  14. #include <linux/rtc/ds1286.h>
  15. #include <linux/io.h>
  16. #include <linux/slab.h>
  17. struct ds1286_priv {
  18. struct rtc_device *rtc;
  19. u32 __iomem *rtcregs;
  20. spinlock_t lock;
  21. };
  22. static inline u8 ds1286_rtc_read(struct ds1286_priv *priv, int reg)
  23. {
  24. return __raw_readl(&priv->rtcregs[reg]) & 0xff;
  25. }
  26. static inline void ds1286_rtc_write(struct ds1286_priv *priv, u8 data, int reg)
  27. {
  28. __raw_writel(data, &priv->rtcregs[reg]);
  29. }
  30. static int ds1286_alarm_irq_enable(struct device *dev, unsigned int enabled)
  31. {
  32. struct ds1286_priv *priv = dev_get_drvdata(dev);
  33. unsigned long flags;
  34. unsigned char val;
  35. /* Allow or mask alarm interrupts */
  36. spin_lock_irqsave(&priv->lock, flags);
  37. val = ds1286_rtc_read(priv, RTC_CMD);
  38. if (enabled)
  39. val &= ~RTC_TDM;
  40. else
  41. val |= RTC_TDM;
  42. ds1286_rtc_write(priv, val, RTC_CMD);
  43. spin_unlock_irqrestore(&priv->lock, flags);
  44. return 0;
  45. }
  46. #ifdef CONFIG_RTC_INTF_DEV
  47. static int ds1286_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
  48. {
  49. struct ds1286_priv *priv = dev_get_drvdata(dev);
  50. unsigned long flags;
  51. unsigned char val;
  52. switch (cmd) {
  53. case RTC_WIE_OFF:
  54. /* Mask watchdog int. enab. bit */
  55. spin_lock_irqsave(&priv->lock, flags);
  56. val = ds1286_rtc_read(priv, RTC_CMD);
  57. val |= RTC_WAM;
  58. ds1286_rtc_write(priv, val, RTC_CMD);
  59. spin_unlock_irqrestore(&priv->lock, flags);
  60. break;
  61. case RTC_WIE_ON:
  62. /* Allow watchdog interrupts. */
  63. spin_lock_irqsave(&priv->lock, flags);
  64. val = ds1286_rtc_read(priv, RTC_CMD);
  65. val &= ~RTC_WAM;
  66. ds1286_rtc_write(priv, val, RTC_CMD);
  67. spin_unlock_irqrestore(&priv->lock, flags);
  68. break;
  69. default:
  70. return -ENOIOCTLCMD;
  71. }
  72. return 0;
  73. }
  74. #else
  75. #define ds1286_ioctl NULL
  76. #endif
  77. #ifdef CONFIG_PROC_FS
  78. static int ds1286_proc(struct device *dev, struct seq_file *seq)
  79. {
  80. struct ds1286_priv *priv = dev_get_drvdata(dev);
  81. unsigned char month, cmd, amode;
  82. const char *s;
  83. month = ds1286_rtc_read(priv, RTC_MONTH);
  84. seq_printf(seq,
  85. "oscillator\t: %s\n"
  86. "square_wave\t: %s\n",
  87. (month & RTC_EOSC) ? "disabled" : "enabled",
  88. (month & RTC_ESQW) ? "disabled" : "enabled");
  89. amode = ((ds1286_rtc_read(priv, RTC_MINUTES_ALARM) & 0x80) >> 5) |
  90. ((ds1286_rtc_read(priv, RTC_HOURS_ALARM) & 0x80) >> 6) |
  91. ((ds1286_rtc_read(priv, RTC_DAY_ALARM) & 0x80) >> 7);
  92. switch (amode) {
  93. case 7:
  94. s = "each minute";
  95. break;
  96. case 3:
  97. s = "minutes match";
  98. break;
  99. case 1:
  100. s = "hours and minutes match";
  101. break;
  102. case 0:
  103. s = "days, hours and minutes match";
  104. break;
  105. default:
  106. s = "invalid";
  107. break;
  108. }
  109. seq_printf(seq, "alarm_mode\t: %s\n", s);
  110. cmd = ds1286_rtc_read(priv, RTC_CMD);
  111. seq_printf(seq,
  112. "alarm_enable\t: %s\n"
  113. "wdog_alarm\t: %s\n"
  114. "alarm_mask\t: %s\n"
  115. "wdog_alarm_mask\t: %s\n"
  116. "interrupt_mode\t: %s\n"
  117. "INTB_mode\t: %s_active\n"
  118. "interrupt_pins\t: %s\n",
  119. (cmd & RTC_TDF) ? "yes" : "no",
  120. (cmd & RTC_WAF) ? "yes" : "no",
  121. (cmd & RTC_TDM) ? "disabled" : "enabled",
  122. (cmd & RTC_WAM) ? "disabled" : "enabled",
  123. (cmd & RTC_PU_LVL) ? "pulse" : "level",
  124. (cmd & RTC_IBH_LO) ? "low" : "high",
  125. (cmd & RTC_IPSW) ? "unswapped" : "swapped");
  126. return 0;
  127. }
  128. #else
  129. #define ds1286_proc NULL
  130. #endif
  131. static int ds1286_read_time(struct device *dev, struct rtc_time *tm)
  132. {
  133. struct ds1286_priv *priv = dev_get_drvdata(dev);
  134. unsigned char save_control;
  135. unsigned long flags;
  136. unsigned long uip_watchdog = jiffies;
  137. /*
  138. * read RTC once any update in progress is done. The update
  139. * can take just over 2ms. We wait 10 to 20ms. There is no need to
  140. * to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP.
  141. * If you need to know *exactly* when a second has started, enable
  142. * periodic update complete interrupts, (via ioctl) and then
  143. * immediately read /dev/rtc which will block until you get the IRQ.
  144. * Once the read clears, read the RTC time (again via ioctl). Easy.
  145. */
  146. if (ds1286_rtc_read(priv, RTC_CMD) & RTC_TE)
  147. while (time_before(jiffies, uip_watchdog + 2*HZ/100))
  148. barrier();
  149. /*
  150. * Only the values that we read from the RTC are set. We leave
  151. * tm_wday, tm_yday and tm_isdst untouched. Even though the
  152. * RTC has RTC_DAY_OF_WEEK, we ignore it, as it is only updated
  153. * by the RTC when initially set to a non-zero value.
  154. */
  155. spin_lock_irqsave(&priv->lock, flags);
  156. save_control = ds1286_rtc_read(priv, RTC_CMD);
  157. ds1286_rtc_write(priv, (save_control|RTC_TE), RTC_CMD);
  158. tm->tm_sec = ds1286_rtc_read(priv, RTC_SECONDS);
  159. tm->tm_min = ds1286_rtc_read(priv, RTC_MINUTES);
  160. tm->tm_hour = ds1286_rtc_read(priv, RTC_HOURS) & 0x3f;
  161. tm->tm_mday = ds1286_rtc_read(priv, RTC_DATE);
  162. tm->tm_mon = ds1286_rtc_read(priv, RTC_MONTH) & 0x1f;
  163. tm->tm_year = ds1286_rtc_read(priv, RTC_YEAR);
  164. ds1286_rtc_write(priv, save_control, RTC_CMD);
  165. spin_unlock_irqrestore(&priv->lock, flags);
  166. tm->tm_sec = bcd2bin(tm->tm_sec);
  167. tm->tm_min = bcd2bin(tm->tm_min);
  168. tm->tm_hour = bcd2bin(tm->tm_hour);
  169. tm->tm_mday = bcd2bin(tm->tm_mday);
  170. tm->tm_mon = bcd2bin(tm->tm_mon);
  171. tm->tm_year = bcd2bin(tm->tm_year);
  172. /*
  173. * Account for differences between how the RTC uses the values
  174. * and how they are defined in a struct rtc_time;
  175. */
  176. if (tm->tm_year < 45)
  177. tm->tm_year += 30;
  178. tm->tm_year += 40;
  179. if (tm->tm_year < 70)
  180. tm->tm_year += 100;
  181. tm->tm_mon--;
  182. return 0;
  183. }
  184. static int ds1286_set_time(struct device *dev, struct rtc_time *tm)
  185. {
  186. struct ds1286_priv *priv = dev_get_drvdata(dev);
  187. unsigned char mon, day, hrs, min, sec;
  188. unsigned char save_control;
  189. unsigned int yrs;
  190. unsigned long flags;
  191. yrs = tm->tm_year + 1900;
  192. mon = tm->tm_mon + 1; /* tm_mon starts at zero */
  193. day = tm->tm_mday;
  194. hrs = tm->tm_hour;
  195. min = tm->tm_min;
  196. sec = tm->tm_sec;
  197. if (yrs < 1970)
  198. return -EINVAL;
  199. yrs -= 1940;
  200. if (yrs > 255) /* They are unsigned */
  201. return -EINVAL;
  202. if (yrs >= 100)
  203. yrs -= 100;
  204. sec = bin2bcd(sec);
  205. min = bin2bcd(min);
  206. hrs = bin2bcd(hrs);
  207. day = bin2bcd(day);
  208. mon = bin2bcd(mon);
  209. yrs = bin2bcd(yrs);
  210. spin_lock_irqsave(&priv->lock, flags);
  211. save_control = ds1286_rtc_read(priv, RTC_CMD);
  212. ds1286_rtc_write(priv, (save_control|RTC_TE), RTC_CMD);
  213. ds1286_rtc_write(priv, yrs, RTC_YEAR);
  214. ds1286_rtc_write(priv, mon, RTC_MONTH);
  215. ds1286_rtc_write(priv, day, RTC_DATE);
  216. ds1286_rtc_write(priv, hrs, RTC_HOURS);
  217. ds1286_rtc_write(priv, min, RTC_MINUTES);
  218. ds1286_rtc_write(priv, sec, RTC_SECONDS);
  219. ds1286_rtc_write(priv, 0, RTC_HUNDREDTH_SECOND);
  220. ds1286_rtc_write(priv, save_control, RTC_CMD);
  221. spin_unlock_irqrestore(&priv->lock, flags);
  222. return 0;
  223. }
  224. static int ds1286_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
  225. {
  226. struct ds1286_priv *priv = dev_get_drvdata(dev);
  227. unsigned long flags;
  228. /*
  229. * Only the values that we read from the RTC are set. That
  230. * means only tm_wday, tm_hour, tm_min.
  231. */
  232. spin_lock_irqsave(&priv->lock, flags);
  233. alm->time.tm_min = ds1286_rtc_read(priv, RTC_MINUTES_ALARM) & 0x7f;
  234. alm->time.tm_hour = ds1286_rtc_read(priv, RTC_HOURS_ALARM) & 0x1f;
  235. alm->time.tm_wday = ds1286_rtc_read(priv, RTC_DAY_ALARM) & 0x07;
  236. ds1286_rtc_read(priv, RTC_CMD);
  237. spin_unlock_irqrestore(&priv->lock, flags);
  238. alm->time.tm_min = bcd2bin(alm->time.tm_min);
  239. alm->time.tm_hour = bcd2bin(alm->time.tm_hour);
  240. alm->time.tm_sec = 0;
  241. return 0;
  242. }
  243. static int ds1286_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
  244. {
  245. struct ds1286_priv *priv = dev_get_drvdata(dev);
  246. unsigned char hrs, min, sec;
  247. hrs = alm->time.tm_hour;
  248. min = alm->time.tm_min;
  249. sec = alm->time.tm_sec;
  250. if (hrs >= 24)
  251. hrs = 0xff;
  252. if (min >= 60)
  253. min = 0xff;
  254. if (sec != 0)
  255. return -EINVAL;
  256. min = bin2bcd(min);
  257. hrs = bin2bcd(hrs);
  258. spin_lock(&priv->lock);
  259. ds1286_rtc_write(priv, hrs, RTC_HOURS_ALARM);
  260. ds1286_rtc_write(priv, min, RTC_MINUTES_ALARM);
  261. spin_unlock(&priv->lock);
  262. return 0;
  263. }
  264. static const struct rtc_class_ops ds1286_ops = {
  265. .ioctl = ds1286_ioctl,
  266. .proc = ds1286_proc,
  267. .read_time = ds1286_read_time,
  268. .set_time = ds1286_set_time,
  269. .read_alarm = ds1286_read_alarm,
  270. .set_alarm = ds1286_set_alarm,
  271. .alarm_irq_enable = ds1286_alarm_irq_enable,
  272. };
  273. static int ds1286_probe(struct platform_device *pdev)
  274. {
  275. struct rtc_device *rtc;
  276. struct ds1286_priv *priv;
  277. priv = devm_kzalloc(&pdev->dev, sizeof(struct ds1286_priv), GFP_KERNEL);
  278. if (!priv)
  279. return -ENOMEM;
  280. priv->rtcregs = devm_platform_ioremap_resource(pdev, 0);
  281. if (IS_ERR(priv->rtcregs))
  282. return PTR_ERR(priv->rtcregs);
  283. spin_lock_init(&priv->lock);
  284. platform_set_drvdata(pdev, priv);
  285. rtc = devm_rtc_device_register(&pdev->dev, "ds1286", &ds1286_ops,
  286. THIS_MODULE);
  287. if (IS_ERR(rtc))
  288. return PTR_ERR(rtc);
  289. priv->rtc = rtc;
  290. return 0;
  291. }
  292. static struct platform_driver ds1286_platform_driver = {
  293. .driver = {
  294. .name = "rtc-ds1286",
  295. },
  296. .probe = ds1286_probe,
  297. };
  298. module_platform_driver(ds1286_platform_driver);
  299. MODULE_AUTHOR("Thomas Bogendoerfer <tsbogend@alpha.franken.de>");
  300. MODULE_DESCRIPTION("DS1286 RTC driver");
  301. MODULE_LICENSE("GPL");
  302. MODULE_ALIAS("platform:rtc-ds1286");