1/* leds-sunfire.c: SUNW,Ultra-Enterprise LED driver. 2 * 3 * Copyright (C) 2008 David S. Miller <davem@davemloft.net> 4 */ 5 6#include <linux/kernel.h> 7#include <linux/module.h> 8#include <linux/init.h> 9#include <linux/leds.h> 10#include <linux/io.h> 11#include <linux/platform_device.h> 12#include <linux/slab.h> 13 14#include <asm/fhc.h> 15#include <asm/upa.h> 16 17#define DRIVER_NAME "leds-sunfire" 18#define PFX DRIVER_NAME ": " 19 20MODULE_AUTHOR("David S. Miller (davem@davemloft.net)"); 21MODULE_DESCRIPTION("Sun Fire LED driver"); 22MODULE_LICENSE("GPL"); 23 24struct sunfire_led { 25 struct led_classdev led_cdev; 26 void __iomem *reg; 27}; 28#define to_sunfire_led(d) container_of(d, struct sunfire_led, led_cdev) 29 30static void __clockboard_set(struct led_classdev *led_cdev, 31 enum led_brightness led_val, u8 bit) 32{ 33 struct sunfire_led *p = to_sunfire_led(led_cdev); 34 u8 reg = upa_readb(p->reg); 35 36 switch (bit) { 37 case CLOCK_CTRL_LLED: 38 if (led_val) 39 reg &= ~bit; 40 else 41 reg |= bit; 42 break; 43 44 default: 45 if (led_val) 46 reg |= bit; 47 else 48 reg &= ~bit; 49 break; 50 } 51 upa_writeb(reg, p->reg); 52} 53 54static void clockboard_left_set(struct led_classdev *led_cdev, 55 enum led_brightness led_val) 56{ 57 __clockboard_set(led_cdev, led_val, CLOCK_CTRL_LLED); 58} 59 60static void clockboard_middle_set(struct led_classdev *led_cdev, 61 enum led_brightness led_val) 62{ 63 __clockboard_set(led_cdev, led_val, CLOCK_CTRL_MLED); 64} 65 66static void clockboard_right_set(struct led_classdev *led_cdev, 67 enum led_brightness led_val) 68{ 69 __clockboard_set(led_cdev, led_val, CLOCK_CTRL_RLED); 70} 71 72static void __fhc_set(struct led_classdev *led_cdev, 73 enum led_brightness led_val, u32 bit) 74{ 75 struct sunfire_led *p = to_sunfire_led(led_cdev); 76 u32 reg = upa_readl(p->reg); 77 78 switch (bit) { 79 case FHC_CONTROL_LLED: 80 if (led_val) 81 reg &= ~bit; 82 else 83 reg |= bit; 84 break; 85 86 default: 87 if (led_val) 88 reg |= bit; 89 else 90 reg &= ~bit; 91 break; 92 } 93 upa_writel(reg, p->reg); 94} 95 96static void fhc_left_set(struct led_classdev *led_cdev, 97 enum led_brightness led_val) 98{ 99 __fhc_set(led_cdev, led_val, FHC_CONTROL_LLED); 100} 101 102static void fhc_middle_set(struct led_classdev *led_cdev, 103 enum led_brightness led_val) 104{ 105 __fhc_set(led_cdev, led_val, FHC_CONTROL_MLED); 106} 107 108static void fhc_right_set(struct led_classdev *led_cdev, 109 enum led_brightness led_val) 110{ 111 __fhc_set(led_cdev, led_val, FHC_CONTROL_RLED); 112} 113 114typedef void (*set_handler)(struct led_classdev *, enum led_brightness); 115struct led_type { 116 const char *name; 117 set_handler handler; 118 const char *default_trigger; 119}; 120 121#define NUM_LEDS_PER_BOARD 3 122struct sunfire_drvdata { 123 struct sunfire_led leds[NUM_LEDS_PER_BOARD]; 124}; 125 126static int __devinit sunfire_led_generic_probe(struct platform_device *pdev, 127 struct led_type *types) 128{ 129 struct sunfire_drvdata *p; 130 int i, err = -EINVAL; 131 132 if (pdev->num_resources != 1) { 133 printk(KERN_ERR PFX "Wrong number of resources %d, should be 1\n", 134 pdev->num_resources); 135 goto out; 136 } 137 138 p = kzalloc(sizeof(*p), GFP_KERNEL); 139 if (!p) { 140 printk(KERN_ERR PFX "Could not allocate struct sunfire_drvdata\n"); 141 goto out; 142 } 143 144 for (i = 0; i < NUM_LEDS_PER_BOARD; i++) { 145 struct led_classdev *lp = &p->leds[i].led_cdev; 146 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; 152 153 err = led_classdev_register(&pdev->dev, lp); 154 if (err) { 155 printk(KERN_ERR PFX "Could not register %s LED\n", 156 lp->name); 157 goto out_unregister_led_cdevs; 158 } 159 } 160 161 dev_set_drvdata(&pdev->dev, p); 162 163 err = 0; 164out: 165 return err; 166 167out_unregister_led_cdevs: 168 for (i--; i >= 0; i--) 169 led_classdev_unregister(&p->leds[i].led_cdev); 170 goto out; 171} 172 173static int __devexit sunfire_led_generic_remove(struct platform_device *pdev) 174{ 175 struct sunfire_drvdata *p = dev_get_drvdata(&pdev->dev); 176 int i; 177 178 for (i = 0; i < NUM_LEDS_PER_BOARD; i++) 179 led_classdev_unregister(&p->leds[i].led_cdev); 180 181 kfree(p); 182 183 return 0; 184} 185 186static struct led_type clockboard_led_types[NUM_LEDS_PER_BOARD] = { 187 { 188 .name = "clockboard-left", 189 .handler = clockboard_left_set, 190 }, 191 { 192 .name = "clockboard-middle", 193 .handler = clockboard_middle_set, 194 }, 195 { 196 .name = "clockboard-right", 197 .handler = clockboard_right_set, 198 .default_trigger= "heartbeat", 199 }, 200}; 201 202static int __devinit sunfire_clockboard_led_probe(struct platform_device *pdev) 203{ 204 return sunfire_led_generic_probe(pdev, clockboard_led_types); 205} 206 207static struct led_type fhc_led_types[NUM_LEDS_PER_BOARD] = { 208 { 209 .name = "fhc-left", 210 .handler = fhc_left_set, 211 }, 212 { 213 .name = "fhc-middle", 214 .handler = fhc_middle_set, 215 }, 216 { 217 .name = "fhc-right", 218 .handler = fhc_right_set, 219 .default_trigger= "heartbeat", 220 }, 221}; 222 223static int __devinit sunfire_fhc_led_probe(struct platform_device *pdev) 224{ 225 return sunfire_led_generic_probe(pdev, fhc_led_types); 226} 227 228MODULE_ALIAS("platform:sunfire-clockboard-leds"); 229MODULE_ALIAS("platform:sunfire-fhc-leds"); 230 231static struct platform_driver sunfire_clockboard_led_driver = { 232 .probe = sunfire_clockboard_led_probe, 233 .remove = __devexit_p(sunfire_led_generic_remove), 234 .driver = { 235 .name = "sunfire-clockboard-leds", 236 .owner = THIS_MODULE, 237 }, 238}; 239 240static struct platform_driver sunfire_fhc_led_driver = { 241 .probe = sunfire_fhc_led_probe, 242 .remove = __devexit_p(sunfire_led_generic_remove), 243 .driver = { 244 .name = "sunfire-fhc-leds", 245 .owner = THIS_MODULE, 246 }, 247}; 248 249static int __init sunfire_leds_init(void) 250{ 251 int err = platform_driver_register(&sunfire_clockboard_led_driver); 252 253 if (err) { 254 printk(KERN_ERR PFX "Could not register clock board LED driver\n"); 255 return err; 256 } 257 258 err = platform_driver_register(&sunfire_fhc_led_driver); 259 if (err) { 260 printk(KERN_ERR PFX "Could not register FHC LED driver\n"); 261 platform_driver_unregister(&sunfire_clockboard_led_driver); 262 } 263 264 return err; 265} 266 267static void __exit sunfire_leds_exit(void) 268{ 269 platform_driver_unregister(&sunfire_clockboard_led_driver); 270 platform_driver_unregister(&sunfire_fhc_led_driver); 271} 272 273module_init(sunfire_leds_init); 274module_exit(sunfire_leds_exit); 275