led_bcm6858.c 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2019 Philippe Reynes <philippe.reynes@softathome.com>
  4. *
  5. * based on:
  6. * drivers/led/led_bcm6328.c
  7. * drivers/led/led_bcm6358.c
  8. */
  9. #include <common.h>
  10. #include <dm.h>
  11. #include <errno.h>
  12. #include <led.h>
  13. #include <log.h>
  14. #include <asm/io.h>
  15. #include <dm/lists.h>
  16. #include <linux/bitops.h>
  17. #define LEDS_MAX 32
  18. #define LEDS_WAIT 100
  19. /* LED Mode register */
  20. #define LED_MODE_REG 0x0
  21. #define LED_MODE_OFF 0
  22. #define LED_MODE_ON 1
  23. #define LED_MODE_MASK 1
  24. /* LED Controller Global settings register */
  25. #define LED_CTRL_REG 0x00
  26. #define LED_CTRL_MASK 0x1f
  27. #define LED_CTRL_LED_TEST_MODE BIT(0)
  28. #define LED_CTRL_SERIAL_LED_DATA_PPOL BIT(1)
  29. #define LED_CTRL_SERIAL_LED_CLK_POL BIT(2)
  30. #define LED_CTRL_SERIAL_LED_EN_POL BIT(3)
  31. #define LED_CTRL_SERIAL_LED_MSB_FIRST BIT(4)
  32. /* LED Controller IP LED source select register */
  33. #define LED_HW_LED_EN_REG 0x08
  34. /* LED Flash control register0 */
  35. #define LED_FLASH_RATE_CONTROL_REG0 0x10
  36. /* Soft LED input register */
  37. #define LED_SW_LED_IP_REG 0xb8
  38. /* Parallel LED Output Polarity Register */
  39. #define LED_PLED_OP_PPOL_REG 0xc0
  40. struct bcm6858_led_priv {
  41. void __iomem *regs;
  42. u8 pin;
  43. };
  44. #ifdef CONFIG_LED_BLINK
  45. /*
  46. * The value for flash rate are:
  47. * 0 : no blinking
  48. * 1 : rate is 25 Hz => 40 ms (period)
  49. * 2 : rate is 12.5 Hz => 80 ms (period)
  50. * 3 : rate is 6.25 Hz => 160 ms (period)
  51. * 4 : rate is 3.125 Hz => 320 ms (period)
  52. * 5 : rate is 1.5625 Hz => 640 ms (period)
  53. * 6 : rate is 0.7815 Hz => 1280 ms (period)
  54. * 7 : rate is 0.390625 Hz => 2560 ms (period)
  55. */
  56. static const int bcm6858_flash_rate[8] = {
  57. 0, 40, 80, 160, 320, 640, 1280, 2560
  58. };
  59. static u32 bcm6858_flash_rate_value(int period_ms)
  60. {
  61. unsigned long value = 7;
  62. int i;
  63. for (i = 0; i < ARRAY_SIZE(bcm6858_flash_rate); i++) {
  64. if (period_ms <= bcm6858_flash_rate[i]) {
  65. value = i;
  66. break;
  67. }
  68. }
  69. return value;
  70. }
  71. static int bcm6858_led_set_period(struct udevice *dev, int period_ms)
  72. {
  73. struct bcm6858_led_priv *priv = dev_get_priv(dev);
  74. u32 offset, shift, mask, value;
  75. offset = (priv->pin / 8) * 4;
  76. shift = (priv->pin % 8) * 4;
  77. mask = 0x7 << shift;
  78. value = bcm6858_flash_rate_value(period_ms) << shift;
  79. clrbits_32(priv->regs + LED_FLASH_RATE_CONTROL_REG0 + offset, mask);
  80. setbits_32(priv->regs + LED_FLASH_RATE_CONTROL_REG0 + offset, value);
  81. return 0;
  82. }
  83. #endif
  84. static enum led_state_t bcm6858_led_get_state(struct udevice *dev)
  85. {
  86. struct bcm6858_led_priv *priv = dev_get_priv(dev);
  87. enum led_state_t state = LEDST_OFF;
  88. u32 sw_led_ip;
  89. sw_led_ip = readl(priv->regs + LED_SW_LED_IP_REG);
  90. if (sw_led_ip & (1 << priv->pin))
  91. state = LEDST_ON;
  92. return state;
  93. }
  94. static int bcm6858_led_set_state(struct udevice *dev, enum led_state_t state)
  95. {
  96. struct bcm6858_led_priv *priv = dev_get_priv(dev);
  97. switch (state) {
  98. case LEDST_OFF:
  99. clrbits_32(priv->regs + LED_SW_LED_IP_REG, (1 << priv->pin));
  100. #ifdef CONFIG_LED_BLINK
  101. bcm6858_led_set_period(dev, 0);
  102. #endif
  103. break;
  104. case LEDST_ON:
  105. setbits_32(priv->regs + LED_SW_LED_IP_REG, (1 << priv->pin));
  106. #ifdef CONFIG_LED_BLINK
  107. bcm6858_led_set_period(dev, 0);
  108. #endif
  109. break;
  110. case LEDST_TOGGLE:
  111. if (bcm6858_led_get_state(dev) == LEDST_OFF)
  112. return bcm6858_led_set_state(dev, LEDST_ON);
  113. else
  114. return bcm6858_led_set_state(dev, LEDST_OFF);
  115. break;
  116. #ifdef CONFIG_LED_BLINK
  117. case LEDST_BLINK:
  118. setbits_32(priv->regs + LED_SW_LED_IP_REG, (1 << priv->pin));
  119. break;
  120. #endif
  121. default:
  122. return -EINVAL;
  123. }
  124. return 0;
  125. }
  126. static const struct led_ops bcm6858_led_ops = {
  127. .get_state = bcm6858_led_get_state,
  128. .set_state = bcm6858_led_set_state,
  129. #ifdef CONFIG_LED_BLINK
  130. .set_period = bcm6858_led_set_period,
  131. #endif
  132. };
  133. static int bcm6858_led_probe(struct udevice *dev)
  134. {
  135. struct led_uc_plat *uc_plat = dev_get_uclass_plat(dev);
  136. /* Top-level LED node */
  137. if (!uc_plat->label) {
  138. void __iomem *regs;
  139. u32 set_bits = 0;
  140. regs = dev_remap_addr(dev);
  141. if (!regs)
  142. return -EINVAL;
  143. if (dev_read_bool(dev, "brcm,serial-led-msb-first"))
  144. set_bits |= LED_CTRL_SERIAL_LED_MSB_FIRST;
  145. if (dev_read_bool(dev, "brcm,serial-led-en-pol"))
  146. set_bits |= LED_CTRL_SERIAL_LED_EN_POL;
  147. if (dev_read_bool(dev, "brcm,serial-led-clk-pol"))
  148. set_bits |= LED_CTRL_SERIAL_LED_CLK_POL;
  149. if (dev_read_bool(dev, "brcm,serial-led-data-ppol"))
  150. set_bits |= LED_CTRL_SERIAL_LED_DATA_PPOL;
  151. if (dev_read_bool(dev, "brcm,led-test-mode"))
  152. set_bits |= LED_CTRL_LED_TEST_MODE;
  153. clrsetbits_32(regs + LED_CTRL_REG, ~0, set_bits);
  154. } else {
  155. struct bcm6858_led_priv *priv = dev_get_priv(dev);
  156. void __iomem *regs;
  157. unsigned int pin;
  158. regs = dev_remap_addr(dev_get_parent(dev));
  159. if (!regs)
  160. return -EINVAL;
  161. pin = dev_read_u32_default(dev, "reg", LEDS_MAX);
  162. if (pin >= LEDS_MAX)
  163. return -EINVAL;
  164. priv->regs = regs;
  165. priv->pin = pin;
  166. /* this led is managed by software */
  167. clrbits_32(regs + LED_HW_LED_EN_REG, 1 << pin);
  168. /* configure the polarity */
  169. if (dev_read_bool(dev, "active-low"))
  170. clrbits_32(regs + LED_PLED_OP_PPOL_REG, 1 << pin);
  171. else
  172. setbits_32(regs + LED_PLED_OP_PPOL_REG, 1 << pin);
  173. }
  174. return 0;
  175. }
  176. static int bcm6858_led_bind(struct udevice *parent)
  177. {
  178. ofnode node;
  179. dev_for_each_subnode(node, parent) {
  180. struct led_uc_plat *uc_plat;
  181. struct udevice *dev;
  182. const char *label;
  183. int ret;
  184. label = ofnode_read_string(node, "label");
  185. if (!label) {
  186. debug("%s: node %s has no label\n", __func__,
  187. ofnode_get_name(node));
  188. return -EINVAL;
  189. }
  190. ret = device_bind_driver_to_node(parent, "bcm6858-led",
  191. ofnode_get_name(node),
  192. node, &dev);
  193. if (ret)
  194. return ret;
  195. uc_plat = dev_get_uclass_plat(dev);
  196. uc_plat->label = label;
  197. }
  198. return 0;
  199. }
  200. static const struct udevice_id bcm6858_led_ids[] = {
  201. { .compatible = "brcm,bcm6858-leds" },
  202. { /* sentinel */ }
  203. };
  204. U_BOOT_DRIVER(bcm6858_led) = {
  205. .name = "bcm6858-led",
  206. .id = UCLASS_LED,
  207. .of_match = bcm6858_led_ids,
  208. .bind = bcm6858_led_bind,
  209. .probe = bcm6858_led_probe,
  210. .priv_auto = sizeof(struct bcm6858_led_priv),
  211. .ops = &bcm6858_led_ops,
  212. };