spi-lp8841-rtc.c 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * SPI master driver for ICP DAS LP-8841 RTC
  4. *
  5. * Copyright (C) 2016 Sergei Ianovich
  6. *
  7. * based on
  8. *
  9. * Dallas DS1302 RTC Support
  10. * Copyright (C) 2002 David McCullough
  11. * Copyright (C) 2003 - 2007 Paul Mundt
  12. */
  13. #include <linux/delay.h>
  14. #include <linux/kernel.h>
  15. #include <linux/module.h>
  16. #include <linux/platform_device.h>
  17. #include <linux/of.h>
  18. #include <linux/of_device.h>
  19. #include <linux/spi/spi.h>
  20. #define DRIVER_NAME "spi_lp8841_rtc"
  21. #define SPI_LP8841_RTC_CE 0x01
  22. #define SPI_LP8841_RTC_CLK 0x02
  23. #define SPI_LP8841_RTC_nWE 0x04
  24. #define SPI_LP8841_RTC_MOSI 0x08
  25. #define SPI_LP8841_RTC_MISO 0x01
  26. /*
  27. * REVISIT If there is support for SPI_3WIRE and SPI_LSB_FIRST in SPI
  28. * GPIO driver, this SPI driver can be replaced by a simple GPIO driver
  29. * providing 3 GPIO pins.
  30. */
  31. struct spi_lp8841_rtc {
  32. void *iomem;
  33. unsigned long state;
  34. };
  35. static inline void
  36. setsck(struct spi_lp8841_rtc *data, int is_on)
  37. {
  38. if (is_on)
  39. data->state |= SPI_LP8841_RTC_CLK;
  40. else
  41. data->state &= ~SPI_LP8841_RTC_CLK;
  42. writeb(data->state, data->iomem);
  43. }
  44. static inline void
  45. setmosi(struct spi_lp8841_rtc *data, int is_on)
  46. {
  47. if (is_on)
  48. data->state |= SPI_LP8841_RTC_MOSI;
  49. else
  50. data->state &= ~SPI_LP8841_RTC_MOSI;
  51. writeb(data->state, data->iomem);
  52. }
  53. static inline int
  54. getmiso(struct spi_lp8841_rtc *data)
  55. {
  56. return ioread8(data->iomem) & SPI_LP8841_RTC_MISO;
  57. }
  58. static inline u32
  59. bitbang_txrx_be_cpha0_lsb(struct spi_lp8841_rtc *data,
  60. unsigned usecs, unsigned cpol, unsigned flags,
  61. u32 word, u8 bits)
  62. {
  63. /* if (cpol == 0) this is SPI_MODE_0; else this is SPI_MODE_2 */
  64. u32 shift = 32 - bits;
  65. /* clock starts at inactive polarity */
  66. for (; likely(bits); bits--) {
  67. /* setup LSB (to slave) on leading edge */
  68. if ((flags & SPI_MASTER_NO_TX) == 0)
  69. setmosi(data, (word & 1));
  70. usleep_range(usecs, usecs + 1); /* T(setup) */
  71. /* sample LSB (from slave) on trailing edge */
  72. word >>= 1;
  73. if ((flags & SPI_MASTER_NO_RX) == 0)
  74. word |= (getmiso(data) << 31);
  75. setsck(data, !cpol);
  76. usleep_range(usecs, usecs + 1);
  77. setsck(data, cpol);
  78. }
  79. word >>= shift;
  80. return word;
  81. }
  82. static int
  83. spi_lp8841_rtc_transfer_one(struct spi_master *master,
  84. struct spi_device *spi,
  85. struct spi_transfer *t)
  86. {
  87. struct spi_lp8841_rtc *data = spi_master_get_devdata(master);
  88. unsigned count = t->len;
  89. const u8 *tx = t->tx_buf;
  90. u8 *rx = t->rx_buf;
  91. u8 word = 0;
  92. int ret = 0;
  93. if (tx) {
  94. data->state &= ~SPI_LP8841_RTC_nWE;
  95. writeb(data->state, data->iomem);
  96. while (likely(count > 0)) {
  97. word = *tx++;
  98. bitbang_txrx_be_cpha0_lsb(data, 1, 0,
  99. SPI_MASTER_NO_RX, word, 8);
  100. count--;
  101. }
  102. } else if (rx) {
  103. data->state |= SPI_LP8841_RTC_nWE;
  104. writeb(data->state, data->iomem);
  105. while (likely(count > 0)) {
  106. word = bitbang_txrx_be_cpha0_lsb(data, 1, 0,
  107. SPI_MASTER_NO_TX, word, 8);
  108. *rx++ = word;
  109. count--;
  110. }
  111. } else {
  112. ret = -EINVAL;
  113. }
  114. spi_finalize_current_transfer(master);
  115. return ret;
  116. }
  117. static void
  118. spi_lp8841_rtc_set_cs(struct spi_device *spi, bool enable)
  119. {
  120. struct spi_lp8841_rtc *data = spi_master_get_devdata(spi->master);
  121. data->state = 0;
  122. writeb(data->state, data->iomem);
  123. if (enable) {
  124. usleep_range(4, 5);
  125. data->state |= SPI_LP8841_RTC_CE;
  126. writeb(data->state, data->iomem);
  127. usleep_range(4, 5);
  128. }
  129. }
  130. static int
  131. spi_lp8841_rtc_setup(struct spi_device *spi)
  132. {
  133. if ((spi->mode & SPI_CS_HIGH) == 0) {
  134. dev_err(&spi->dev, "unsupported active low chip select\n");
  135. return -EINVAL;
  136. }
  137. if ((spi->mode & SPI_LSB_FIRST) == 0) {
  138. dev_err(&spi->dev, "unsupported MSB first mode\n");
  139. return -EINVAL;
  140. }
  141. if ((spi->mode & SPI_3WIRE) == 0) {
  142. dev_err(&spi->dev, "unsupported wiring. 3 wires required\n");
  143. return -EINVAL;
  144. }
  145. return 0;
  146. }
  147. #ifdef CONFIG_OF
  148. static const struct of_device_id spi_lp8841_rtc_dt_ids[] = {
  149. { .compatible = "icpdas,lp8841-spi-rtc" },
  150. { }
  151. };
  152. MODULE_DEVICE_TABLE(of, spi_lp8841_rtc_dt_ids);
  153. #endif
  154. static int
  155. spi_lp8841_rtc_probe(struct platform_device *pdev)
  156. {
  157. int ret;
  158. struct spi_master *master;
  159. struct spi_lp8841_rtc *data;
  160. master = spi_alloc_master(&pdev->dev, sizeof(*data));
  161. if (!master)
  162. return -ENOMEM;
  163. platform_set_drvdata(pdev, master);
  164. master->flags = SPI_MASTER_HALF_DUPLEX;
  165. master->mode_bits = SPI_CS_HIGH | SPI_3WIRE | SPI_LSB_FIRST;
  166. master->bus_num = pdev->id;
  167. master->num_chipselect = 1;
  168. master->setup = spi_lp8841_rtc_setup;
  169. master->set_cs = spi_lp8841_rtc_set_cs;
  170. master->transfer_one = spi_lp8841_rtc_transfer_one;
  171. master->bits_per_word_mask = SPI_BPW_MASK(8);
  172. #ifdef CONFIG_OF
  173. master->dev.of_node = pdev->dev.of_node;
  174. #endif
  175. data = spi_master_get_devdata(master);
  176. data->iomem = devm_platform_ioremap_resource(pdev, 0);
  177. ret = PTR_ERR_OR_ZERO(data->iomem);
  178. if (ret) {
  179. dev_err(&pdev->dev, "failed to get IO address\n");
  180. goto err_put_master;
  181. }
  182. /* register with the SPI framework */
  183. ret = devm_spi_register_master(&pdev->dev, master);
  184. if (ret) {
  185. dev_err(&pdev->dev, "cannot register spi master\n");
  186. goto err_put_master;
  187. }
  188. return ret;
  189. err_put_master:
  190. spi_master_put(master);
  191. return ret;
  192. }
  193. MODULE_ALIAS("platform:" DRIVER_NAME);
  194. static struct platform_driver spi_lp8841_rtc_driver = {
  195. .driver = {
  196. .name = DRIVER_NAME,
  197. .of_match_table = of_match_ptr(spi_lp8841_rtc_dt_ids),
  198. },
  199. .probe = spi_lp8841_rtc_probe,
  200. };
  201. module_platform_driver(spi_lp8841_rtc_driver);
  202. MODULE_DESCRIPTION("SPI master driver for ICP DAS LP-8841 RTC");
  203. MODULE_AUTHOR("Sergei Ianovich");
  204. MODULE_LICENSE("GPL");