1 /* 2 * Driver for BCM6328 memory-mapped LEDs, based on leds-syscon.c 3 * 4 * Copyright 2015 Álvaro Fernández Rojas <noltari@gmail.com> 5 * Copyright 2015 Jonas Gorski <jogo@openwrt.org> 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms of the GNU General Public License as published by the 9 * Free Software Foundation; either version 2 of the License, or (at your 10 * option) any later version. 11 */ 12 #include <linux/io.h> 13 #include <linux/leds.h> 14 #include <linux/module.h> 15 #include <linux/of.h> 16 #include <linux/platform_device.h> 17 #include <linux/spinlock.h> 18 19 #define BCM6328_REG_INIT 0x00 20 #define BCM6328_REG_MODE_HI 0x04 21 #define BCM6328_REG_MODE_LO 0x08 22 #define BCM6328_REG_HWDIS 0x0c 23 #define BCM6328_REG_STROBE 0x10 24 #define BCM6328_REG_LNKACTSEL_HI 0x14 25 #define BCM6328_REG_LNKACTSEL_LO 0x18 26 #define BCM6328_REG_RBACK 0x1c 27 #define BCM6328_REG_SERMUX 0x20 28 29 #define BCM6328_LED_MAX_COUNT 24 30 #define BCM6328_LED_DEF_DELAY 500 31 #define BCM6328_LED_INTERVAL_MS 20 32 33 #define BCM6328_LED_INTV_MASK 0x3f 34 #define BCM6328_LED_FAST_INTV_SHIFT 6 35 #define BCM6328_LED_FAST_INTV_MASK (BCM6328_LED_INTV_MASK << \ 36 BCM6328_LED_FAST_INTV_SHIFT) 37 #define BCM6328_SERIAL_LED_EN BIT(12) 38 #define BCM6328_SERIAL_LED_MUX BIT(13) 39 #define BCM6328_SERIAL_LED_CLK_NPOL BIT(14) 40 #define BCM6328_SERIAL_LED_DATA_PPOL BIT(15) 41 #define BCM6328_SERIAL_LED_SHIFT_DIR BIT(16) 42 #define BCM6328_LED_SHIFT_TEST BIT(30) 43 #define BCM6328_LED_TEST BIT(31) 44 #define BCM6328_INIT_MASK (BCM6328_SERIAL_LED_EN | \ 45 BCM6328_SERIAL_LED_MUX | \ 46 BCM6328_SERIAL_LED_CLK_NPOL | \ 47 BCM6328_SERIAL_LED_DATA_PPOL | \ 48 BCM6328_SERIAL_LED_SHIFT_DIR) 49 50 #define BCM6328_LED_MODE_MASK 3 51 #define BCM6328_LED_MODE_OFF 0 52 #define BCM6328_LED_MODE_FAST 1 53 #define BCM6328_LED_MODE_BLINK 2 54 #define BCM6328_LED_MODE_ON 3 55 #define BCM6328_LED_SHIFT(X) ((X) << 1) 56 57 /** 58 * struct bcm6328_led - state container for bcm6328 based LEDs 59 * @cdev: LED class device for this LED 60 * @mem: memory resource 61 * @lock: memory lock 62 * @pin: LED pin number 63 * @blink_leds: blinking LEDs 64 * @blink_delay: blinking delay 65 * @active_low: LED is active low 66 */ 67 struct bcm6328_led { 68 struct led_classdev cdev; 69 void __iomem *mem; 70 spinlock_t *lock; 71 unsigned long pin; 72 unsigned long *blink_leds; 73 unsigned long *blink_delay; 74 bool active_low; 75 }; 76 77 static void bcm6328_led_write(void __iomem *reg, unsigned long data) 78 { 79 iowrite32be(data, reg); 80 } 81 82 static unsigned long bcm6328_led_read(void __iomem *reg) 83 { 84 return ioread32be(reg); 85 } 86 87 /** 88 * LEDMode 64 bits / 24 LEDs 89 * bits [31:0] -> LEDs 8-23 90 * bits [47:32] -> LEDs 0-7 91 * bits [63:48] -> unused 92 */ 93 static unsigned long bcm6328_pin2shift(unsigned long pin) 94 { 95 if (pin < 8) 96 return pin + 16; /* LEDs 0-7 (bits 47:32) */ 97 else 98 return pin - 8; /* LEDs 8-23 (bits 31:0) */ 99 } 100 101 static void bcm6328_led_mode(struct bcm6328_led *led, unsigned long value) 102 { 103 void __iomem *mode; 104 unsigned long val, shift; 105 106 shift = bcm6328_pin2shift(led->pin); 107 if (shift / 16) 108 mode = led->mem + BCM6328_REG_MODE_HI; 109 else 110 mode = led->mem + BCM6328_REG_MODE_LO; 111 112 val = bcm6328_led_read(mode); 113 val &= ~(BCM6328_LED_MODE_MASK << BCM6328_LED_SHIFT(shift % 16)); 114 val |= (value << BCM6328_LED_SHIFT(shift % 16)); 115 bcm6328_led_write(mode, val); 116 } 117 118 static void bcm6328_led_set(struct led_classdev *led_cdev, 119 enum led_brightness value) 120 { 121 struct bcm6328_led *led = 122 container_of(led_cdev, struct bcm6328_led, cdev); 123 unsigned long flags; 124 125 spin_lock_irqsave(led->lock, flags); 126 *(led->blink_leds) &= ~BIT(led->pin); 127 if ((led->active_low && value == LED_OFF) || 128 (!led->active_low && value != LED_OFF)) 129 bcm6328_led_mode(led, BCM6328_LED_MODE_OFF); 130 else 131 bcm6328_led_mode(led, BCM6328_LED_MODE_ON); 132 spin_unlock_irqrestore(led->lock, flags); 133 } 134 135 static int bcm6328_blink_set(struct led_classdev *led_cdev, 136 unsigned long *delay_on, unsigned long *delay_off) 137 { 138 struct bcm6328_led *led = 139 container_of(led_cdev, struct bcm6328_led, cdev); 140 unsigned long delay, flags; 141 142 if (!*delay_on) 143 *delay_on = BCM6328_LED_DEF_DELAY; 144 if (!*delay_off) 145 *delay_off = BCM6328_LED_DEF_DELAY; 146 147 if (*delay_on != *delay_off) { 148 dev_dbg(led_cdev->dev, 149 "fallback to soft blinking (delay_on != delay_off)\n"); 150 return -EINVAL; 151 } 152 153 delay = *delay_on / BCM6328_LED_INTERVAL_MS; 154 if (delay == 0) 155 delay = 1; 156 else if (delay > BCM6328_LED_INTV_MASK) { 157 dev_dbg(led_cdev->dev, 158 "fallback to soft blinking (delay > %ums)\n", 159 BCM6328_LED_INTV_MASK * BCM6328_LED_INTERVAL_MS); 160 return -EINVAL; 161 } 162 163 spin_lock_irqsave(led->lock, flags); 164 if (*(led->blink_leds) == 0 || 165 *(led->blink_leds) == BIT(led->pin) || 166 *(led->blink_delay) == delay) { 167 unsigned long val; 168 169 *(led->blink_leds) |= BIT(led->pin); 170 *(led->blink_delay) = delay; 171 172 val = bcm6328_led_read(led->mem + BCM6328_REG_INIT); 173 val &= ~BCM6328_LED_FAST_INTV_MASK; 174 val |= (delay << BCM6328_LED_FAST_INTV_SHIFT); 175 bcm6328_led_write(led->mem + BCM6328_REG_INIT, val); 176 177 bcm6328_led_mode(led, BCM6328_LED_MODE_BLINK); 178 179 spin_unlock_irqrestore(led->lock, flags); 180 } else { 181 spin_unlock_irqrestore(led->lock, flags); 182 dev_dbg(led_cdev->dev, 183 "fallback to soft blinking (delay already set)\n"); 184 return -EINVAL; 185 } 186 187 return 0; 188 } 189 190 static int bcm6328_hwled(struct device *dev, struct device_node *nc, u32 reg, 191 void __iomem *mem, spinlock_t *lock) 192 { 193 int i, cnt; 194 unsigned long flags, val; 195 196 spin_lock_irqsave(lock, flags); 197 val = bcm6328_led_read(mem + BCM6328_REG_HWDIS); 198 val &= ~BIT(reg); 199 bcm6328_led_write(mem + BCM6328_REG_HWDIS, val); 200 spin_unlock_irqrestore(lock, flags); 201 202 /* Only LEDs 0-7 can be activity/link controlled */ 203 if (reg >= 8) 204 return 0; 205 206 cnt = of_property_count_elems_of_size(nc, "brcm,link-signal-sources", 207 sizeof(u32)); 208 for (i = 0; i < cnt; i++) { 209 u32 sel; 210 void __iomem *addr; 211 212 if (reg < 4) 213 addr = mem + BCM6328_REG_LNKACTSEL_LO; 214 else 215 addr = mem + BCM6328_REG_LNKACTSEL_HI; 216 217 of_property_read_u32_index(nc, "brcm,link-signal-sources", i, 218 &sel); 219 220 if (reg / 4 != sel / 4) { 221 dev_warn(dev, "invalid link signal source\n"); 222 continue; 223 } 224 225 spin_lock_irqsave(lock, flags); 226 val = bcm6328_led_read(addr); 227 val |= (BIT(reg) << (((sel % 4) * 4) + 16)); 228 bcm6328_led_write(addr, val); 229 spin_unlock_irqrestore(lock, flags); 230 } 231 232 cnt = of_property_count_elems_of_size(nc, 233 "brcm,activity-signal-sources", 234 sizeof(u32)); 235 for (i = 0; i < cnt; i++) { 236 u32 sel; 237 void __iomem *addr; 238 239 if (reg < 4) 240 addr = mem + BCM6328_REG_LNKACTSEL_LO; 241 else 242 addr = mem + BCM6328_REG_LNKACTSEL_HI; 243 244 of_property_read_u32_index(nc, "brcm,activity-signal-sources", 245 i, &sel); 246 247 if (reg / 4 != sel / 4) { 248 dev_warn(dev, "invalid activity signal source\n"); 249 continue; 250 } 251 252 spin_lock_irqsave(lock, flags); 253 val = bcm6328_led_read(addr); 254 val |= (BIT(reg) << ((sel % 4) * 4)); 255 bcm6328_led_write(addr, val); 256 spin_unlock_irqrestore(lock, flags); 257 } 258 259 return 0; 260 } 261 262 static int bcm6328_led(struct device *dev, struct device_node *nc, u32 reg, 263 void __iomem *mem, spinlock_t *lock, 264 unsigned long *blink_leds, unsigned long *blink_delay) 265 { 266 struct bcm6328_led *led; 267 unsigned long flags; 268 const char *state; 269 int rc; 270 271 led = devm_kzalloc(dev, sizeof(*led), GFP_KERNEL); 272 if (!led) 273 return -ENOMEM; 274 275 led->pin = reg; 276 led->mem = mem; 277 led->lock = lock; 278 led->blink_leds = blink_leds; 279 led->blink_delay = blink_delay; 280 281 if (of_property_read_bool(nc, "active-low")) 282 led->active_low = true; 283 284 led->cdev.name = of_get_property(nc, "label", NULL) ? : nc->name; 285 led->cdev.default_trigger = of_get_property(nc, 286 "linux,default-trigger", 287 NULL); 288 289 spin_lock_irqsave(lock, flags); 290 if (!of_property_read_string(nc, "default-state", &state)) { 291 if (!strcmp(state, "on")) { 292 led->cdev.brightness = LED_FULL; 293 } else if (!strcmp(state, "keep")) { 294 void __iomem *mode; 295 unsigned long val, shift; 296 297 shift = bcm6328_pin2shift(led->pin); 298 if (shift / 16) 299 mode = mem + BCM6328_REG_MODE_HI; 300 else 301 mode = mem + BCM6328_REG_MODE_LO; 302 303 val = bcm6328_led_read(mode) >> 304 BCM6328_LED_SHIFT(shift % 16); 305 val &= BCM6328_LED_MODE_MASK; 306 if ((led->active_low && val == BCM6328_LED_MODE_ON) || 307 (!led->active_low && val == BCM6328_LED_MODE_OFF)) 308 led->cdev.brightness = LED_FULL; 309 else 310 led->cdev.brightness = LED_OFF; 311 } else { 312 led->cdev.brightness = LED_OFF; 313 } 314 } else { 315 led->cdev.brightness = LED_OFF; 316 } 317 318 if ((led->active_low && led->cdev.brightness == LED_FULL) || 319 (!led->active_low && led->cdev.brightness == LED_OFF)) 320 bcm6328_led_mode(led, BCM6328_LED_MODE_ON); 321 else 322 bcm6328_led_mode(led, BCM6328_LED_MODE_OFF); 323 spin_unlock_irqrestore(lock, flags); 324 325 led->cdev.brightness_set = bcm6328_led_set; 326 led->cdev.blink_set = bcm6328_blink_set; 327 328 rc = led_classdev_register(dev, &led->cdev); 329 if (rc < 0) 330 return rc; 331 332 dev_dbg(dev, "registered LED %s\n", led->cdev.name); 333 334 return 0; 335 } 336 337 static int bcm6328_leds_probe(struct platform_device *pdev) 338 { 339 struct device *dev = &pdev->dev; 340 struct device_node *np = pdev->dev.of_node; 341 struct device_node *child; 342 struct resource *mem_r; 343 void __iomem *mem; 344 spinlock_t *lock; 345 unsigned long val, *blink_leds, *blink_delay; 346 347 mem_r = platform_get_resource(pdev, IORESOURCE_MEM, 0); 348 if (!mem_r) 349 return -EINVAL; 350 351 mem = devm_ioremap_resource(dev, mem_r); 352 if (IS_ERR(mem)) 353 return PTR_ERR(mem); 354 355 lock = devm_kzalloc(dev, sizeof(*lock), GFP_KERNEL); 356 if (!lock) 357 return -ENOMEM; 358 359 blink_leds = devm_kzalloc(dev, sizeof(*blink_leds), GFP_KERNEL); 360 if (!blink_leds) 361 return -ENOMEM; 362 363 blink_delay = devm_kzalloc(dev, sizeof(*blink_delay), GFP_KERNEL); 364 if (!blink_delay) 365 return -ENOMEM; 366 367 spin_lock_init(lock); 368 369 bcm6328_led_write(mem + BCM6328_REG_HWDIS, ~0); 370 bcm6328_led_write(mem + BCM6328_REG_LNKACTSEL_HI, 0); 371 bcm6328_led_write(mem + BCM6328_REG_LNKACTSEL_LO, 0); 372 373 val = bcm6328_led_read(mem + BCM6328_REG_INIT); 374 val &= ~(BCM6328_INIT_MASK); 375 if (of_property_read_bool(np, "brcm,serial-leds")) 376 val |= BCM6328_SERIAL_LED_EN; 377 if (of_property_read_bool(np, "brcm,serial-mux")) 378 val |= BCM6328_SERIAL_LED_MUX; 379 if (of_property_read_bool(np, "brcm,serial-clk-low")) 380 val |= BCM6328_SERIAL_LED_CLK_NPOL; 381 if (!of_property_read_bool(np, "brcm,serial-dat-low")) 382 val |= BCM6328_SERIAL_LED_DATA_PPOL; 383 if (!of_property_read_bool(np, "brcm,serial-shift-inv")) 384 val |= BCM6328_SERIAL_LED_SHIFT_DIR; 385 bcm6328_led_write(mem + BCM6328_REG_INIT, val); 386 387 for_each_available_child_of_node(np, child) { 388 int rc; 389 u32 reg; 390 391 if (of_property_read_u32(child, "reg", ®)) 392 continue; 393 394 if (reg >= BCM6328_LED_MAX_COUNT) { 395 dev_err(dev, "invalid LED (%u >= %d)\n", reg, 396 BCM6328_LED_MAX_COUNT); 397 continue; 398 } 399 400 if (of_property_read_bool(child, "brcm,hardware-controlled")) 401 rc = bcm6328_hwled(dev, child, reg, mem, lock); 402 else 403 rc = bcm6328_led(dev, child, reg, mem, lock, 404 blink_leds, blink_delay); 405 406 if (rc < 0) { 407 of_node_put(child); 408 return rc; 409 } 410 } 411 412 return 0; 413 } 414 415 static const struct of_device_id bcm6328_leds_of_match[] = { 416 { .compatible = "brcm,bcm6328-leds", }, 417 { }, 418 }; 419 MODULE_DEVICE_TABLE(of, bcm6328_leds_of_match); 420 421 static struct platform_driver bcm6328_leds_driver = { 422 .probe = bcm6328_leds_probe, 423 .driver = { 424 .name = "leds-bcm6328", 425 .of_match_table = bcm6328_leds_of_match, 426 }, 427 }; 428 429 module_platform_driver(bcm6328_leds_driver); 430 431 MODULE_AUTHOR("Álvaro Fernández Rojas <noltari@gmail.com>"); 432 MODULE_AUTHOR("Jonas Gorski <jogo@openwrt.org>"); 433 MODULE_DESCRIPTION("LED driver for BCM6328 controllers"); 434 MODULE_LICENSE("GPL v2"); 435 MODULE_ALIAS("platform:leds-bcm6328"); 436