/*
   * TI LP8860 4-Channel LED Driver
   *
   * Copyright (C) 2014 Texas Instruments
   *
   * Author: Dan Murphy <dmurphy@ti.com>
   *
   * This program is free software; you can redistribute it and/or
   * modify it under the terms of the GNU General Public License
   * version 2 as published by the Free Software Foundation.
   *
   */
  
  #include <linux/i2c.h>
  #include <linux/init.h>
  #include <linux/leds.h>
  #include <linux/regmap.h>
  #include <linux/regulator/consumer.h>
  #include <linux/module.h>
  #include <linux/mutex.h>
  #include <linux/of.h>
  #include <linux/of_gpio.h>
  #include <linux/gpio/consumer.h>
  #include <linux/slab.h>
  
  #define LP8860_DISP_CL1_BRT_MSB		0x00
  #define LP8860_DISP_CL1_BRT_LSB		0x01
  #define LP8860_DISP_CL1_CURR_MSB	0x02
  #define LP8860_DISP_CL1_CURR_LSB	0x03
  #define LP8860_CL2_BRT_MSB		0x04
  #define LP8860_CL2_BRT_LSB		0x05
  #define LP8860_CL2_CURRENT		0x06
  #define LP8860_CL3_BRT_MSB		0x07
  #define LP8860_CL3_BRT_LSB		0x08
  #define LP8860_CL3_CURRENT		0x09
  #define LP8860_CL4_BRT_MSB		0x0a
  #define LP8860_CL4_BRT_LSB		0x0b
  #define LP8860_CL4_CURRENT		0x0c
  #define LP8860_CONFIG			0x0d
  #define LP8860_STATUS			0x0e
  #define LP8860_FAULT			0x0f
  #define LP8860_LED_FAULT		0x10
  #define LP8860_FAULT_CLEAR		0x11
  #define LP8860_ID			0x12
  #define LP8860_TEMP_MSB			0x13
  #define LP8860_TEMP_LSB			0x14
  #define LP8860_DISP_LED_CURR_MSB	0x15
  #define LP8860_DISP_LED_CURR_LSB	0x16
  #define LP8860_DISP_LED_PWM_MSB		0x17
  #define LP8860_DISP_LED_PWM_LSB		0x18
  #define LP8860_EEPROM_CNTRL		0x19
  #define LP8860_EEPROM_UNLOCK		0x1a
  
  #define LP8860_EEPROM_REG_0		0x60
  #define LP8860_EEPROM_REG_1		0x61
  #define LP8860_EEPROM_REG_2		0x62
  #define LP8860_EEPROM_REG_3		0x63
  #define LP8860_EEPROM_REG_4		0x64
  #define LP8860_EEPROM_REG_5		0x65
  #define LP8860_EEPROM_REG_6		0x66
  #define LP8860_EEPROM_REG_7		0x67
  #define LP8860_EEPROM_REG_8		0x68
  #define LP8860_EEPROM_REG_9		0x69
  #define LP8860_EEPROM_REG_10		0x6a
  #define LP8860_EEPROM_REG_11		0x6b
  #define LP8860_EEPROM_REG_12		0x6c
  #define LP8860_EEPROM_REG_13		0x6d
  #define LP8860_EEPROM_REG_14		0x6e
  #define LP8860_EEPROM_REG_15		0x6f
  #define LP8860_EEPROM_REG_16		0x70
  #define LP8860_EEPROM_REG_17		0x71
  #define LP8860_EEPROM_REG_18		0x72
  #define LP8860_EEPROM_REG_19		0x73
  #define LP8860_EEPROM_REG_20		0x74
  #define LP8860_EEPROM_REG_21		0x75
  #define LP8860_EEPROM_REG_22		0x76
  #define LP8860_EEPROM_REG_23		0x77
  #define LP8860_EEPROM_REG_24		0x78
  
  #define LP8860_LOCK_EEPROM		0x00
  #define LP8860_UNLOCK_EEPROM		0x01
  #define LP8860_PROGRAM_EEPROM		0x02
  #define LP8860_EEPROM_CODE_1		0x08
  #define LP8860_EEPROM_CODE_2		0xba
  #define LP8860_EEPROM_CODE_3		0xef
  
  #define LP8860_CLEAR_FAULTS		0x01
  
  #define LP8860_DISP_LED_NAME		"display_cluster"
  
  /**
   * struct lp8860_led -
   * @lock - Lock for reading/writing the device
   * @work - Work item used to off load the brightness register writes
   * @client - Pointer to the I2C client
   * @led_dev - led class device pointer
   * @regmap - Devices register map
   * @eeprom_regmap - EEPROM register map
   * @enable_gpio - VDDIO/EN gpio to enable communication interface
   * @regulator - LED supply regulator pointer
   * @brightness - Current brightness value requested
   * @label - LED label
  **/
  struct lp8860_led {
  	struct mutex lock;
  	struct work_struct work;
  	struct i2c_client *client;
  	struct led_classdev led_dev;
  	struct regmap *regmap;
  	struct regmap *eeprom_regmap;
  	struct gpio_desc *enable_gpio;
  	struct regulator *regulator;
  	enum led_brightness brightness;
  	const char *label;
  };
  
  struct lp8860_eeprom_reg {
  	uint8_t reg;
  	uint8_t value;
  };
  
  static struct lp8860_eeprom_reg lp8860_eeprom_disp_regs[] = {
  	{ LP8860_EEPROM_REG_0, 0xed },
  	{ LP8860_EEPROM_REG_1, 0xdf },
  	{ LP8860_EEPROM_REG_2, 0xdc },
  	{ LP8860_EEPROM_REG_3, 0xf0 },
  	{ LP8860_EEPROM_REG_4, 0xdf },
  	{ LP8860_EEPROM_REG_5, 0xe5 },
  	{ LP8860_EEPROM_REG_6, 0xf2 },
  	{ LP8860_EEPROM_REG_7, 0x77 },
  	{ LP8860_EEPROM_REG_8, 0x77 },
  	{ LP8860_EEPROM_REG_9, 0x71 },
  	{ LP8860_EEPROM_REG_10, 0x3f },
  	{ LP8860_EEPROM_REG_11, 0xb7 },
  	{ LP8860_EEPROM_REG_12, 0x17 },
  	{ LP8860_EEPROM_REG_13, 0xef },
  	{ LP8860_EEPROM_REG_14, 0xb0 },
  	{ LP8860_EEPROM_REG_15, 0x87 },
  	{ LP8860_EEPROM_REG_16, 0xce },
  	{ LP8860_EEPROM_REG_17, 0x72 },
  	{ LP8860_EEPROM_REG_18, 0xe5 },
  	{ LP8860_EEPROM_REG_19, 0xdf },
  	{ LP8860_EEPROM_REG_20, 0x35 },
  	{ LP8860_EEPROM_REG_21, 0x06 },
  	{ LP8860_EEPROM_REG_22, 0xdc },
  	{ LP8860_EEPROM_REG_23, 0x88 },
  	{ LP8860_EEPROM_REG_24, 0x3E },
  };
  
  static int lp8860_unlock_eeprom(struct lp8860_led *led, int lock)
  {
  	int ret;
  
  	mutex_lock(&led->lock);
  
  	if (lock == LP8860_UNLOCK_EEPROM) {
  		ret = regmap_write(led->regmap,
  			LP8860_EEPROM_UNLOCK,
  			LP8860_EEPROM_CODE_1);
  		if (ret) {
  			dev_err(&led->client->dev, "EEPROM Unlock failed
  ");
  			goto out;
  		}
  
  		ret = regmap_write(led->regmap,
  			LP8860_EEPROM_UNLOCK,
  			LP8860_EEPROM_CODE_2);
  		if (ret) {
  			dev_err(&led->client->dev, "EEPROM Unlock failed
  ");
  			goto out;
  		}
  		ret = regmap_write(led->regmap,
  			LP8860_EEPROM_UNLOCK,
  			LP8860_EEPROM_CODE_3);
  		if (ret) {
  			dev_err(&led->client->dev, "EEPROM Unlock failed
  ");
  			goto out;
  		}
  	} else {
  		ret = regmap_write(led->regmap,
  			LP8860_EEPROM_UNLOCK,
  			LP8860_LOCK_EEPROM);
  	}
  
  out:
  	mutex_unlock(&led->lock);
  	return ret;
  }
  
  static int lp8860_fault_check(struct lp8860_led *led)
  {
  	int ret, fault;
  	unsigned int read_buf;
  
  	ret = regmap_read(led->regmap, LP8860_LED_FAULT, &read_buf);
  	if (ret)
  		goto out;
  
  	fault = read_buf;
  
  	ret = regmap_read(led->regmap, LP8860_FAULT, &read_buf);
  	if (ret)
  		goto out;
  
  	fault |= read_buf;
  
  	/* Attempt to clear any faults */
  	if (fault)
  		ret = regmap_write(led->regmap, LP8860_FAULT_CLEAR,
  			LP8860_CLEAR_FAULTS);
  out:
  	return ret;
  }
  
  static void lp8860_led_brightness_work(struct work_struct *work)
  {
  	struct lp8860_led *led = container_of(work, struct lp8860_led, work);
  	int ret;
  	int disp_brightness = led->brightness * 255;
  
  	mutex_lock(&led->lock);
  
  	ret = lp8860_fault_check(led);
  	if (ret) {
  		dev_err(&led->client->dev, "Cannot read/clear faults
  ");
  		goto out;
  	}
  
  	ret = regmap_write(led->regmap, LP8860_DISP_CL1_BRT_MSB,
  			(disp_brightness & 0xff00) >> 8);
  	if (ret) {
  		dev_err(&led->client->dev, "Cannot write CL1 MSB
  ");
  		goto out;
  	}
  
  	ret = regmap_write(led->regmap, LP8860_DISP_CL1_BRT_LSB,
  			disp_brightness & 0xff);
  	if (ret) {
  		dev_err(&led->client->dev, "Cannot write CL1 LSB
  ");
  		goto out;
  	}
  out:
  	mutex_unlock(&led->lock);
  }
  
  static void lp8860_brightness_set(struct led_classdev *led_cdev,
  				enum led_brightness brt_val)
  {
  	struct lp8860_led *led =
  			container_of(led_cdev, struct lp8860_led, led_dev);
  
  	led->brightness = brt_val;
  	schedule_work(&led->work);
  }
  
  static int lp8860_init(struct lp8860_led *led)
  {
  	unsigned int read_buf;
  	int ret, i, reg_count;
  
  	if (led->enable_gpio)
  		gpiod_direction_output(led->enable_gpio, 1);
  
  	ret = lp8860_fault_check(led);
  	if (ret)
  		goto out;
  
  	ret = regmap_read(led->regmap, LP8860_STATUS, &read_buf);
  	if (ret)
  		goto out;
  
  	ret = lp8860_unlock_eeprom(led, LP8860_UNLOCK_EEPROM);
  	if (ret) {
  		dev_err(&led->client->dev, "Failed unlocking EEPROM
  ");
  		goto out;
  	}
  
  	reg_count = ARRAY_SIZE(lp8860_eeprom_disp_regs) / sizeof(lp8860_eeprom_disp_regs[0]);
  	for (i = 0; i < reg_count; i++) {
  		ret = regmap_write(led->eeprom_regmap,
  				lp8860_eeprom_disp_regs[i].reg,
  				lp8860_eeprom_disp_regs[i].value);
  		if (ret) {
  			dev_err(&led->client->dev, "Failed writing EEPROM
  ");
  			goto out;
  		}
  	}
  
  	ret = lp8860_unlock_eeprom(led, LP8860_LOCK_EEPROM);
  	if (ret)
  		goto out;
  
  	ret = regmap_write(led->regmap,
  			LP8860_EEPROM_CNTRL,
  			LP8860_PROGRAM_EEPROM);
  	if (ret)
  		dev_err(&led->client->dev, "Failed programming EEPROM
  ");
  out:
  	if (ret)
  		if (led->enable_gpio)
  			gpiod_direction_output(led->enable_gpio, 0);
  	return ret;
  }
  
  static const struct reg_default lp8860_reg_defs[] = {
  	{ LP8860_DISP_CL1_BRT_MSB, 0x00},
  	{ LP8860_DISP_CL1_BRT_LSB, 0x00},
  	{ LP8860_DISP_CL1_CURR_MSB, 0x00},
  	{ LP8860_DISP_CL1_CURR_LSB, 0x00},
  	{ LP8860_CL2_BRT_MSB, 0x00},
  	{ LP8860_CL2_BRT_LSB, 0x00},
  	{ LP8860_CL2_CURRENT, 0x00},
  	{ LP8860_CL3_BRT_MSB, 0x00},
  	{ LP8860_CL3_BRT_LSB, 0x00},
  	{ LP8860_CL3_CURRENT, 0x00},
  	{ LP8860_CL4_BRT_MSB, 0x00},
  	{ LP8860_CL4_BRT_LSB, 0x00},
  	{ LP8860_CL4_CURRENT, 0x00},
  	{ LP8860_CONFIG, 0x00},
  	{ LP8860_FAULT_CLEAR, 0x00},
  	{ LP8860_EEPROM_CNTRL, 0x80},
  	{ LP8860_EEPROM_UNLOCK, 0x00},
  };
  
  static const struct regmap_config lp8860_regmap_config = {
  	.reg_bits = 8,
  	.val_bits = 8,
  
  	.max_register = LP8860_EEPROM_UNLOCK,
  	.reg_defaults = lp8860_reg_defs,
  	.num_reg_defaults = ARRAY_SIZE(lp8860_reg_defs),
  	.cache_type = REGCACHE_NONE,
  };
  
  static const struct reg_default lp8860_eeprom_defs[] = {
  	{ LP8860_EEPROM_REG_0, 0x00 },
  	{ LP8860_EEPROM_REG_1, 0x00 },
  	{ LP8860_EEPROM_REG_2, 0x00 },
  	{ LP8860_EEPROM_REG_3, 0x00 },
  	{ LP8860_EEPROM_REG_4, 0x00 },
  	{ LP8860_EEPROM_REG_5, 0x00 },
  	{ LP8860_EEPROM_REG_6, 0x00 },
  	{ LP8860_EEPROM_REG_7, 0x00 },
  	{ LP8860_EEPROM_REG_8, 0x00 },
  	{ LP8860_EEPROM_REG_9, 0x00 },
  	{ LP8860_EEPROM_REG_10, 0x00 },
  	{ LP8860_EEPROM_REG_11, 0x00 },
  	{ LP8860_EEPROM_REG_12, 0x00 },
  	{ LP8860_EEPROM_REG_13, 0x00 },
  	{ LP8860_EEPROM_REG_14, 0x00 },
  	{ LP8860_EEPROM_REG_15, 0x00 },
  	{ LP8860_EEPROM_REG_16, 0x00 },
  	{ LP8860_EEPROM_REG_17, 0x00 },
  	{ LP8860_EEPROM_REG_18, 0x00 },
  	{ LP8860_EEPROM_REG_19, 0x00 },
  	{ LP8860_EEPROM_REG_20, 0x00 },
  	{ LP8860_EEPROM_REG_21, 0x00 },
  	{ LP8860_EEPROM_REG_22, 0x00 },
  	{ LP8860_EEPROM_REG_23, 0x00 },
  	{ LP8860_EEPROM_REG_24, 0x00 },
  };
  
  static const struct regmap_config lp8860_eeprom_regmap_config = {
  	.reg_bits = 8,
  	.val_bits = 8,
  
  	.max_register = LP8860_EEPROM_REG_24,
  	.reg_defaults = lp8860_eeprom_defs,
  	.num_reg_defaults = ARRAY_SIZE(lp8860_eeprom_defs),
  	.cache_type = REGCACHE_NONE,
  };
  
  static int lp8860_probe(struct i2c_client *client,
  			const struct i2c_device_id *id)
  {
  	int ret;
  	struct lp8860_led *led;
  	struct device_node *np = client->dev.of_node;
  
  	led = devm_kzalloc(&client->dev, sizeof(*led), GFP_KERNEL);
  	if (!led)
  		return -ENOMEM;
  
  	led->label = LP8860_DISP_LED_NAME;
  
  	if (client->dev.of_node) {
  		ret = of_property_read_string(np, "label", &led->label);
  		if (ret) {
  			dev_err(&client->dev, "Missing label in dt
  ");
  			return -EINVAL;
  		}
  	}
  
  	led->enable_gpio = devm_gpiod_get_optional(&client->dev,
  						   "enable", GPIOD_OUT_LOW);
  	if (IS_ERR(led->enable_gpio)) {
  		ret = PTR_ERR(led->enable_gpio);
  		dev_err(&client->dev, "Failed to get enable gpio: %d
  ", ret);
  		return ret;
  	}
  
  	led->regulator = devm_regulator_get(&client->dev, "vled");
  	if (IS_ERR(led->regulator))
  		led->regulator = NULL;
  
  	led->client = client;
  	led->led_dev.name = led->label;
  	led->led_dev.max_brightness = LED_FULL;
  	led->led_dev.brightness_set = lp8860_brightness_set;
  
  	mutex_init(&led->lock);
  	INIT_WORK(&led->work, lp8860_led_brightness_work);
  
  	i2c_set_clientdata(client, led);
  
  	led->regmap = devm_regmap_init_i2c(client, &lp8860_regmap_config);
  	if (IS_ERR(led->regmap)) {
  		ret = PTR_ERR(led->regmap);
  		dev_err(&client->dev, "Failed to allocate register map: %d
  ",
  			ret);
  		return ret;
  	}
  
  	led->eeprom_regmap = devm_regmap_init_i2c(client, &lp8860_eeprom_regmap_config);
  	if (IS_ERR(led->eeprom_regmap)) {
  		ret = PTR_ERR(led->eeprom_regmap);
  		dev_err(&client->dev, "Failed to allocate register map: %d
  ",
  			ret);
  		return ret;
  	}
  
  	ret = lp8860_init(led);
  	if (ret)
  		return ret;
  
  	ret = led_classdev_register(&client->dev, &led->led_dev);
  	if (ret) {
  		dev_err(&client->dev, "led register err: %d
  ", ret);
  		return ret;
  	}
  
  	return 0;
  }
  
  static int lp8860_remove(struct i2c_client *client)
  {
  	struct lp8860_led *led = i2c_get_clientdata(client);
  	int ret;
  
  	led_classdev_unregister(&led->led_dev);
  	cancel_work_sync(&led->work);
  
  	if (led->enable_gpio)
  		gpiod_direction_output(led->enable_gpio, 0);
  
  	if (led->regulator) {
  		ret = regulator_disable(led->regulator);
  		if (ret)
  			dev_err(&led->client->dev,
  				"Failed to disable regulator
  ");
  	}
  
  	return 0;
  }
  
  static const struct i2c_device_id lp8860_id[] = {
  	{ "lp8860", 0 },
  	{ }
  };
  MODULE_DEVICE_TABLE(i2c, lp8860_id);
  
  #ifdef CONFIG_OF
  static const struct of_device_id of_lp8860_leds_match[] = {
  	{ .compatible = "ti,lp8860", },
  	{},
  };
  MODULE_DEVICE_TABLE(of, of_lp8860_leds_match);
  #endif
  
  static struct i2c_driver lp8860_driver = {
  	.driver = {
  		.name	= "lp8860",
  		.of_match_table = of_match_ptr(of_lp8860_leds_match),
  	},
  	.probe		= lp8860_probe,
  	.remove		= lp8860_remove,
  	.id_table	= lp8860_id,
  };
  module_i2c_driver(lp8860_driver);
  
  MODULE_DESCRIPTION("Texas Instruments LP8860 LED driver");
  MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
  MODULE_LICENSE("GPL");