reset-simple.c 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Simple Reset Controller Driver
  4. *
  5. * Copyright (C) 2017 Pengutronix, Philipp Zabel <kernel@pengutronix.de>
  6. *
  7. * Based on Allwinner SoCs Reset Controller driver
  8. *
  9. * Copyright 2013 Maxime Ripard
  10. *
  11. * Maxime Ripard <maxime.ripard@free-electrons.com>
  12. */
  13. #include <linux/delay.h>
  14. #include <linux/device.h>
  15. #include <linux/err.h>
  16. #include <linux/io.h>
  17. #include <linux/of.h>
  18. #include <linux/of_device.h>
  19. #include <linux/platform_device.h>
  20. #include <linux/reset-controller.h>
  21. #include <linux/reset/reset-simple.h>
  22. #include <linux/spinlock.h>
  23. static inline struct reset_simple_data *
  24. to_reset_simple_data(struct reset_controller_dev *rcdev)
  25. {
  26. return container_of(rcdev, struct reset_simple_data, rcdev);
  27. }
  28. static int reset_simple_update(struct reset_controller_dev *rcdev,
  29. unsigned long id, bool assert)
  30. {
  31. struct reset_simple_data *data = to_reset_simple_data(rcdev);
  32. int reg_width = sizeof(u32);
  33. int bank = id / (reg_width * BITS_PER_BYTE);
  34. int offset = id % (reg_width * BITS_PER_BYTE);
  35. unsigned long flags;
  36. u32 reg;
  37. spin_lock_irqsave(&data->lock, flags);
  38. reg = readl(data->membase + (bank * reg_width));
  39. if (assert ^ data->active_low)
  40. reg |= BIT(offset);
  41. else
  42. reg &= ~BIT(offset);
  43. writel(reg, data->membase + (bank * reg_width));
  44. spin_unlock_irqrestore(&data->lock, flags);
  45. return 0;
  46. }
  47. static int reset_simple_assert(struct reset_controller_dev *rcdev,
  48. unsigned long id)
  49. {
  50. return reset_simple_update(rcdev, id, true);
  51. }
  52. static int reset_simple_deassert(struct reset_controller_dev *rcdev,
  53. unsigned long id)
  54. {
  55. return reset_simple_update(rcdev, id, false);
  56. }
  57. static int reset_simple_reset(struct reset_controller_dev *rcdev,
  58. unsigned long id)
  59. {
  60. struct reset_simple_data *data = to_reset_simple_data(rcdev);
  61. int ret;
  62. if (!data->reset_us)
  63. return -ENOTSUPP;
  64. ret = reset_simple_assert(rcdev, id);
  65. if (ret)
  66. return ret;
  67. usleep_range(data->reset_us, data->reset_us * 2);
  68. return reset_simple_deassert(rcdev, id);
  69. }
  70. static int reset_simple_status(struct reset_controller_dev *rcdev,
  71. unsigned long id)
  72. {
  73. struct reset_simple_data *data = to_reset_simple_data(rcdev);
  74. int reg_width = sizeof(u32);
  75. int bank = id / (reg_width * BITS_PER_BYTE);
  76. int offset = id % (reg_width * BITS_PER_BYTE);
  77. u32 reg;
  78. reg = readl(data->membase + (bank * reg_width));
  79. return !(reg & BIT(offset)) ^ !data->status_active_low;
  80. }
  81. const struct reset_control_ops reset_simple_ops = {
  82. .assert = reset_simple_assert,
  83. .deassert = reset_simple_deassert,
  84. .reset = reset_simple_reset,
  85. .status = reset_simple_status,
  86. };
  87. EXPORT_SYMBOL_GPL(reset_simple_ops);
  88. /**
  89. * struct reset_simple_devdata - simple reset controller properties
  90. * @reg_offset: offset between base address and first reset register.
  91. * @nr_resets: number of resets. If not set, default to resource size in bits.
  92. * @active_low: if true, bits are cleared to assert the reset. Otherwise, bits
  93. * are set to assert the reset.
  94. * @status_active_low: if true, bits read back as cleared while the reset is
  95. * asserted. Otherwise, bits read back as set while the
  96. * reset is asserted.
  97. */
  98. struct reset_simple_devdata {
  99. u32 reg_offset;
  100. u32 nr_resets;
  101. bool active_low;
  102. bool status_active_low;
  103. };
  104. #define SOCFPGA_NR_BANKS 8
  105. static const struct reset_simple_devdata reset_simple_socfpga = {
  106. .reg_offset = 0x20,
  107. .nr_resets = SOCFPGA_NR_BANKS * 32,
  108. .status_active_low = true,
  109. };
  110. static const struct reset_simple_devdata reset_simple_active_low = {
  111. .active_low = true,
  112. .status_active_low = true,
  113. };
  114. static const struct of_device_id reset_simple_dt_ids[] = {
  115. { .compatible = "altr,stratix10-rst-mgr",
  116. .data = &reset_simple_socfpga },
  117. { .compatible = "st,stm32-rcc", },
  118. { .compatible = "allwinner,sun6i-a31-clock-reset",
  119. .data = &reset_simple_active_low },
  120. { .compatible = "zte,zx296718-reset",
  121. .data = &reset_simple_active_low },
  122. { .compatible = "aspeed,ast2400-lpc-reset" },
  123. { .compatible = "aspeed,ast2500-lpc-reset" },
  124. { .compatible = "bitmain,bm1880-reset",
  125. .data = &reset_simple_active_low },
  126. { .compatible = "snps,dw-high-reset" },
  127. { .compatible = "snps,dw-low-reset",
  128. .data = &reset_simple_active_low },
  129. { /* sentinel */ },
  130. };
  131. static int reset_simple_probe(struct platform_device *pdev)
  132. {
  133. struct device *dev = &pdev->dev;
  134. const struct reset_simple_devdata *devdata;
  135. struct reset_simple_data *data;
  136. void __iomem *membase;
  137. struct resource *res;
  138. u32 reg_offset = 0;
  139. devdata = of_device_get_match_data(dev);
  140. data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
  141. if (!data)
  142. return -ENOMEM;
  143. res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  144. membase = devm_ioremap_resource(dev, res);
  145. if (IS_ERR(membase))
  146. return PTR_ERR(membase);
  147. spin_lock_init(&data->lock);
  148. data->membase = membase;
  149. data->rcdev.owner = THIS_MODULE;
  150. data->rcdev.nr_resets = resource_size(res) * BITS_PER_BYTE;
  151. data->rcdev.ops = &reset_simple_ops;
  152. data->rcdev.of_node = dev->of_node;
  153. if (devdata) {
  154. reg_offset = devdata->reg_offset;
  155. if (devdata->nr_resets)
  156. data->rcdev.nr_resets = devdata->nr_resets;
  157. data->active_low = devdata->active_low;
  158. data->status_active_low = devdata->status_active_low;
  159. }
  160. data->membase += reg_offset;
  161. return devm_reset_controller_register(dev, &data->rcdev);
  162. }
  163. static struct platform_driver reset_simple_driver = {
  164. .probe = reset_simple_probe,
  165. .driver = {
  166. .name = "simple-reset",
  167. .of_match_table = reset_simple_dt_ids,
  168. },
  169. };
  170. builtin_platform_driver(reset_simple_driver);