1 /* leds-sunfire.c: SUNW,Ultra-Enterprise LED driver.
3 * Copyright (C) 2008 David S. Miller <davem@davemloft.net>
6 #include <linux/kernel.h>
7 #include <linux/module.h>
8 #include <linux/init.h>
9 #include <linux/leds.h>
11 #include <linux/platform_device.h>
12 #include <linux/slab.h>
17 #define DRIVER_NAME "leds-sunfire"
18 #define PFX DRIVER_NAME ": "
20 MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
21 MODULE_DESCRIPTION("Sun Fire LED driver");
22 MODULE_LICENSE("GPL");
25 struct led_classdev led_cdev
;
28 #define to_sunfire_led(d) container_of(d, struct sunfire_led, led_cdev)
30 static void __clockboard_set(struct led_classdev
*led_cdev
,
31 enum led_brightness led_val
, u8 bit
)
33 struct sunfire_led
*p
= to_sunfire_led(led_cdev
);
34 u8 reg
= upa_readb(p
->reg
);
51 upa_writeb(reg
, p
->reg
);
54 static void clockboard_left_set(struct led_classdev
*led_cdev
,
55 enum led_brightness led_val
)
57 __clockboard_set(led_cdev
, led_val
, CLOCK_CTRL_LLED
);
60 static void clockboard_middle_set(struct led_classdev
*led_cdev
,
61 enum led_brightness led_val
)
63 __clockboard_set(led_cdev
, led_val
, CLOCK_CTRL_MLED
);
66 static void clockboard_right_set(struct led_classdev
*led_cdev
,
67 enum led_brightness led_val
)
69 __clockboard_set(led_cdev
, led_val
, CLOCK_CTRL_RLED
);
72 static void __fhc_set(struct led_classdev
*led_cdev
,
73 enum led_brightness led_val
, u32 bit
)
75 struct sunfire_led
*p
= to_sunfire_led(led_cdev
);
76 u32 reg
= upa_readl(p
->reg
);
79 case FHC_CONTROL_LLED
:
93 upa_writel(reg
, p
->reg
);
96 static void fhc_left_set(struct led_classdev
*led_cdev
,
97 enum led_brightness led_val
)
99 __fhc_set(led_cdev
, led_val
, FHC_CONTROL_LLED
);
102 static void fhc_middle_set(struct led_classdev
*led_cdev
,
103 enum led_brightness led_val
)
105 __fhc_set(led_cdev
, led_val
, FHC_CONTROL_MLED
);
108 static void fhc_right_set(struct led_classdev
*led_cdev
,
109 enum led_brightness led_val
)
111 __fhc_set(led_cdev
, led_val
, FHC_CONTROL_RLED
);
114 typedef void (*set_handler
)(struct led_classdev
*, enum led_brightness
);
118 const char *default_trigger
;
121 #define NUM_LEDS_PER_BOARD 3
122 struct sunfire_drvdata
{
123 struct sunfire_led leds
[NUM_LEDS_PER_BOARD
];
126 static int sunfire_led_generic_probe(struct platform_device
*pdev
,
127 struct led_type
*types
)
129 struct sunfire_drvdata
*p
;
132 if (pdev
->num_resources
!= 1) {
133 printk(KERN_ERR PFX
"Wrong number of resources %d, should be 1\n",
134 pdev
->num_resources
);
138 p
= devm_kzalloc(&pdev
->dev
, sizeof(*p
), GFP_KERNEL
);
140 printk(KERN_ERR PFX
"Could not allocate struct sunfire_drvdata\n");
144 for (i
= 0; i
< NUM_LEDS_PER_BOARD
; i
++) {
145 struct led_classdev
*lp
= &p
->leds
[i
].led_cdev
;
147 p
->leds
[i
].reg
= (void __iomem
*) pdev
->resource
[0].start
;
148 lp
->name
= types
[i
].name
;
149 lp
->brightness
= LED_FULL
;
150 lp
->brightness_set
= types
[i
].handler
;
151 lp
->default_trigger
= types
[i
].default_trigger
;
153 err
= led_classdev_register(&pdev
->dev
, lp
);
155 printk(KERN_ERR PFX
"Could not register %s LED\n",
157 for (i
--; i
>= 0; i
--)
158 led_classdev_unregister(&p
->leds
[i
].led_cdev
);
163 dev_set_drvdata(&pdev
->dev
, p
);
168 static int sunfire_led_generic_remove(struct platform_device
*pdev
)
170 struct sunfire_drvdata
*p
= dev_get_drvdata(&pdev
->dev
);
173 for (i
= 0; i
< NUM_LEDS_PER_BOARD
; i
++)
174 led_classdev_unregister(&p
->leds
[i
].led_cdev
);
179 static struct led_type clockboard_led_types
[NUM_LEDS_PER_BOARD
] = {
181 .name
= "clockboard-left",
182 .handler
= clockboard_left_set
,
185 .name
= "clockboard-middle",
186 .handler
= clockboard_middle_set
,
189 .name
= "clockboard-right",
190 .handler
= clockboard_right_set
,
191 .default_trigger
= "heartbeat",
195 static int sunfire_clockboard_led_probe(struct platform_device
*pdev
)
197 return sunfire_led_generic_probe(pdev
, clockboard_led_types
);
200 static struct led_type fhc_led_types
[NUM_LEDS_PER_BOARD
] = {
203 .handler
= fhc_left_set
,
206 .name
= "fhc-middle",
207 .handler
= fhc_middle_set
,
211 .handler
= fhc_right_set
,
212 .default_trigger
= "heartbeat",
216 static int sunfire_fhc_led_probe(struct platform_device
*pdev
)
218 return sunfire_led_generic_probe(pdev
, fhc_led_types
);
221 MODULE_ALIAS("platform:sunfire-clockboard-leds");
222 MODULE_ALIAS("platform:sunfire-fhc-leds");
224 static struct platform_driver sunfire_clockboard_led_driver
= {
225 .probe
= sunfire_clockboard_led_probe
,
226 .remove
= sunfire_led_generic_remove
,
228 .name
= "sunfire-clockboard-leds",
229 .owner
= THIS_MODULE
,
233 static struct platform_driver sunfire_fhc_led_driver
= {
234 .probe
= sunfire_fhc_led_probe
,
235 .remove
= sunfire_led_generic_remove
,
237 .name
= "sunfire-fhc-leds",
238 .owner
= THIS_MODULE
,
242 static int __init
sunfire_leds_init(void)
244 int err
= platform_driver_register(&sunfire_clockboard_led_driver
);
247 printk(KERN_ERR PFX
"Could not register clock board LED driver\n");
251 err
= platform_driver_register(&sunfire_fhc_led_driver
);
253 printk(KERN_ERR PFX
"Could not register FHC LED driver\n");
254 platform_driver_unregister(&sunfire_clockboard_led_driver
);
260 static void __exit
sunfire_leds_exit(void)
262 platform_driver_unregister(&sunfire_clockboard_led_driver
);
263 platform_driver_unregister(&sunfire_fhc_led_driver
);
266 module_init(sunfire_leds_init
);
267 module_exit(sunfire_leds_exit
);