rtc-bq4802.c 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /* rtc-bq4802.c: TI BQ4802 RTC driver.
  3. *
  4. * Copyright (C) 2008 David S. Miller <davem@davemloft.net>
  5. */
  6. #include <linux/kernel.h>
  7. #include <linux/module.h>
  8. #include <linux/init.h>
  9. #include <linux/io.h>
  10. #include <linux/platform_device.h>
  11. #include <linux/rtc.h>
  12. #include <linux/bcd.h>
  13. #include <linux/slab.h>
  14. MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
  15. MODULE_DESCRIPTION("TI BQ4802 RTC driver");
  16. MODULE_LICENSE("GPL");
  17. struct bq4802 {
  18. void __iomem *regs;
  19. unsigned long ioport;
  20. struct rtc_device *rtc;
  21. spinlock_t lock;
  22. struct resource *r;
  23. u8 (*read)(struct bq4802 *, int);
  24. void (*write)(struct bq4802 *, int, u8);
  25. };
  26. static u8 bq4802_read_io(struct bq4802 *p, int off)
  27. {
  28. return inb(p->ioport + off);
  29. }
  30. static void bq4802_write_io(struct bq4802 *p, int off, u8 val)
  31. {
  32. outb(val, p->ioport + off);
  33. }
  34. static u8 bq4802_read_mem(struct bq4802 *p, int off)
  35. {
  36. return readb(p->regs + off);
  37. }
  38. static void bq4802_write_mem(struct bq4802 *p, int off, u8 val)
  39. {
  40. writeb(val, p->regs + off);
  41. }
  42. static int bq4802_read_time(struct device *dev, struct rtc_time *tm)
  43. {
  44. struct bq4802 *p = dev_get_drvdata(dev);
  45. unsigned long flags;
  46. unsigned int century;
  47. u8 val;
  48. spin_lock_irqsave(&p->lock, flags);
  49. val = p->read(p, 0x0e);
  50. p->write(p, 0xe, val | 0x08);
  51. tm->tm_sec = p->read(p, 0x00);
  52. tm->tm_min = p->read(p, 0x02);
  53. tm->tm_hour = p->read(p, 0x04);
  54. tm->tm_mday = p->read(p, 0x06);
  55. tm->tm_mon = p->read(p, 0x09);
  56. tm->tm_year = p->read(p, 0x0a);
  57. tm->tm_wday = p->read(p, 0x08);
  58. century = p->read(p, 0x0f);
  59. p->write(p, 0x0e, val);
  60. spin_unlock_irqrestore(&p->lock, flags);
  61. tm->tm_sec = bcd2bin(tm->tm_sec);
  62. tm->tm_min = bcd2bin(tm->tm_min);
  63. tm->tm_hour = bcd2bin(tm->tm_hour);
  64. tm->tm_mday = bcd2bin(tm->tm_mday);
  65. tm->tm_mon = bcd2bin(tm->tm_mon);
  66. tm->tm_year = bcd2bin(tm->tm_year);
  67. tm->tm_wday = bcd2bin(tm->tm_wday);
  68. century = bcd2bin(century);
  69. tm->tm_year += (century * 100);
  70. tm->tm_year -= 1900;
  71. tm->tm_mon--;
  72. return 0;
  73. }
  74. static int bq4802_set_time(struct device *dev, struct rtc_time *tm)
  75. {
  76. struct bq4802 *p = dev_get_drvdata(dev);
  77. u8 sec, min, hrs, day, mon, yrs, century, val;
  78. unsigned long flags;
  79. unsigned int year;
  80. year = tm->tm_year + 1900;
  81. century = year / 100;
  82. yrs = year % 100;
  83. mon = tm->tm_mon + 1; /* tm_mon starts at zero */
  84. day = tm->tm_mday;
  85. hrs = tm->tm_hour;
  86. min = tm->tm_min;
  87. sec = tm->tm_sec;
  88. sec = bin2bcd(sec);
  89. min = bin2bcd(min);
  90. hrs = bin2bcd(hrs);
  91. day = bin2bcd(day);
  92. mon = bin2bcd(mon);
  93. yrs = bin2bcd(yrs);
  94. century = bin2bcd(century);
  95. spin_lock_irqsave(&p->lock, flags);
  96. val = p->read(p, 0x0e);
  97. p->write(p, 0x0e, val | 0x08);
  98. p->write(p, 0x00, sec);
  99. p->write(p, 0x02, min);
  100. p->write(p, 0x04, hrs);
  101. p->write(p, 0x06, day);
  102. p->write(p, 0x09, mon);
  103. p->write(p, 0x0a, yrs);
  104. p->write(p, 0x0f, century);
  105. p->write(p, 0x0e, val);
  106. spin_unlock_irqrestore(&p->lock, flags);
  107. return 0;
  108. }
  109. static const struct rtc_class_ops bq4802_ops = {
  110. .read_time = bq4802_read_time,
  111. .set_time = bq4802_set_time,
  112. };
  113. static int bq4802_probe(struct platform_device *pdev)
  114. {
  115. struct bq4802 *p = devm_kzalloc(&pdev->dev, sizeof(*p), GFP_KERNEL);
  116. int err = -ENOMEM;
  117. if (!p)
  118. goto out;
  119. spin_lock_init(&p->lock);
  120. p->r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  121. if (!p->r) {
  122. p->r = platform_get_resource(pdev, IORESOURCE_IO, 0);
  123. err = -EINVAL;
  124. if (!p->r)
  125. goto out;
  126. }
  127. if (p->r->flags & IORESOURCE_IO) {
  128. p->ioport = p->r->start;
  129. p->read = bq4802_read_io;
  130. p->write = bq4802_write_io;
  131. } else if (p->r->flags & IORESOURCE_MEM) {
  132. p->regs = devm_ioremap(&pdev->dev, p->r->start,
  133. resource_size(p->r));
  134. if (!p->regs){
  135. err = -ENOMEM;
  136. goto out;
  137. }
  138. p->read = bq4802_read_mem;
  139. p->write = bq4802_write_mem;
  140. } else {
  141. err = -EINVAL;
  142. goto out;
  143. }
  144. platform_set_drvdata(pdev, p);
  145. p->rtc = devm_rtc_device_register(&pdev->dev, "bq4802",
  146. &bq4802_ops, THIS_MODULE);
  147. if (IS_ERR(p->rtc)) {
  148. err = PTR_ERR(p->rtc);
  149. goto out;
  150. }
  151. err = 0;
  152. out:
  153. return err;
  154. }
  155. /* work with hotplug and coldplug */
  156. MODULE_ALIAS("platform:rtc-bq4802");
  157. static struct platform_driver bq4802_driver = {
  158. .driver = {
  159. .name = "rtc-bq4802",
  160. },
  161. .probe = bq4802_probe,
  162. };
  163. module_platform_driver(bq4802_driver);