1 /* 2 * Driver for ISSI IS31FL32xx family of I2C LED controllers 3 * 4 * Copyright 2015 Allworx Corp. 5 * 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 * 11 * Datasheets: 12 * http://www.issi.com/US/product-analog-fxled-driver.shtml 13 * http://www.si-en.com/product.asp?parentid=890 14 */ 15 16 #include <linux/device.h> 17 #include <linux/i2c.h> 18 #include <linux/kernel.h> 19 #include <linux/leds.h> 20 #include <linux/module.h> 21 #include <linux/of.h> 22 #include <linux/of_device.h> 23 24 /* Used to indicate a device has no such register */ 25 #define IS31FL32XX_REG_NONE 0xFF 26 27 /* Software Shutdown bit in Shutdown Register */ 28 #define IS31FL32XX_SHUTDOWN_SSD_ENABLE 0 29 #define IS31FL32XX_SHUTDOWN_SSD_DISABLE BIT(0) 30 31 /* IS31FL3216 has a number of unique registers */ 32 #define IS31FL3216_CONFIG_REG 0x00 33 #define IS31FL3216_LIGHTING_EFFECT_REG 0x03 34 #define IS31FL3216_CHANNEL_CONFIG_REG 0x04 35 36 /* Software Shutdown bit in 3216 Config Register */ 37 #define IS31FL3216_CONFIG_SSD_ENABLE BIT(7) 38 #define IS31FL3216_CONFIG_SSD_DISABLE 0 39 40 struct is31fl32xx_priv; 41 struct is31fl32xx_led_data { 42 struct led_classdev cdev; 43 u8 channel; /* 1-based, max priv->cdef->channels */ 44 struct is31fl32xx_priv *priv; 45 }; 46 47 struct is31fl32xx_priv { 48 const struct is31fl32xx_chipdef *cdef; 49 struct i2c_client *client; 50 unsigned int num_leds; 51 struct is31fl32xx_led_data leds[0]; 52 }; 53 54 /** 55 * struct is31fl32xx_chipdef - chip-specific attributes 56 * @channels : Number of LED channels 57 * @shutdown_reg : address of Shutdown register (optional) 58 * @pwm_update_reg : address of PWM Update register 59 * @global_control_reg : address of Global Control register (optional) 60 * @reset_reg : address of Reset register (optional) 61 * @pwm_register_base : address of first PWM register 62 * @pwm_registers_reversed: : true if PWM registers count down instead of up 63 * @led_control_register_base : address of first LED control register (optional) 64 * @enable_bits_per_led_control_register: number of LEDs enable bits in each 65 * @reset_func: : pointer to reset function 66 * 67 * For all optional register addresses, the sentinel value %IS31FL32XX_REG_NONE 68 * indicates that this chip has no such register. 69 * 70 * If non-NULL, @reset_func will be called during probing to set all 71 * necessary registers to a known initialization state. This is needed 72 * for chips that do not have a @reset_reg. 73 * 74 * @enable_bits_per_led_control_register must be >=1 if 75 * @led_control_register_base != %IS31FL32XX_REG_NONE. 76 */ 77 struct is31fl32xx_chipdef { 78 u8 channels; 79 u8 shutdown_reg; 80 u8 pwm_update_reg; 81 u8 global_control_reg; 82 u8 reset_reg; 83 u8 pwm_register_base; 84 bool pwm_registers_reversed; 85 u8 led_control_register_base; 86 u8 enable_bits_per_led_control_register; 87 int (*reset_func)(struct is31fl32xx_priv *priv); 88 int (*sw_shutdown_func)(struct is31fl32xx_priv *priv, bool enable); 89 }; 90 91 static const struct is31fl32xx_chipdef is31fl3236_cdef = { 92 .channels = 36, 93 .shutdown_reg = 0x00, 94 .pwm_update_reg = 0x25, 95 .global_control_reg = 0x4a, 96 .reset_reg = 0x4f, 97 .pwm_register_base = 0x01, 98 .led_control_register_base = 0x26, 99 .enable_bits_per_led_control_register = 1, 100 }; 101 102 static const struct is31fl32xx_chipdef is31fl3235_cdef = { 103 .channels = 28, 104 .shutdown_reg = 0x00, 105 .pwm_update_reg = 0x25, 106 .global_control_reg = 0x4a, 107 .reset_reg = 0x4f, 108 .pwm_register_base = 0x05, 109 .led_control_register_base = 0x2a, 110 .enable_bits_per_led_control_register = 1, 111 }; 112 113 static const struct is31fl32xx_chipdef is31fl3218_cdef = { 114 .channels = 18, 115 .shutdown_reg = 0x00, 116 .pwm_update_reg = 0x16, 117 .global_control_reg = IS31FL32XX_REG_NONE, 118 .reset_reg = 0x17, 119 .pwm_register_base = 0x01, 120 .led_control_register_base = 0x13, 121 .enable_bits_per_led_control_register = 6, 122 }; 123 124 static int is31fl3216_reset(struct is31fl32xx_priv *priv); 125 static int is31fl3216_software_shutdown(struct is31fl32xx_priv *priv, 126 bool enable); 127 static const struct is31fl32xx_chipdef is31fl3216_cdef = { 128 .channels = 16, 129 .shutdown_reg = IS31FL32XX_REG_NONE, 130 .pwm_update_reg = 0xB0, 131 .global_control_reg = IS31FL32XX_REG_NONE, 132 .reset_reg = IS31FL32XX_REG_NONE, 133 .pwm_register_base = 0x10, 134 .pwm_registers_reversed = true, 135 .led_control_register_base = 0x01, 136 .enable_bits_per_led_control_register = 8, 137 .reset_func = is31fl3216_reset, 138 .sw_shutdown_func = is31fl3216_software_shutdown, 139 }; 140 141 static int is31fl32xx_write(struct is31fl32xx_priv *priv, u8 reg, u8 val) 142 { 143 int ret; 144 145 dev_dbg(&priv->client->dev, "writing register 0x%02X=0x%02X", reg, val); 146 147 ret = i2c_smbus_write_byte_data(priv->client, reg, val); 148 if (ret) { 149 dev_err(&priv->client->dev, 150 "register write to 0x%02X failed (error %d)", 151 reg, ret); 152 } 153 return ret; 154 } 155 156 /* 157 * Custom reset function for IS31FL3216 because it does not have a RESET 158 * register the way that the other IS31FL32xx chips do. We don't bother 159 * writing the GPIO and animation registers, because the registers we 160 * do write ensure those will have no effect. 161 */ 162 static int is31fl3216_reset(struct is31fl32xx_priv *priv) 163 { 164 unsigned int i; 165 int ret; 166 167 ret = is31fl32xx_write(priv, IS31FL3216_CONFIG_REG, 168 IS31FL3216_CONFIG_SSD_ENABLE); 169 if (ret) 170 return ret; 171 for (i = 0; i < priv->cdef->channels; i++) { 172 ret = is31fl32xx_write(priv, priv->cdef->pwm_register_base+i, 173 0x00); 174 if (ret) 175 return ret; 176 } 177 ret = is31fl32xx_write(priv, priv->cdef->pwm_update_reg, 0); 178 if (ret) 179 return ret; 180 ret = is31fl32xx_write(priv, IS31FL3216_LIGHTING_EFFECT_REG, 0x00); 181 if (ret) 182 return ret; 183 ret = is31fl32xx_write(priv, IS31FL3216_CHANNEL_CONFIG_REG, 0x00); 184 if (ret) 185 return ret; 186 187 return 0; 188 } 189 190 /* 191 * Custom Software-Shutdown function for IS31FL3216 because it does not have 192 * a SHUTDOWN register the way that the other IS31FL32xx chips do. 193 * We don't bother doing a read/modify/write on the CONFIG register because 194 * we only ever use a value of '0' for the other fields in that register. 195 */ 196 static int is31fl3216_software_shutdown(struct is31fl32xx_priv *priv, 197 bool enable) 198 { 199 u8 value = enable ? IS31FL3216_CONFIG_SSD_ENABLE : 200 IS31FL3216_CONFIG_SSD_DISABLE; 201 202 return is31fl32xx_write(priv, IS31FL3216_CONFIG_REG, value); 203 } 204 205 /* 206 * NOTE: A mutex is not needed in this function because: 207 * - All referenced data is read-only after probe() 208 * - The I2C core has a mutex on to protect the bus 209 * - There are no read/modify/write operations 210 * - Intervening operations between the write of the PWM register 211 * and the Update register are harmless. 212 * 213 * Example: 214 * PWM_REG_1 write 16 215 * UPDATE_REG write 0 216 * PWM_REG_2 write 128 217 * UPDATE_REG write 0 218 * vs: 219 * PWM_REG_1 write 16 220 * PWM_REG_2 write 128 221 * UPDATE_REG write 0 222 * UPDATE_REG write 0 223 * are equivalent. Poking the Update register merely applies all PWM 224 * register writes up to that point. 225 */ 226 static int is31fl32xx_brightness_set(struct led_classdev *led_cdev, 227 enum led_brightness brightness) 228 { 229 const struct is31fl32xx_led_data *led_data = 230 container_of(led_cdev, struct is31fl32xx_led_data, cdev); 231 const struct is31fl32xx_chipdef *cdef = led_data->priv->cdef; 232 u8 pwm_register_offset; 233 int ret; 234 235 dev_dbg(led_cdev->dev, "%s: %d\n", __func__, brightness); 236 237 /* NOTE: led_data->channel is 1-based */ 238 if (cdef->pwm_registers_reversed) 239 pwm_register_offset = cdef->channels - led_data->channel; 240 else 241 pwm_register_offset = led_data->channel - 1; 242 243 ret = is31fl32xx_write(led_data->priv, 244 cdef->pwm_register_base + pwm_register_offset, 245 brightness); 246 if (ret) 247 return ret; 248 249 return is31fl32xx_write(led_data->priv, cdef->pwm_update_reg, 0); 250 } 251 252 static int is31fl32xx_reset_regs(struct is31fl32xx_priv *priv) 253 { 254 const struct is31fl32xx_chipdef *cdef = priv->cdef; 255 int ret; 256 257 if (cdef->reset_reg != IS31FL32XX_REG_NONE) { 258 ret = is31fl32xx_write(priv, cdef->reset_reg, 0); 259 if (ret) 260 return ret; 261 } 262 263 if (cdef->reset_func) 264 return cdef->reset_func(priv); 265 266 return 0; 267 } 268 269 static int is31fl32xx_software_shutdown(struct is31fl32xx_priv *priv, 270 bool enable) 271 { 272 const struct is31fl32xx_chipdef *cdef = priv->cdef; 273 int ret; 274 275 if (cdef->shutdown_reg != IS31FL32XX_REG_NONE) { 276 u8 value = enable ? IS31FL32XX_SHUTDOWN_SSD_ENABLE : 277 IS31FL32XX_SHUTDOWN_SSD_DISABLE; 278 ret = is31fl32xx_write(priv, cdef->shutdown_reg, value); 279 if (ret) 280 return ret; 281 } 282 283 if (cdef->sw_shutdown_func) 284 return cdef->sw_shutdown_func(priv, enable); 285 286 return 0; 287 } 288 289 static int is31fl32xx_init_regs(struct is31fl32xx_priv *priv) 290 { 291 const struct is31fl32xx_chipdef *cdef = priv->cdef; 292 int ret; 293 294 ret = is31fl32xx_reset_regs(priv); 295 if (ret) 296 return ret; 297 298 /* 299 * Set enable bit for all channels. 300 * We will control state with PWM registers alone. 301 */ 302 if (cdef->led_control_register_base != IS31FL32XX_REG_NONE) { 303 u8 value = 304 GENMASK(cdef->enable_bits_per_led_control_register-1, 0); 305 u8 num_regs = cdef->channels / 306 cdef->enable_bits_per_led_control_register; 307 int i; 308 309 for (i = 0; i < num_regs; i++) { 310 ret = is31fl32xx_write(priv, 311 cdef->led_control_register_base+i, 312 value); 313 if (ret) 314 return ret; 315 } 316 } 317 318 ret = is31fl32xx_software_shutdown(priv, false); 319 if (ret) 320 return ret; 321 322 if (cdef->global_control_reg != IS31FL32XX_REG_NONE) { 323 ret = is31fl32xx_write(priv, cdef->global_control_reg, 0x00); 324 if (ret) 325 return ret; 326 } 327 328 return 0; 329 } 330 331 static inline size_t sizeof_is31fl32xx_priv(int num_leds) 332 { 333 return sizeof(struct is31fl32xx_priv) + 334 (sizeof(struct is31fl32xx_led_data) * num_leds); 335 } 336 337 static int is31fl32xx_parse_child_dt(const struct device *dev, 338 const struct device_node *child, 339 struct is31fl32xx_led_data *led_data) 340 { 341 struct led_classdev *cdev = &led_data->cdev; 342 int ret = 0; 343 u32 reg; 344 345 if (of_property_read_string(child, "label", &cdev->name)) 346 cdev->name = child->name; 347 348 ret = of_property_read_u32(child, "reg", ®); 349 if (ret || reg < 1 || reg > led_data->priv->cdef->channels) { 350 dev_err(dev, 351 "Child node %pOF does not have a valid reg property\n", 352 child); 353 return -EINVAL; 354 } 355 led_data->channel = reg; 356 357 of_property_read_string(child, "linux,default-trigger", 358 &cdev->default_trigger); 359 360 cdev->brightness_set_blocking = is31fl32xx_brightness_set; 361 362 return 0; 363 } 364 365 static struct is31fl32xx_led_data *is31fl32xx_find_led_data( 366 struct is31fl32xx_priv *priv, 367 u8 channel) 368 { 369 size_t i; 370 371 for (i = 0; i < priv->num_leds; i++) { 372 if (priv->leds[i].channel == channel) 373 return &priv->leds[i]; 374 } 375 376 return NULL; 377 } 378 379 static int is31fl32xx_parse_dt(struct device *dev, 380 struct is31fl32xx_priv *priv) 381 { 382 struct device_node *child; 383 int ret = 0; 384 385 for_each_child_of_node(dev->of_node, child) { 386 struct is31fl32xx_led_data *led_data = 387 &priv->leds[priv->num_leds]; 388 const struct is31fl32xx_led_data *other_led_data; 389 390 led_data->priv = priv; 391 392 ret = is31fl32xx_parse_child_dt(dev, child, led_data); 393 if (ret) 394 goto err; 395 396 /* Detect if channel is already in use by another child */ 397 other_led_data = is31fl32xx_find_led_data(priv, 398 led_data->channel); 399 if (other_led_data) { 400 dev_err(dev, 401 "%s and %s both attempting to use channel %d\n", 402 led_data->cdev.name, 403 other_led_data->cdev.name, 404 led_data->channel); 405 goto err; 406 } 407 408 ret = devm_led_classdev_register(dev, &led_data->cdev); 409 if (ret) { 410 dev_err(dev, "failed to register PWM led for %s: %d\n", 411 led_data->cdev.name, ret); 412 goto err; 413 } 414 415 priv->num_leds++; 416 } 417 418 return 0; 419 420 err: 421 of_node_put(child); 422 return ret; 423 } 424 425 static const struct of_device_id of_is31fl32xx_match[] = { 426 { .compatible = "issi,is31fl3236", .data = &is31fl3236_cdef, }, 427 { .compatible = "issi,is31fl3235", .data = &is31fl3235_cdef, }, 428 { .compatible = "issi,is31fl3218", .data = &is31fl3218_cdef, }, 429 { .compatible = "si-en,sn3218", .data = &is31fl3218_cdef, }, 430 { .compatible = "issi,is31fl3216", .data = &is31fl3216_cdef, }, 431 { .compatible = "si-en,sn3216", .data = &is31fl3216_cdef, }, 432 {}, 433 }; 434 435 MODULE_DEVICE_TABLE(of, of_is31fl32xx_match); 436 437 static int is31fl32xx_probe(struct i2c_client *client, 438 const struct i2c_device_id *id) 439 { 440 const struct is31fl32xx_chipdef *cdef; 441 const struct of_device_id *of_dev_id; 442 struct device *dev = &client->dev; 443 struct is31fl32xx_priv *priv; 444 int count; 445 int ret = 0; 446 447 of_dev_id = of_match_device(of_is31fl32xx_match, dev); 448 if (!of_dev_id) 449 return -EINVAL; 450 451 cdef = of_dev_id->data; 452 453 count = of_get_child_count(dev->of_node); 454 if (!count) 455 return -EINVAL; 456 457 priv = devm_kzalloc(dev, sizeof_is31fl32xx_priv(count), 458 GFP_KERNEL); 459 if (!priv) 460 return -ENOMEM; 461 462 priv->client = client; 463 priv->cdef = cdef; 464 i2c_set_clientdata(client, priv); 465 466 ret = is31fl32xx_init_regs(priv); 467 if (ret) 468 return ret; 469 470 ret = is31fl32xx_parse_dt(dev, priv); 471 if (ret) 472 return ret; 473 474 return 0; 475 } 476 477 static int is31fl32xx_remove(struct i2c_client *client) 478 { 479 struct is31fl32xx_priv *priv = i2c_get_clientdata(client); 480 481 return is31fl32xx_reset_regs(priv); 482 } 483 484 /* 485 * i2c-core (and modalias) requires that id_table be properly filled, 486 * even though it is not used for DeviceTree based instantiation. 487 */ 488 static const struct i2c_device_id is31fl32xx_id[] = { 489 { "is31fl3236" }, 490 { "is31fl3235" }, 491 { "is31fl3218" }, 492 { "sn3218" }, 493 { "is31fl3216" }, 494 { "sn3216" }, 495 {}, 496 }; 497 498 MODULE_DEVICE_TABLE(i2c, is31fl32xx_id); 499 500 static struct i2c_driver is31fl32xx_driver = { 501 .driver = { 502 .name = "is31fl32xx", 503 .of_match_table = of_is31fl32xx_match, 504 }, 505 .probe = is31fl32xx_probe, 506 .remove = is31fl32xx_remove, 507 .id_table = is31fl32xx_id, 508 }; 509 510 module_i2c_driver(is31fl32xx_driver); 511 512 MODULE_AUTHOR("David Rivshin <drivshin@allworx.com>"); 513 MODULE_DESCRIPTION("ISSI IS31FL32xx LED driver"); 514 MODULE_LICENSE("GPL v2"); 515