leds-sunfire.c 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /* leds-sunfire.c: SUNW,Ultra-Enterprise LED driver.
  3. *
  4. * Copyright (C) 2008 David S. Miller <davem@davemloft.net>
  5. */
  6. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  7. #include <linux/kernel.h>
  8. #include <linux/module.h>
  9. #include <linux/init.h>
  10. #include <linux/leds.h>
  11. #include <linux/io.h>
  12. #include <linux/platform_device.h>
  13. #include <linux/slab.h>
  14. #include <asm/fhc.h>
  15. #include <asm/upa.h>
  16. MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
  17. MODULE_DESCRIPTION("Sun Fire LED driver");
  18. MODULE_LICENSE("GPL");
  19. struct sunfire_led {
  20. struct led_classdev led_cdev;
  21. void __iomem *reg;
  22. };
  23. #define to_sunfire_led(d) container_of(d, struct sunfire_led, led_cdev)
  24. static void __clockboard_set(struct led_classdev *led_cdev,
  25. enum led_brightness led_val, u8 bit)
  26. {
  27. struct sunfire_led *p = to_sunfire_led(led_cdev);
  28. u8 reg = upa_readb(p->reg);
  29. switch (bit) {
  30. case CLOCK_CTRL_LLED:
  31. if (led_val)
  32. reg &= ~bit;
  33. else
  34. reg |= bit;
  35. break;
  36. default:
  37. if (led_val)
  38. reg |= bit;
  39. else
  40. reg &= ~bit;
  41. break;
  42. }
  43. upa_writeb(reg, p->reg);
  44. }
  45. static void clockboard_left_set(struct led_classdev *led_cdev,
  46. enum led_brightness led_val)
  47. {
  48. __clockboard_set(led_cdev, led_val, CLOCK_CTRL_LLED);
  49. }
  50. static void clockboard_middle_set(struct led_classdev *led_cdev,
  51. enum led_brightness led_val)
  52. {
  53. __clockboard_set(led_cdev, led_val, CLOCK_CTRL_MLED);
  54. }
  55. static void clockboard_right_set(struct led_classdev *led_cdev,
  56. enum led_brightness led_val)
  57. {
  58. __clockboard_set(led_cdev, led_val, CLOCK_CTRL_RLED);
  59. }
  60. static void __fhc_set(struct led_classdev *led_cdev,
  61. enum led_brightness led_val, u32 bit)
  62. {
  63. struct sunfire_led *p = to_sunfire_led(led_cdev);
  64. u32 reg = upa_readl(p->reg);
  65. switch (bit) {
  66. case FHC_CONTROL_LLED:
  67. if (led_val)
  68. reg &= ~bit;
  69. else
  70. reg |= bit;
  71. break;
  72. default:
  73. if (led_val)
  74. reg |= bit;
  75. else
  76. reg &= ~bit;
  77. break;
  78. }
  79. upa_writel(reg, p->reg);
  80. }
  81. static void fhc_left_set(struct led_classdev *led_cdev,
  82. enum led_brightness led_val)
  83. {
  84. __fhc_set(led_cdev, led_val, FHC_CONTROL_LLED);
  85. }
  86. static void fhc_middle_set(struct led_classdev *led_cdev,
  87. enum led_brightness led_val)
  88. {
  89. __fhc_set(led_cdev, led_val, FHC_CONTROL_MLED);
  90. }
  91. static void fhc_right_set(struct led_classdev *led_cdev,
  92. enum led_brightness led_val)
  93. {
  94. __fhc_set(led_cdev, led_val, FHC_CONTROL_RLED);
  95. }
  96. typedef void (*set_handler)(struct led_classdev *, enum led_brightness);
  97. struct led_type {
  98. const char *name;
  99. set_handler handler;
  100. const char *default_trigger;
  101. };
  102. #define NUM_LEDS_PER_BOARD 3
  103. struct sunfire_drvdata {
  104. struct sunfire_led leds[NUM_LEDS_PER_BOARD];
  105. };
  106. static int sunfire_led_generic_probe(struct platform_device *pdev,
  107. struct led_type *types)
  108. {
  109. struct sunfire_drvdata *p;
  110. int i, err;
  111. if (pdev->num_resources != 1) {
  112. dev_err(&pdev->dev, "Wrong number of resources %d, should be 1\n",
  113. pdev->num_resources);
  114. return -EINVAL;
  115. }
  116. p = devm_kzalloc(&pdev->dev, sizeof(*p), GFP_KERNEL);
  117. if (!p)
  118. return -ENOMEM;
  119. for (i = 0; i < NUM_LEDS_PER_BOARD; i++) {
  120. struct led_classdev *lp = &p->leds[i].led_cdev;
  121. p->leds[i].reg = (void __iomem *) pdev->resource[0].start;
  122. lp->name = types[i].name;
  123. lp->brightness = LED_FULL;
  124. lp->brightness_set = types[i].handler;
  125. lp->default_trigger = types[i].default_trigger;
  126. err = led_classdev_register(&pdev->dev, lp);
  127. if (err) {
  128. dev_err(&pdev->dev, "Could not register %s LED\n",
  129. lp->name);
  130. for (i--; i >= 0; i--)
  131. led_classdev_unregister(&p->leds[i].led_cdev);
  132. return err;
  133. }
  134. }
  135. platform_set_drvdata(pdev, p);
  136. return 0;
  137. }
  138. static int sunfire_led_generic_remove(struct platform_device *pdev)
  139. {
  140. struct sunfire_drvdata *p = platform_get_drvdata(pdev);
  141. int i;
  142. for (i = 0; i < NUM_LEDS_PER_BOARD; i++)
  143. led_classdev_unregister(&p->leds[i].led_cdev);
  144. return 0;
  145. }
  146. static struct led_type clockboard_led_types[NUM_LEDS_PER_BOARD] = {
  147. {
  148. .name = "clockboard-left",
  149. .handler = clockboard_left_set,
  150. },
  151. {
  152. .name = "clockboard-middle",
  153. .handler = clockboard_middle_set,
  154. },
  155. {
  156. .name = "clockboard-right",
  157. .handler = clockboard_right_set,
  158. .default_trigger = "heartbeat",
  159. },
  160. };
  161. static int sunfire_clockboard_led_probe(struct platform_device *pdev)
  162. {
  163. return sunfire_led_generic_probe(pdev, clockboard_led_types);
  164. }
  165. static struct led_type fhc_led_types[NUM_LEDS_PER_BOARD] = {
  166. {
  167. .name = "fhc-left",
  168. .handler = fhc_left_set,
  169. },
  170. {
  171. .name = "fhc-middle",
  172. .handler = fhc_middle_set,
  173. },
  174. {
  175. .name = "fhc-right",
  176. .handler = fhc_right_set,
  177. .default_trigger = "heartbeat",
  178. },
  179. };
  180. static int sunfire_fhc_led_probe(struct platform_device *pdev)
  181. {
  182. return sunfire_led_generic_probe(pdev, fhc_led_types);
  183. }
  184. MODULE_ALIAS("platform:sunfire-clockboard-leds");
  185. MODULE_ALIAS("platform:sunfire-fhc-leds");
  186. static struct platform_driver sunfire_clockboard_led_driver = {
  187. .probe = sunfire_clockboard_led_probe,
  188. .remove = sunfire_led_generic_remove,
  189. .driver = {
  190. .name = "sunfire-clockboard-leds",
  191. },
  192. };
  193. static struct platform_driver sunfire_fhc_led_driver = {
  194. .probe = sunfire_fhc_led_probe,
  195. .remove = sunfire_led_generic_remove,
  196. .driver = {
  197. .name = "sunfire-fhc-leds",
  198. },
  199. };
  200. static struct platform_driver * const drivers[] = {
  201. &sunfire_clockboard_led_driver,
  202. &sunfire_fhc_led_driver,
  203. };
  204. static int __init sunfire_leds_init(void)
  205. {
  206. return platform_register_drivers(drivers, ARRAY_SIZE(drivers));
  207. }
  208. static void __exit sunfire_leds_exit(void)
  209. {
  210. platform_unregister_drivers(drivers, ARRAY_SIZE(drivers));
  211. }
  212. module_init(sunfire_leds_init);
  213. module_exit(sunfire_leds_exit);