rtc-ds1742.c 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274
  1. /*
  2. * An rtc driver for the Dallas DS1742
  3. *
  4. * Copyright (C) 2006 Atsushi Nemoto <anemo@mba.ocn.ne.jp>
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License version 2 as
  8. * published by the Free Software Foundation.
  9. *
  10. * Copyright (C) 2006 Torsten Ertbjerg Rasmussen <tr@newtec.dk>
  11. * - nvram size determined from resource
  12. * - this ds1742 driver now supports ds1743.
  13. */
  14. #include <linux/bcd.h>
  15. #include <linux/init.h>
  16. #include <linux/kernel.h>
  17. #include <linux/delay.h>
  18. #include <linux/jiffies.h>
  19. #include <linux/rtc.h>
  20. #include <linux/platform_device.h>
  21. #include <linux/io.h>
  22. #define DRV_VERSION "0.3"
  23. #define RTC_SIZE 8
  24. #define RTC_CONTROL 0
  25. #define RTC_CENTURY 0
  26. #define RTC_SECONDS 1
  27. #define RTC_MINUTES 2
  28. #define RTC_HOURS 3
  29. #define RTC_DAY 4
  30. #define RTC_DATE 5
  31. #define RTC_MONTH 6
  32. #define RTC_YEAR 7
  33. #define RTC_CENTURY_MASK 0x3f
  34. #define RTC_SECONDS_MASK 0x7f
  35. #define RTC_DAY_MASK 0x07
  36. /* Bits in the Control/Century register */
  37. #define RTC_WRITE 0x80
  38. #define RTC_READ 0x40
  39. /* Bits in the Seconds register */
  40. #define RTC_STOP 0x80
  41. /* Bits in the Day register */
  42. #define RTC_BATT_FLAG 0x80
  43. struct rtc_plat_data {
  44. struct rtc_device *rtc;
  45. void __iomem *ioaddr_nvram;
  46. void __iomem *ioaddr_rtc;
  47. size_t size_nvram;
  48. size_t size;
  49. unsigned long baseaddr;
  50. unsigned long last_jiffies;
  51. };
  52. static int ds1742_rtc_set_time(struct device *dev, struct rtc_time *tm)
  53. {
  54. struct platform_device *pdev = to_platform_device(dev);
  55. struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
  56. void __iomem *ioaddr = pdata->ioaddr_rtc;
  57. u8 century;
  58. century = BIN2BCD((tm->tm_year + 1900) / 100);
  59. writeb(RTC_WRITE, ioaddr + RTC_CONTROL);
  60. writeb(BIN2BCD(tm->tm_year % 100), ioaddr + RTC_YEAR);
  61. writeb(BIN2BCD(tm->tm_mon + 1), ioaddr + RTC_MONTH);
  62. writeb(BIN2BCD(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
  63. writeb(BIN2BCD(tm->tm_mday), ioaddr + RTC_DATE);
  64. writeb(BIN2BCD(tm->tm_hour), ioaddr + RTC_HOURS);
  65. writeb(BIN2BCD(tm->tm_min), ioaddr + RTC_MINUTES);
  66. writeb(BIN2BCD(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
  67. /* RTC_CENTURY and RTC_CONTROL share same register */
  68. writeb(RTC_WRITE | (century & RTC_CENTURY_MASK), ioaddr + RTC_CENTURY);
  69. writeb(century & RTC_CENTURY_MASK, ioaddr + RTC_CONTROL);
  70. return 0;
  71. }
  72. static int ds1742_rtc_read_time(struct device *dev, struct rtc_time *tm)
  73. {
  74. struct platform_device *pdev = to_platform_device(dev);
  75. struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
  76. void __iomem *ioaddr = pdata->ioaddr_rtc;
  77. unsigned int year, month, day, hour, minute, second, week;
  78. unsigned int century;
  79. /* give enough time to update RTC in case of continuous read */
  80. if (pdata->last_jiffies == jiffies)
  81. msleep(1);
  82. pdata->last_jiffies = jiffies;
  83. writeb(RTC_READ, ioaddr + RTC_CONTROL);
  84. second = readb(ioaddr + RTC_SECONDS) & RTC_SECONDS_MASK;
  85. minute = readb(ioaddr + RTC_MINUTES);
  86. hour = readb(ioaddr + RTC_HOURS);
  87. day = readb(ioaddr + RTC_DATE);
  88. week = readb(ioaddr + RTC_DAY) & RTC_DAY_MASK;
  89. month = readb(ioaddr + RTC_MONTH);
  90. year = readb(ioaddr + RTC_YEAR);
  91. century = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK;
  92. writeb(0, ioaddr + RTC_CONTROL);
  93. tm->tm_sec = BCD2BIN(second);
  94. tm->tm_min = BCD2BIN(minute);
  95. tm->tm_hour = BCD2BIN(hour);
  96. tm->tm_mday = BCD2BIN(day);
  97. tm->tm_wday = BCD2BIN(week);
  98. tm->tm_mon = BCD2BIN(month) - 1;
  99. /* year is 1900 + tm->tm_year */
  100. tm->tm_year = BCD2BIN(year) + BCD2BIN(century) * 100 - 1900;
  101. if (rtc_valid_tm(tm) < 0) {
  102. dev_err(dev, "retrieved date/time is not valid.\n");
  103. rtc_time_to_tm(0, tm);
  104. }
  105. return 0;
  106. }
  107. static const struct rtc_class_ops ds1742_rtc_ops = {
  108. .read_time = ds1742_rtc_read_time,
  109. .set_time = ds1742_rtc_set_time,
  110. };
  111. static ssize_t ds1742_nvram_read(struct kobject *kobj, char *buf,
  112. loff_t pos, size_t size)
  113. {
  114. struct platform_device *pdev =
  115. to_platform_device(container_of(kobj, struct device, kobj));
  116. struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
  117. void __iomem *ioaddr = pdata->ioaddr_nvram;
  118. ssize_t count;
  119. for (count = 0; size > 0 && pos < pdata->size_nvram; count++, size--)
  120. *buf++ = readb(ioaddr + pos++);
  121. return count;
  122. }
  123. static ssize_t ds1742_nvram_write(struct kobject *kobj, char *buf,
  124. loff_t pos, size_t size)
  125. {
  126. struct platform_device *pdev =
  127. to_platform_device(container_of(kobj, struct device, kobj));
  128. struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
  129. void __iomem *ioaddr = pdata->ioaddr_nvram;
  130. ssize_t count;
  131. for (count = 0; size > 0 && pos < pdata->size_nvram; count++, size--)
  132. writeb(*buf++, ioaddr + pos++);
  133. return count;
  134. }
  135. static struct bin_attribute ds1742_nvram_attr = {
  136. .attr = {
  137. .name = "nvram",
  138. .mode = S_IRUGO | S_IWUGO,
  139. .owner = THIS_MODULE,
  140. },
  141. .read = ds1742_nvram_read,
  142. .write = ds1742_nvram_write,
  143. };
  144. static int __devinit ds1742_rtc_probe(struct platform_device *pdev)
  145. {
  146. struct rtc_device *rtc;
  147. struct resource *res;
  148. unsigned int cen, sec;
  149. struct rtc_plat_data *pdata = NULL;
  150. void __iomem *ioaddr = NULL;
  151. int ret = 0;
  152. res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  153. if (!res)
  154. return -ENODEV;
  155. pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
  156. if (!pdata)
  157. return -ENOMEM;
  158. pdata->size = res->end - res->start + 1;
  159. if (!request_mem_region(res->start, pdata->size, pdev->name)) {
  160. ret = -EBUSY;
  161. goto out;
  162. }
  163. pdata->baseaddr = res->start;
  164. ioaddr = ioremap(pdata->baseaddr, pdata->size);
  165. if (!ioaddr) {
  166. ret = -ENOMEM;
  167. goto out;
  168. }
  169. pdata->ioaddr_nvram = ioaddr;
  170. pdata->size_nvram = pdata->size - RTC_SIZE;
  171. pdata->ioaddr_rtc = ioaddr + pdata->size_nvram;
  172. /* turn RTC on if it was not on */
  173. ioaddr = pdata->ioaddr_rtc;
  174. sec = readb(ioaddr + RTC_SECONDS);
  175. if (sec & RTC_STOP) {
  176. sec &= RTC_SECONDS_MASK;
  177. cen = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK;
  178. writeb(RTC_WRITE, ioaddr + RTC_CONTROL);
  179. writeb(sec, ioaddr + RTC_SECONDS);
  180. writeb(cen & RTC_CENTURY_MASK, ioaddr + RTC_CONTROL);
  181. }
  182. if (!(readb(ioaddr + RTC_DAY) & RTC_BATT_FLAG))
  183. dev_warn(&pdev->dev, "voltage-low detected.\n");
  184. rtc = rtc_device_register(pdev->name, &pdev->dev,
  185. &ds1742_rtc_ops, THIS_MODULE);
  186. if (IS_ERR(rtc)) {
  187. ret = PTR_ERR(rtc);
  188. goto out;
  189. }
  190. pdata->rtc = rtc;
  191. pdata->last_jiffies = jiffies;
  192. platform_set_drvdata(pdev, pdata);
  193. ds1742_nvram_attr.size = max(ds1742_nvram_attr.size,
  194. pdata->size_nvram);
  195. ret = sysfs_create_bin_file(&pdev->dev.kobj, &ds1742_nvram_attr);
  196. if (ret)
  197. goto out;
  198. return 0;
  199. out:
  200. if (pdata->rtc)
  201. rtc_device_unregister(pdata->rtc);
  202. if (pdata->ioaddr_nvram)
  203. iounmap(pdata->ioaddr_nvram);
  204. if (pdata->baseaddr)
  205. release_mem_region(pdata->baseaddr, pdata->size);
  206. kfree(pdata);
  207. return ret;
  208. }
  209. static int __devexit ds1742_rtc_remove(struct platform_device *pdev)
  210. {
  211. struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
  212. sysfs_remove_bin_file(&pdev->dev.kobj, &ds1742_nvram_attr);
  213. rtc_device_unregister(pdata->rtc);
  214. iounmap(pdata->ioaddr_nvram);
  215. release_mem_region(pdata->baseaddr, pdata->size);
  216. kfree(pdata);
  217. return 0;
  218. }
  219. static struct platform_driver ds1742_rtc_driver = {
  220. .probe = ds1742_rtc_probe,
  221. .remove = __devexit_p(ds1742_rtc_remove),
  222. .driver = {
  223. .name = "ds1742",
  224. .owner = THIS_MODULE,
  225. },
  226. };
  227. static __init int ds1742_init(void)
  228. {
  229. return platform_driver_register(&ds1742_rtc_driver);
  230. }
  231. static __exit void ds1742_exit(void)
  232. {
  233. return platform_driver_unregister(&ds1742_rtc_driver);
  234. }
  235. module_init(ds1742_init);
  236. module_exit(ds1742_exit);
  237. MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
  238. MODULE_DESCRIPTION("Dallas DS1742 RTC driver");
  239. MODULE_LICENSE("GPL");
  240. MODULE_VERSION(DRV_VERSION);