pinctrl-sandbox.c 5.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2015 Masahiro Yamada <yamada.masahiro@socionext.com>
  4. */
  5. /* #define DEBUG */
  6. #include <common.h>
  7. #include <dm.h>
  8. #include <log.h>
  9. #include <dm/pinctrl.h>
  10. #include <linux/bitops.h>
  11. static const char * const sandbox_pins[] = {
  12. "SCL",
  13. "SDA",
  14. "TX",
  15. "RX",
  16. "W1",
  17. "GPIO0",
  18. "GPIO1",
  19. "GPIO2",
  20. "GPIO3",
  21. };
  22. static const char * const sandbox_pins_muxing[] = {
  23. "I2C SCL",
  24. "I2C SDA",
  25. "Uart TX",
  26. "Uart RX",
  27. "1-wire gpio",
  28. "gpio",
  29. "gpio",
  30. "gpio",
  31. "gpio",
  32. };
  33. static const char * const sandbox_groups[] = {
  34. "i2c",
  35. "serial_a",
  36. "serial_b",
  37. "spi",
  38. "w1",
  39. };
  40. static const char * const sandbox_functions[] = {
  41. "i2c",
  42. "serial",
  43. "spi",
  44. "w1",
  45. "gpio",
  46. "gpio",
  47. "gpio",
  48. "gpio",
  49. };
  50. static const struct pinconf_param sandbox_conf_params[] = {
  51. { "bias-disable", PIN_CONFIG_BIAS_DISABLE, 0 },
  52. { "bias-high-impedance", PIN_CONFIG_BIAS_HIGH_IMPEDANCE, 0 },
  53. { "bias-bus-hold", PIN_CONFIG_BIAS_BUS_HOLD, 0 },
  54. { "bias-pull-up", PIN_CONFIG_BIAS_PULL_UP, 1 },
  55. { "bias-pull-down", PIN_CONFIG_BIAS_PULL_DOWN, 1 },
  56. { "bias-pull-pin-default", PIN_CONFIG_BIAS_PULL_PIN_DEFAULT, 1 },
  57. { "drive-open-drain", PIN_CONFIG_DRIVE_OPEN_DRAIN, 0 },
  58. { "drive-open-source", PIN_CONFIG_DRIVE_OPEN_SOURCE, 0 },
  59. { "drive-strength", PIN_CONFIG_DRIVE_STRENGTH, 0 },
  60. { "input-enable", PIN_CONFIG_INPUT_ENABLE, 1 },
  61. { "input-disable", PIN_CONFIG_INPUT_ENABLE, 0 },
  62. };
  63. /* bitfield used to save param and value of each pin/selector */
  64. static unsigned int sandbox_pins_param[ARRAY_SIZE(sandbox_pins)];
  65. static unsigned int sandbox_pins_value[ARRAY_SIZE(sandbox_pins)];
  66. static int sandbox_get_pins_count(struct udevice *dev)
  67. {
  68. return ARRAY_SIZE(sandbox_pins);
  69. }
  70. static const char *sandbox_get_pin_name(struct udevice *dev, unsigned selector)
  71. {
  72. return sandbox_pins[selector];
  73. }
  74. static int sandbox_get_pin_muxing(struct udevice *dev,
  75. unsigned int selector,
  76. char *buf, int size)
  77. {
  78. const struct pinconf_param *p;
  79. int i;
  80. snprintf(buf, size, "%s", sandbox_pins_muxing[selector]);
  81. if (sandbox_pins_param[selector]) {
  82. for (i = 0, p = sandbox_conf_params;
  83. i < ARRAY_SIZE(sandbox_conf_params);
  84. i++, p++) {
  85. if ((sandbox_pins_param[selector] & BIT(p->param)) &&
  86. (!!(sandbox_pins_value[selector] & BIT(p->param)) ==
  87. p->default_value)) {
  88. strncat(buf, " ", size);
  89. strncat(buf, p->property, size);
  90. }
  91. }
  92. }
  93. strncat(buf, ".", size);
  94. return 0;
  95. }
  96. static int sandbox_get_groups_count(struct udevice *dev)
  97. {
  98. return ARRAY_SIZE(sandbox_groups);
  99. }
  100. static const char *sandbox_get_group_name(struct udevice *dev,
  101. unsigned selector)
  102. {
  103. return sandbox_groups[selector];
  104. }
  105. static int sandbox_get_functions_count(struct udevice *dev)
  106. {
  107. return ARRAY_SIZE(sandbox_functions);
  108. }
  109. static const char *sandbox_get_function_name(struct udevice *dev,
  110. unsigned selector)
  111. {
  112. return sandbox_functions[selector];
  113. }
  114. static int sandbox_pinmux_set(struct udevice *dev, unsigned pin_selector,
  115. unsigned func_selector)
  116. {
  117. debug("sandbox pinmux: pin = %d (%s), function = %d (%s)\n",
  118. pin_selector, sandbox_get_pin_name(dev, pin_selector),
  119. func_selector, sandbox_get_function_name(dev, func_selector));
  120. sandbox_pins_param[pin_selector] = 0;
  121. sandbox_pins_value[pin_selector] = 0;
  122. return 0;
  123. }
  124. static int sandbox_pinmux_group_set(struct udevice *dev,
  125. unsigned group_selector,
  126. unsigned func_selector)
  127. {
  128. debug("sandbox pinmux: group = %d (%s), function = %d (%s)\n",
  129. group_selector, sandbox_get_group_name(dev, group_selector),
  130. func_selector, sandbox_get_function_name(dev, func_selector));
  131. return 0;
  132. }
  133. static int sandbox_pinconf_set(struct udevice *dev, unsigned pin_selector,
  134. unsigned param, unsigned argument)
  135. {
  136. debug("sandbox pinconf: pin = %d (%s), param = %d, arg = %d\n",
  137. pin_selector, sandbox_get_pin_name(dev, pin_selector),
  138. param, argument);
  139. sandbox_pins_param[pin_selector] |= BIT(param);
  140. if (argument)
  141. sandbox_pins_value[pin_selector] |= BIT(param);
  142. else
  143. sandbox_pins_value[pin_selector] &= ~BIT(param);
  144. return 0;
  145. }
  146. static int sandbox_pinconf_group_set(struct udevice *dev,
  147. unsigned group_selector,
  148. unsigned param, unsigned argument)
  149. {
  150. debug("sandbox pinconf: group = %d (%s), param = %d, arg = %d\n",
  151. group_selector, sandbox_get_group_name(dev, group_selector),
  152. param, argument);
  153. return 0;
  154. }
  155. const struct pinctrl_ops sandbox_pinctrl_ops = {
  156. .get_pins_count = sandbox_get_pins_count,
  157. .get_pin_name = sandbox_get_pin_name,
  158. .get_pin_muxing = sandbox_get_pin_muxing,
  159. .get_groups_count = sandbox_get_groups_count,
  160. .get_group_name = sandbox_get_group_name,
  161. .get_functions_count = sandbox_get_functions_count,
  162. .get_function_name = sandbox_get_function_name,
  163. .pinmux_set = sandbox_pinmux_set,
  164. .pinmux_group_set = sandbox_pinmux_group_set,
  165. .pinconf_num_params = ARRAY_SIZE(sandbox_conf_params),
  166. .pinconf_params = sandbox_conf_params,
  167. .pinconf_set = sandbox_pinconf_set,
  168. .pinconf_group_set = sandbox_pinconf_group_set,
  169. .set_state = pinctrl_generic_set_state,
  170. };
  171. static const struct udevice_id sandbox_pinctrl_match[] = {
  172. { .compatible = "sandbox,pinctrl" },
  173. { /* sentinel */ }
  174. };
  175. U_BOOT_DRIVER(sandbox_pinctrl) = {
  176. .name = "sandbox_pinctrl",
  177. .id = UCLASS_PINCTRL,
  178. .of_match = sandbox_pinctrl_match,
  179. .ops = &sandbox_pinctrl_ops,
  180. };