leds-pm8058.c 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /* Copyright (c) 2010, 2011, 2016 The Linux Foundation. All rights reserved.
  3. */
  4. #include <linux/leds.h>
  5. #include <linux/module.h>
  6. #include <linux/of.h>
  7. #include <linux/of_device.h>
  8. #include <linux/platform_device.h>
  9. #include <linux/pm.h>
  10. #include <linux/regmap.h>
  11. #define PM8058_LED_TYPE_COMMON 0x00
  12. #define PM8058_LED_TYPE_KEYPAD 0x01
  13. #define PM8058_LED_TYPE_FLASH 0x02
  14. #define PM8058_LED_TYPE_COMMON_MASK 0xf8
  15. #define PM8058_LED_TYPE_KEYPAD_MASK 0xf0
  16. #define PM8058_LED_TYPE_COMMON_SHIFT 3
  17. #define PM8058_LED_TYPE_KEYPAD_SHIFT 4
  18. struct pm8058_led {
  19. struct regmap *map;
  20. u32 reg;
  21. u32 ledtype;
  22. struct led_classdev cdev;
  23. };
  24. static void pm8058_led_set(struct led_classdev *cled,
  25. enum led_brightness value)
  26. {
  27. struct pm8058_led *led;
  28. int ret = 0;
  29. unsigned int mask = 0;
  30. unsigned int val = 0;
  31. led = container_of(cled, struct pm8058_led, cdev);
  32. switch (led->ledtype) {
  33. case PM8058_LED_TYPE_COMMON:
  34. mask = PM8058_LED_TYPE_COMMON_MASK;
  35. val = value << PM8058_LED_TYPE_COMMON_SHIFT;
  36. break;
  37. case PM8058_LED_TYPE_KEYPAD:
  38. case PM8058_LED_TYPE_FLASH:
  39. mask = PM8058_LED_TYPE_KEYPAD_MASK;
  40. val = value << PM8058_LED_TYPE_KEYPAD_SHIFT;
  41. break;
  42. default:
  43. break;
  44. }
  45. ret = regmap_update_bits(led->map, led->reg, mask, val);
  46. if (ret)
  47. pr_err("Failed to set LED brightness\n");
  48. }
  49. static enum led_brightness pm8058_led_get(struct led_classdev *cled)
  50. {
  51. struct pm8058_led *led;
  52. int ret;
  53. unsigned int val;
  54. led = container_of(cled, struct pm8058_led, cdev);
  55. ret = regmap_read(led->map, led->reg, &val);
  56. if (ret) {
  57. pr_err("Failed to get LED brightness\n");
  58. return LED_OFF;
  59. }
  60. switch (led->ledtype) {
  61. case PM8058_LED_TYPE_COMMON:
  62. val &= PM8058_LED_TYPE_COMMON_MASK;
  63. val >>= PM8058_LED_TYPE_COMMON_SHIFT;
  64. break;
  65. case PM8058_LED_TYPE_KEYPAD:
  66. case PM8058_LED_TYPE_FLASH:
  67. val &= PM8058_LED_TYPE_KEYPAD_MASK;
  68. val >>= PM8058_LED_TYPE_KEYPAD_SHIFT;
  69. break;
  70. default:
  71. val = LED_OFF;
  72. break;
  73. }
  74. return val;
  75. }
  76. static int pm8058_led_probe(struct platform_device *pdev)
  77. {
  78. struct led_init_data init_data = {};
  79. struct device *dev = &pdev->dev;
  80. struct pm8058_led *led;
  81. struct device_node *np;
  82. int ret;
  83. struct regmap *map;
  84. const char *state;
  85. enum led_brightness maxbright;
  86. led = devm_kzalloc(dev, sizeof(*led), GFP_KERNEL);
  87. if (!led)
  88. return -ENOMEM;
  89. led->ledtype = (u32)(unsigned long)of_device_get_match_data(dev);
  90. map = dev_get_regmap(dev->parent, NULL);
  91. if (!map) {
  92. dev_err(dev, "Parent regmap unavailable.\n");
  93. return -ENXIO;
  94. }
  95. led->map = map;
  96. np = dev_of_node(dev);
  97. ret = of_property_read_u32(np, "reg", &led->reg);
  98. if (ret) {
  99. dev_err(dev, "no register offset specified\n");
  100. return -EINVAL;
  101. }
  102. led->cdev.brightness_set = pm8058_led_set;
  103. led->cdev.brightness_get = pm8058_led_get;
  104. if (led->ledtype == PM8058_LED_TYPE_COMMON)
  105. maxbright = 31; /* 5 bits */
  106. else
  107. maxbright = 15; /* 4 bits */
  108. led->cdev.max_brightness = maxbright;
  109. state = of_get_property(np, "default-state", NULL);
  110. if (state) {
  111. if (!strcmp(state, "keep")) {
  112. led->cdev.brightness = pm8058_led_get(&led->cdev);
  113. } else if (!strcmp(state, "on")) {
  114. led->cdev.brightness = maxbright;
  115. pm8058_led_set(&led->cdev, maxbright);
  116. } else {
  117. led->cdev.brightness = LED_OFF;
  118. pm8058_led_set(&led->cdev, LED_OFF);
  119. }
  120. }
  121. if (led->ledtype == PM8058_LED_TYPE_KEYPAD ||
  122. led->ledtype == PM8058_LED_TYPE_FLASH)
  123. led->cdev.flags = LED_CORE_SUSPENDRESUME;
  124. init_data.fwnode = of_fwnode_handle(np);
  125. ret = devm_led_classdev_register_ext(dev, &led->cdev, &init_data);
  126. if (ret)
  127. dev_err(dev, "Failed to register LED for %pOF\n", np);
  128. return ret;
  129. }
  130. static const struct of_device_id pm8058_leds_id_table[] = {
  131. {
  132. .compatible = "qcom,pm8058-led",
  133. .data = (void *)PM8058_LED_TYPE_COMMON
  134. },
  135. {
  136. .compatible = "qcom,pm8058-keypad-led",
  137. .data = (void *)PM8058_LED_TYPE_KEYPAD
  138. },
  139. {
  140. .compatible = "qcom,pm8058-flash-led",
  141. .data = (void *)PM8058_LED_TYPE_FLASH
  142. },
  143. { },
  144. };
  145. MODULE_DEVICE_TABLE(of, pm8058_leds_id_table);
  146. static struct platform_driver pm8058_led_driver = {
  147. .probe = pm8058_led_probe,
  148. .driver = {
  149. .name = "pm8058-leds",
  150. .of_match_table = pm8058_leds_id_table,
  151. },
  152. };
  153. module_platform_driver(pm8058_led_driver);
  154. MODULE_DESCRIPTION("PM8058 LEDs driver");
  155. MODULE_LICENSE("GPL v2");
  156. MODULE_ALIAS("platform:pm8058-leds");