pinctrl-serval.c 5.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233
  1. // SPDX-License-Identifier: (GPL-2.0 OR MIT)
  2. /*
  3. * Microsemi SoCs pinctrl driver
  4. *
  5. * Author: <horatiu.vultur@microchip.com>
  6. * Copyright (c) 2019 Microsemi Corporation
  7. */
  8. #include <common.h>
  9. #include <config.h>
  10. #include <dm.h>
  11. #include <dm/device-internal.h>
  12. #include <dm/lists.h>
  13. #include <dm/pinctrl.h>
  14. #include <dm/root.h>
  15. #include <errno.h>
  16. #include <fdtdec.h>
  17. #include <linux/io.h>
  18. #include <asm/gpio.h>
  19. #include <asm/system.h>
  20. #include "mscc-common.h"
  21. enum {
  22. FUNC_NONE,
  23. FUNC_GPIO,
  24. FUNC_IRQ0,
  25. FUNC_IRQ1,
  26. FUNC_MIIM1,
  27. FUNC_PCI_WAKE,
  28. FUNC_PTP0,
  29. FUNC_PTP1,
  30. FUNC_PTP2,
  31. FUNC_PTP3,
  32. FUNC_PWM,
  33. FUNC_RECO_CLK0,
  34. FUNC_RECO_CLK1,
  35. FUNC_SFP0,
  36. FUNC_SFP1,
  37. FUNC_SFP2,
  38. FUNC_SFP3,
  39. FUNC_SFP4,
  40. FUNC_SFP5,
  41. FUNC_SFP6,
  42. FUNC_SFP7,
  43. FUNC_SFP8,
  44. FUNC_SFP9,
  45. FUNC_SFP10,
  46. FUNC_SIO,
  47. FUNC_SI,
  48. FUNC_TACHO,
  49. FUNC_TWI,
  50. FUNC_TWI_SCL_M,
  51. FUNC_UART,
  52. FUNC_UART2,
  53. FUNC_MD,
  54. FUNC_PTP1588,
  55. FUNC_MAX
  56. };
  57. static char * const serval_function_names[] = {
  58. [FUNC_NONE] = "none",
  59. [FUNC_GPIO] = "gpio",
  60. [FUNC_IRQ0] = "irq0",
  61. [FUNC_IRQ1] = "irq1",
  62. [FUNC_MIIM1] = "miim1",
  63. [FUNC_PCI_WAKE] = "pci_wake",
  64. [FUNC_PTP0] = "ptp0",
  65. [FUNC_PTP1] = "ptp1",
  66. [FUNC_PTP2] = "ptp2",
  67. [FUNC_PTP3] = "ptp3",
  68. [FUNC_PWM] = "pwm",
  69. [FUNC_RECO_CLK0] = "reco_clk0",
  70. [FUNC_RECO_CLK1] = "reco_clk1",
  71. [FUNC_SFP0] = "sfp0",
  72. [FUNC_SFP1] = "sfp1",
  73. [FUNC_SFP2] = "sfp2",
  74. [FUNC_SFP3] = "sfp3",
  75. [FUNC_SFP4] = "sfp4",
  76. [FUNC_SFP5] = "sfp5",
  77. [FUNC_SFP6] = "sfp6",
  78. [FUNC_SFP7] = "sfp7",
  79. [FUNC_SFP8] = "sfp8",
  80. [FUNC_SFP9] = "sfp9",
  81. [FUNC_SFP10] = "sfp10",
  82. [FUNC_SIO] = "sio",
  83. [FUNC_SI] = "si",
  84. [FUNC_TACHO] = "tacho",
  85. [FUNC_TWI] = "twi",
  86. [FUNC_TWI_SCL_M] = "twi_scl_m",
  87. [FUNC_UART] = "uart",
  88. [FUNC_UART2] = "uart2",
  89. [FUNC_MD] = "md",
  90. [FUNC_PTP1588] = "1588",
  91. };
  92. MSCC_P(0, SIO, NONE, NONE);
  93. MSCC_P(1, SIO, NONE, NONE);
  94. MSCC_P(2, SIO, NONE, NONE);
  95. MSCC_P(3, SIO, NONE, NONE);
  96. MSCC_P(4, TACHO, NONE, NONE);
  97. MSCC_P(5, PWM, NONE, NONE);
  98. MSCC_P(6, TWI, NONE, NONE);
  99. MSCC_P(7, TWI, NONE, NONE);
  100. MSCC_P(8, SI, NONE, NONE);
  101. MSCC_P(9, SI, MD, NONE);
  102. MSCC_P(10, SI, MD, NONE);
  103. MSCC_P(11, SFP0, MD, TWI_SCL_M);
  104. MSCC_P(12, SFP1, MD, TWI_SCL_M);
  105. MSCC_P(13, SFP2, UART2, TWI_SCL_M);
  106. MSCC_P(14, SFP3, UART2, TWI_SCL_M);
  107. MSCC_P(15, SFP4, PTP1588, TWI_SCL_M);
  108. MSCC_P(16, SFP5, PTP1588, TWI_SCL_M);
  109. MSCC_P(17, SFP6, PCI_WAKE, TWI_SCL_M);
  110. MSCC_P(18, SFP7, NONE, TWI_SCL_M);
  111. MSCC_P(19, SFP8, NONE, TWI_SCL_M);
  112. MSCC_P(20, SFP9, NONE, TWI_SCL_M);
  113. MSCC_P(21, SFP10, NONE, TWI_SCL_M);
  114. MSCC_P(22, NONE, NONE, NONE);
  115. MSCC_P(23, NONE, NONE, NONE);
  116. MSCC_P(24, NONE, NONE, NONE);
  117. MSCC_P(25, NONE, NONE, NONE);
  118. MSCC_P(26, UART, NONE, NONE);
  119. MSCC_P(27, UART, NONE, NONE);
  120. MSCC_P(28, IRQ0, NONE, NONE);
  121. MSCC_P(29, IRQ1, NONE, NONE);
  122. MSCC_P(30, PTP1588, NONE, NONE);
  123. MSCC_P(31, PTP1588, NONE, NONE);
  124. #define SERVAL_PIN(n) { \
  125. .name = "GPIO_"#n, \
  126. .drv_data = &mscc_pin_##n \
  127. }
  128. static const struct mscc_pin_data serval_pins[] = {
  129. SERVAL_PIN(0),
  130. SERVAL_PIN(1),
  131. SERVAL_PIN(2),
  132. SERVAL_PIN(3),
  133. SERVAL_PIN(4),
  134. SERVAL_PIN(5),
  135. SERVAL_PIN(6),
  136. SERVAL_PIN(7),
  137. SERVAL_PIN(8),
  138. SERVAL_PIN(9),
  139. SERVAL_PIN(10),
  140. SERVAL_PIN(11),
  141. SERVAL_PIN(12),
  142. SERVAL_PIN(13),
  143. SERVAL_PIN(14),
  144. SERVAL_PIN(15),
  145. SERVAL_PIN(16),
  146. SERVAL_PIN(17),
  147. SERVAL_PIN(18),
  148. SERVAL_PIN(19),
  149. SERVAL_PIN(20),
  150. SERVAL_PIN(21),
  151. SERVAL_PIN(22),
  152. SERVAL_PIN(23),
  153. SERVAL_PIN(24),
  154. SERVAL_PIN(25),
  155. SERVAL_PIN(26),
  156. SERVAL_PIN(27),
  157. SERVAL_PIN(28),
  158. SERVAL_PIN(29),
  159. SERVAL_PIN(30),
  160. SERVAL_PIN(31),
  161. };
  162. static const unsigned long serval_gpios[] = {
  163. [MSCC_GPIO_OUT_SET] = 0x00,
  164. [MSCC_GPIO_OUT_CLR] = 0x04,
  165. [MSCC_GPIO_OUT] = 0x08,
  166. [MSCC_GPIO_IN] = 0x0c,
  167. [MSCC_GPIO_OE] = 0x10,
  168. [MSCC_GPIO_INTR] = 0x14,
  169. [MSCC_GPIO_INTR_ENA] = 0x18,
  170. [MSCC_GPIO_INTR_IDENT] = 0x1c,
  171. [MSCC_GPIO_ALT0] = 0x20,
  172. [MSCC_GPIO_ALT1] = 0x24,
  173. };
  174. static int serval_gpio_probe(struct udevice *dev)
  175. {
  176. struct gpio_dev_priv *uc_priv;
  177. uc_priv = dev_get_uclass_priv(dev);
  178. uc_priv->bank_name = "serval-gpio";
  179. uc_priv->gpio_count = ARRAY_SIZE(serval_pins);
  180. return 0;
  181. }
  182. static struct driver serval_gpio_driver = {
  183. .name = "serval-gpio",
  184. .id = UCLASS_GPIO,
  185. .probe = serval_gpio_probe,
  186. .ops = &mscc_gpio_ops,
  187. };
  188. static int serval_pinctrl_probe(struct udevice *dev)
  189. {
  190. int ret;
  191. ret = mscc_pinctrl_probe(dev, FUNC_MAX, serval_pins,
  192. ARRAY_SIZE(serval_pins),
  193. serval_function_names,
  194. serval_gpios);
  195. if (ret)
  196. return ret;
  197. ret = device_bind(dev, &serval_gpio_driver, "serval-gpio", NULL,
  198. dev_of_offset(dev), NULL);
  199. if (ret)
  200. return ret;
  201. return 0;
  202. }
  203. static const struct udevice_id serval_pinctrl_of_match[] = {
  204. { .compatible = "mscc,serval-pinctrl" },
  205. {},
  206. };
  207. U_BOOT_DRIVER(serval_pinctrl) = {
  208. .name = "serval-pinctrl",
  209. .id = UCLASS_PINCTRL,
  210. .of_match = of_match_ptr(serval_pinctrl_of_match),
  211. .probe = serval_pinctrl_probe,
  212. .priv_auto_alloc_size = sizeof(struct mscc_pinctrl),
  213. .ops = &mscc_pinctrl_ops,
  214. };