drivers/video/backlight/max25014.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * Backlight driver for Maxim MAX25014
  *
  * Copyright (C) 2025 GOcontroll B.V.
  * Author: Maud Spierings <maudspierings@gocontroll.com>
  */

 #include <linux/backlight.h>
 #include <linux/gpio/consumer.h>
 #include <linux/i2c.h>
 #include <linux/regmap.h>
 #include <linux/slab.h>

 #define MAX25014_ISET_DEFAULT_100 11
 #define MAX_BRIGHTNESS            100
 #define MIN_BRIGHTNESS            0
 #define TON_MAX                   130720 /* @153Hz */
 #define TON_STEP                  1307 /* @153Hz */
 #define TON_MIN                   0

 #define MAX25014_DEV_ID           0x00
 #define MAX25014_REV_ID           0x01
 #define MAX25014_ISET             0x02
 #define MAX25014_IMODE            0x03
 #define MAX25014_TON1H            0x04
 #define MAX25014_TON1L            0x05
 #define MAX25014_TON2H            0x06
 #define MAX25014_TON2L            0x07
 #define MAX25014_TON3H            0x08
 #define MAX25014_TON3L            0x09
 #define MAX25014_TON4H            0x0A
 #define MAX25014_TON4L            0x0B
 #define MAX25014_TON_1_4_LSB      0x0C
 #define MAX25014_SETTING          0x12
 #define MAX25014_DISABLE          0x13
 #define MAX25014_BSTMON           0x14
 #define MAX25014_IOUT1            0x15
 #define MAX25014_IOUT2            0x16
 #define MAX25014_IOUT3            0x17
 #define MAX25014_IOUT4            0x18
 #define MAX25014_OPEN             0x1B
 #define MAX25014_SHORTGND         0x1C
 #define MAX25014_SHORTED_LED      0x1D
 #define MAX25014_MASK             0x1E
 #define MAX25014_DIAG             0x1F

 #define MAX25014_ISET_ENA         BIT(5)
 #define MAX25014_ISET_PSEN        BIT(4)
 #define MAX25014_IMODE_HDIM       BIT(2)
 #define MAX25014_SETTING_FPWM     GENMASK(6, 4)
 #define MAX25014_DISABLE_DIS_MASK GENMASK(3, 0)
 #define MAX25014_DIAG_OT          BIT(0)
 #define MAX25014_DIAG_OTW         BIT(1)
 #define MAX25014_DIAG_HW_RST      BIT(2)
 #define MAX25014_DIAG_BSTOV       BIT(3)
 #define MAX25014_DIAG_BSTUV       BIT(4)
 #define MAX25014_DIAG_IREFOOR     BIT(5)

 struct max25014 {
 	struct i2c_client *client;
 	struct backlight_device *bl;
 	struct regmap *regmap;
 	struct gpio_desc *enable;
 	uint32_t iset;
 	uint8_t strings_mask;
 };

 static const struct regmap_config max25014_regmap_config = {
 	.reg_bits = 8,
 	.val_bits = 8,
 	.max_register = MAX25014_DIAG,
 };

 static int max25014_initial_power_state(struct max25014 *maxim)
 {
 	uint32_t val;
 	int ret;

 	ret = regmap_read(maxim->regmap, MAX25014_ISET, &val);
 	if (ret)
 		return ret;

 	return val & MAX25014_ISET_ENA ? BACKLIGHT_POWER_ON : BACKLIGHT_POWER_OFF;
 }

 static int max25014_check_errors(struct max25014 *maxim)
 {
 	uint32_t val;
 	uint8_t i;
 	int ret;

 	ret = regmap_read(maxim->regmap, MAX25014_OPEN, &val);
 	if (ret)
 		return ret;
 	if (val) {
 		dev_err(&maxim->client->dev, "Open led strings detected on:\n");
 		for (i = 0; i < 4; i++) {
 			if (val & 1 << i)
 				dev_err(&maxim->client->dev, "string %d\n", i + 1);
 		}
 		return -EIO;
 	}

 	ret = regmap_read(maxim->regmap, MAX25014_SHORTGND, &val);
 	if (ret)
 		return ret;
 	if (val) {
 		dev_err(&maxim->client->dev, "Short to ground detected on:\n");
 		for (i = 0; i < 4; i++) {
 			if (val & 1 << i)
 				dev_err(&maxim->client->dev, "string %d\n", i + 1);
 		}
 		return -EIO;
 	}

 	ret = regmap_read(maxim->regmap, MAX25014_SHORTED_LED, &val);
 	if (ret)
 		return ret;
 	if (val) {
 		dev_err(&maxim->client->dev, "Shorted led detected on:\n");
 		for (i = 0; i < 4; i++) {
 			if (val & 1 << i)
 				dev_err(&maxim->client->dev, "string %d\n", i + 1);
 		}
 		return -EIO;
 	}

 	ret = regmap_read(maxim->regmap, MAX25014_DIAG, &val);
 	if (ret)
 		return ret;
 	/*
 	 * The HW_RST bit always starts at 1 after power up.
 	 * It is reset on first read, does not indicate an error.
 	 */
 	if (val && val != MAX25014_DIAG_HW_RST) {
 		if (val & MAX25014_DIAG_OT)
 			dev_err(&maxim->client->dev,
 				"Overtemperature shutdown\n");
 		if (val & MAX25014_DIAG_OTW)
 			dev_err(&maxim->client->dev,
 				 "Chip is getting too hot (>125C)\n");
 		if (val & MAX25014_DIAG_BSTOV)
 			dev_err(&maxim->client->dev,
 				"Boost converter overvoltage\n");
 		if (val & MAX25014_DIAG_BSTUV)
 			dev_err(&maxim->client->dev,
 				"Boost converter undervoltage\n");
 		if (val & MAX25014_DIAG_IREFOOR)
 			dev_err(&maxim->client->dev, "IREF out of range\n");
 		return -EIO;
 	}
 	return 0;
 }

 /*
  * 1. disable unused strings
  * 2. set dim mode
  * 3. set setting register
  * 4. enable the backlight
  */
 static int max25014_configure(struct max25014 *maxim, int initial_state)
 {
 	uint32_t val;
 	int ret;

 	ret = regmap_read(maxim->regmap, MAX25014_DISABLE, &val);
 	if (ret)
 		return ret;

 	/*
 	 * Strings can only be disabled when MAX25014_ISET_ENA == 0, check if
 	 * it needs to be changed at all to prevent the backlight flashing when
 	 * it is configured correctly by the bootloader
 	 */
 	if (!((val & MAX25014_DISABLE_DIS_MASK) == maxim->strings_mask)) {
 		if (initial_state == BACKLIGHT_POWER_ON) {
 			ret = regmap_write(maxim->regmap, MAX25014_ISET, 0);
 			if (ret)
 				return ret;
 		}
 		ret = regmap_write(maxim->regmap, MAX25014_DISABLE, maxim->strings_mask);
 		if (ret)
 			return ret;
 	}

 	ret = regmap_write(maxim->regmap, MAX25014_IMODE, MAX25014_IMODE_HDIM);
 	if (ret)
 		return ret;

 	ret = regmap_read(maxim->regmap, MAX25014_SETTING, &val);
 	if (ret)
 		return ret;

 	ret = regmap_write(maxim->regmap, MAX25014_SETTING,
 			   val & ~MAX25014_SETTING_FPWM);
 	if (ret)
 		return ret;

 	return regmap_write(maxim->regmap, MAX25014_ISET,
 			   maxim->iset | MAX25014_ISET_ENA |
 			   MAX25014_ISET_PSEN);
 }

 static int max25014_update_status(struct backlight_device *bl_dev)
 {
 	struct max25014 *maxim = bl_get_data(bl_dev);
 	uint32_t reg;
 	int ret;

 	reg  = TON_STEP * backlight_get_brightness(bl_dev);

 	/*
 	 * 18 bit number lowest, 2 bits in first register,
 	 * next lowest 8 in the L register, next 8 in the H register
 	 * Seemingly setting the strength of only one string controls all of
 	 * them, individual settings don't affect the outcome.
 	 */
 	ret = regmap_write(maxim->regmap, MAX25014_TON_1_4_LSB, reg & 0b00000011);
 	if (ret != 0)
 		return ret;
 	ret = regmap_write(maxim->regmap, MAX25014_TON1L, (reg >> 2) & 0b11111111);
 	if (ret != 0)
 		return ret;
 	return regmap_write(maxim->regmap, MAX25014_TON1H, (reg >> 10) & 0b11111111);
 }

 static const struct backlight_ops max25014_bl_ops = {
 	.options = BL_CORE_SUSPENDRESUME,
 	.update_status = max25014_update_status,
 };

 static int max25014_parse_dt(struct max25014 *maxim,
 			     uint32_t *initial_brightness)
 {
 	struct device *dev = &maxim->client->dev;
 	struct device_node *node = dev->of_node;
 	uint32_t strings[4];
 	int res, i;

 	res = of_property_count_u32_elems(node, "maxim,strings");
 	if (res == 4) {
 		of_property_read_u32_array(node, "maxim,strings", strings, 4);
 		for (i = 0; i < 4; i++) {
 			if (strings[i] == 0)
 				maxim->strings_mask |= 1 << i;
 	}
 	} else {
 		maxim->strings_mask = 0;
 	}

 	*initial_brightness = 50U;
 	of_property_read_u32(node, "default-brightness", initial_brightness);

 	maxim->iset = MAX25014_ISET_DEFAULT_100;
 	of_property_read_u32(node, "maxim,iset", &maxim->iset);

 	if (maxim->iset > 15)
 		return dev_err_probe(dev, -EINVAL,
 				     "Invalid iset, should be a value from 0-15, entered was %d\n",
 				     maxim->iset);

 	if (*initial_brightness > 100)
 		return dev_err_probe(dev, -EINVAL,
 				     "Invalid initial brightness, should be a value from 0-100, entered was %d\n",
 				     *initial_brightness);

 	return 0;
 }

 static int max25014_probe(struct i2c_client *cl)
 {
 	const struct i2c_device_id *id = i2c_client_get_device_id(cl);
 	struct backlight_properties props;
 	uint32_t initial_brightness = 50;
 	struct backlight_device *bl;
 	struct max25014 *maxim;
 	int ret;

 	maxim = devm_kzalloc(&cl->dev, sizeof(struct max25014), GFP_KERNEL);
 	if (!maxim)
 		return -ENOMEM;

 	maxim->client = cl;

 	ret = max25014_parse_dt(maxim, &initial_brightness);
 	if (ret)
 		return ret;

 	ret = devm_regulator_get_enable(&maxim->client->dev, "power");
 	if (ret)
 		return dev_err_probe(&maxim->client->dev, ret,
 				     "failed to get power-supply");

 	maxim->enable = devm_gpiod_get_optional(&maxim->client->dev, "enable",
 						GPIOD_OUT_HIGH);
 	if (IS_ERR(maxim->enable))
 		return dev_err_probe(&maxim->client->dev, PTR_ERR(maxim->enable),
 				    "failed to get enable gpio\n");

 	/* Datasheet Electrical Characteristics tSTARTUP 2ms */
 	fsleep(2000);

 	maxim->regmap = devm_regmap_init_i2c(cl, &max25014_regmap_config);
 	if (IS_ERR(maxim->regmap))
 		return dev_err_probe(&maxim->client->dev, PTR_ERR(maxim->regmap),
 			"failed to initialize the i2c regmap\n");

 	i2c_set_clientdata(cl, maxim);

 	ret = max25014_check_errors(maxim);
 	if (ret) /* error is already reported in the above function */
 		return ret;

 	ret = max25014_initial_power_state(maxim);
 	if (ret < 0)
 		return dev_err_probe(&maxim->client->dev, ret, "Could not get enabled state\n");

 	memset(&props, 0, sizeof(struct backlight_properties));
 	props.type = BACKLIGHT_PLATFORM;
 	props.max_brightness = MAX_BRIGHTNESS;
 	props.brightness = initial_brightness;
 	props.scale = BACKLIGHT_SCALE_LINEAR;
 	props.power = ret;

 	ret = max25014_configure(maxim, ret);
 	if (ret)
 		return dev_err_probe(&maxim->client->dev, ret, "device config error");

 	bl = devm_backlight_device_register(&maxim->client->dev, id->name,
 					    &maxim->client->dev, maxim,
 					    &max25014_bl_ops, &props);
 	if (IS_ERR(bl))
 		return dev_err_probe(&maxim->client->dev, PTR_ERR(bl),
 				    "failed to register backlight\n");

 	maxim->bl = bl;

 	backlight_update_status(maxim->bl);

 	return 0;
 }

 static void max25014_remove(struct i2c_client *cl)
 {
 	struct max25014 *maxim = i2c_get_clientdata(cl);

 	backlight_device_set_brightness(maxim->bl, 0);
 	gpiod_set_value_cansleep(maxim->enable, 0);
 }

 static const struct of_device_id max25014_dt_ids[] = {
 	{ .compatible = "maxim,max25014", },
 	{ }
 };
 MODULE_DEVICE_TABLE(of, max25014_dt_ids);

 static const struct i2c_device_id max25014_ids[] = {
 	{ "max25014" },
 	{ }
 };
 MODULE_DEVICE_TABLE(i2c, max25014_ids);

 static struct i2c_driver max25014_driver = {
 	.driver = {
 		.name = KBUILD_MODNAME,
 		.of_match_table = of_match_ptr(max25014_dt_ids),
 	},
 	.probe = max25014_probe,
 	.remove = max25014_remove,
 	.id_table = max25014_ids,
 };
 module_i2c_driver(max25014_driver);

 MODULE_DESCRIPTION("Maxim MAX25014 backlight driver");
 MODULE_AUTHOR("Maud Spierings <maudspierings@gocontroll.com>");
 MODULE_LICENSE("GPL");
	// SPDX-License-Identifier: GPL-2.0-only
	/*
	* Backlight driver for Maxim MAX25014
	*
	* Copyright (C) 2025 GOcontroll B.V.
	* Author: Maud Spierings <maudspierings@gocontroll.com>
	*/

	#include <linux/backlight.h>
	#include <linux/gpio/consumer.h>
	#include <linux/i2c.h>
	#include <linux/regmap.h>
	#include <linux/slab.h>

	#define MAX25014_ISET_DEFAULT_100 11
	#define MAX_BRIGHTNESS 100
	#define MIN_BRIGHTNESS 0
	#define TON_MAX 130720 /* @153Hz */
	#define TON_STEP 1307 /* @153Hz */
	#define TON_MIN 0

	#define MAX25014_DEV_ID 0x00
	#define MAX25014_REV_ID 0x01
	#define MAX25014_ISET 0x02
	#define MAX25014_IMODE 0x03
	#define MAX25014_TON1H 0x04
	#define MAX25014_TON1L 0x05
	#define MAX25014_TON2H 0x06
	#define MAX25014_TON2L 0x07
	#define MAX25014_TON3H 0x08
	#define MAX25014_TON3L 0x09
	#define MAX25014_TON4H 0x0A
	#define MAX25014_TON4L 0x0B
	#define MAX25014_TON_1_4_LSB 0x0C
	#define MAX25014_SETTING 0x12
	#define MAX25014_DISABLE 0x13
	#define MAX25014_BSTMON 0x14
	#define MAX25014_IOUT1 0x15
	#define MAX25014_IOUT2 0x16
	#define MAX25014_IOUT3 0x17
	#define MAX25014_IOUT4 0x18
	#define MAX25014_OPEN 0x1B
	#define MAX25014_SHORTGND 0x1C
	#define MAX25014_SHORTED_LED 0x1D
	#define MAX25014_MASK 0x1E
	#define MAX25014_DIAG 0x1F

	#define MAX25014_ISET_ENA BIT(5)
	#define MAX25014_ISET_PSEN BIT(4)
	#define MAX25014_IMODE_HDIM BIT(2)
	#define MAX25014_SETTING_FPWM GENMASK(6, 4)
	#define MAX25014_DISABLE_DIS_MASK GENMASK(3, 0)
	#define MAX25014_DIAG_OT BIT(0)
	#define MAX25014_DIAG_OTW BIT(1)
	#define MAX25014_DIAG_HW_RST BIT(2)
	#define MAX25014_DIAG_BSTOV BIT(3)
	#define MAX25014_DIAG_BSTUV BIT(4)
	#define MAX25014_DIAG_IREFOOR BIT(5)

	struct max25014 {
	struct i2c_client *client;
	struct backlight_device *bl;
	struct regmap *regmap;
	struct gpio_desc *enable;
	uint32_t iset;
	uint8_t strings_mask;
	};

	static const struct regmap_config max25014_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
	.max_register = MAX25014_DIAG,
	};

	static int max25014_initial_power_state(struct max25014 *maxim)
	{
	uint32_t val;
	int ret;

	ret = regmap_read(maxim->regmap, MAX25014_ISET, &val);
	if (ret)
	return ret;

	return val & MAX25014_ISET_ENA ? BACKLIGHT_POWER_ON : BACKLIGHT_POWER_OFF;
	}

	static int max25014_check_errors(struct max25014 *maxim)
	{
	uint32_t val;
	uint8_t i;
	int ret;

	ret = regmap_read(maxim->regmap, MAX25014_OPEN, &val);
	if (ret)
	return ret;
	if (val) {
	dev_err(&maxim->client->dev, "Open led strings detected on:\n");
	for (i = 0; i < 4; i++) {
	if (val & 1 << i)
	dev_err(&maxim->client->dev, "string %d\n", i + 1);
	}
	return -EIO;
	}

	ret = regmap_read(maxim->regmap, MAX25014_SHORTGND, &val);
	if (ret)
	return ret;
	if (val) {
	dev_err(&maxim->client->dev, "Short to ground detected on:\n");
	for (i = 0; i < 4; i++) {
	if (val & 1 << i)
	dev_err(&maxim->client->dev, "string %d\n", i + 1);
	}
	return -EIO;
	}

	ret = regmap_read(maxim->regmap, MAX25014_SHORTED_LED, &val);
	if (ret)
	return ret;
	if (val) {
	dev_err(&maxim->client->dev, "Shorted led detected on:\n");
	for (i = 0; i < 4; i++) {
	if (val & 1 << i)
	dev_err(&maxim->client->dev, "string %d\n", i + 1);
	}
	return -EIO;
	}

	ret = regmap_read(maxim->regmap, MAX25014_DIAG, &val);
	if (ret)
	return ret;
	/*
	* The HW_RST bit always starts at 1 after power up.
	* It is reset on first read, does not indicate an error.
	*/
	if (val && val != MAX25014_DIAG_HW_RST) {
	if (val & MAX25014_DIAG_OT)
	dev_err(&maxim->client->dev,
	"Overtemperature shutdown\n");
	if (val & MAX25014_DIAG_OTW)
	dev_err(&maxim->client->dev,
	"Chip is getting too hot (>125C)\n");
	if (val & MAX25014_DIAG_BSTOV)
	dev_err(&maxim->client->dev,
	"Boost converter overvoltage\n");
	if (val & MAX25014_DIAG_BSTUV)
	dev_err(&maxim->client->dev,
	"Boost converter undervoltage\n");
	if (val & MAX25014_DIAG_IREFOOR)
	dev_err(&maxim->client->dev, "IREF out of range\n");
	return -EIO;
	}
	return 0;
	}

	/*
	* 1. disable unused strings
	* 2. set dim mode
	* 3. set setting register
	* 4. enable the backlight
	*/
	static int max25014_configure(struct max25014 *maxim, int initial_state)
	{
	uint32_t val;
	int ret;

	ret = regmap_read(maxim->regmap, MAX25014_DISABLE, &val);
	if (ret)
	return ret;

	/*
	* Strings can only be disabled when MAX25014_ISET_ENA == 0, check if
	* it needs to be changed at all to prevent the backlight flashing when
	* it is configured correctly by the bootloader
	*/
	if (!((val & MAX25014_DISABLE_DIS_MASK) == maxim->strings_mask)) {
	if (initial_state == BACKLIGHT_POWER_ON) {
	ret = regmap_write(maxim->regmap, MAX25014_ISET, 0);
	if (ret)
	return ret;
	}
	ret = regmap_write(maxim->regmap, MAX25014_DISABLE, maxim->strings_mask);
	if (ret)
	return ret;
	}

	ret = regmap_write(maxim->regmap, MAX25014_IMODE, MAX25014_IMODE_HDIM);
	if (ret)
	return ret;

	ret = regmap_read(maxim->regmap, MAX25014_SETTING, &val);
	if (ret)
	return ret;

	ret = regmap_write(maxim->regmap, MAX25014_SETTING,
	val & ~MAX25014_SETTING_FPWM);
	if (ret)
	return ret;

	return regmap_write(maxim->regmap, MAX25014_ISET,
	maxim->iset \| MAX25014_ISET_ENA \|
	MAX25014_ISET_PSEN);
	}

	static int max25014_update_status(struct backlight_device *bl_dev)
	{
	struct max25014 *maxim = bl_get_data(bl_dev);
	uint32_t reg;
	int ret;

	reg = TON_STEP * backlight_get_brightness(bl_dev);

	/*
	* 18 bit number lowest, 2 bits in first register,
	* next lowest 8 in the L register, next 8 in the H register
	* Seemingly setting the strength of only one string controls all of
	* them, individual settings don't affect the outcome.
	*/
	ret = regmap_write(maxim->regmap, MAX25014_TON_1_4_LSB, reg & 0b00000011);
	if (ret != 0)
	return ret;
	ret = regmap_write(maxim->regmap, MAX25014_TON1L, (reg >> 2) & 0b11111111);
	if (ret != 0)
	return ret;
	return regmap_write(maxim->regmap, MAX25014_TON1H, (reg >> 10) & 0b11111111);
	}

	static const struct backlight_ops max25014_bl_ops = {
	.options = BL_CORE_SUSPENDRESUME,
	.update_status = max25014_update_status,
	};

	static int max25014_parse_dt(struct max25014 *maxim,
	uint32_t *initial_brightness)
	{
	struct device *dev = &maxim->client->dev;
	struct device_node *node = dev->of_node;
	uint32_t strings[4];
	int res, i;

	res = of_property_count_u32_elems(node, "maxim,strings");
	if (res == 4) {
	of_property_read_u32_array(node, "maxim,strings", strings, 4);
	for (i = 0; i < 4; i++) {
	if (strings[i] == 0)
	maxim->strings_mask \|= 1 << i;
	}
	} else {
	maxim->strings_mask = 0;
	}

	*initial_brightness = 50U;
	of_property_read_u32(node, "default-brightness", initial_brightness);

	maxim->iset = MAX25014_ISET_DEFAULT_100;
	of_property_read_u32(node, "maxim,iset", &maxim->iset);

	if (maxim->iset > 15)
	return dev_err_probe(dev, -EINVAL,
	"Invalid iset, should be a value from 0-15, entered was %d\n",
	maxim->iset);

	if (*initial_brightness > 100)
	return dev_err_probe(dev, -EINVAL,
	"Invalid initial brightness, should be a value from 0-100, entered was %d\n",
	*initial_brightness);

	return 0;
	}

	static int max25014_probe(struct i2c_client *cl)
	{
	const struct i2c_device_id *id = i2c_client_get_device_id(cl);
	struct backlight_properties props;
	uint32_t initial_brightness = 50;
	struct backlight_device *bl;
	struct max25014 *maxim;
	int ret;

	maxim = devm_kzalloc(&cl->dev, sizeof(struct max25014), GFP_KERNEL);
	if (!maxim)
	return -ENOMEM;

	maxim->client = cl;

	ret = max25014_parse_dt(maxim, &initial_brightness);
	if (ret)
	return ret;

	ret = devm_regulator_get_enable(&maxim->client->dev, "power");
	if (ret)
	return dev_err_probe(&maxim->client->dev, ret,
	"failed to get power-supply");

	maxim->enable = devm_gpiod_get_optional(&maxim->client->dev, "enable",
	GPIOD_OUT_HIGH);
	if (IS_ERR(maxim->enable))
	return dev_err_probe(&maxim->client->dev, PTR_ERR(maxim->enable),
	"failed to get enable gpio\n");

	/* Datasheet Electrical Characteristics tSTARTUP 2ms */
	fsleep(2000);

	maxim->regmap = devm_regmap_init_i2c(cl, &max25014_regmap_config);
	if (IS_ERR(maxim->regmap))
	return dev_err_probe(&maxim->client->dev, PTR_ERR(maxim->regmap),
	"failed to initialize the i2c regmap\n");

	i2c_set_clientdata(cl, maxim);

	ret = max25014_check_errors(maxim);
	if (ret) /* error is already reported in the above function */
	return ret;

	ret = max25014_initial_power_state(maxim);
	if (ret < 0)
	return dev_err_probe(&maxim->client->dev, ret, "Could not get enabled state\n");

	memset(&props, 0, sizeof(struct backlight_properties));
	props.type = BACKLIGHT_PLATFORM;
	props.max_brightness = MAX_BRIGHTNESS;
	props.brightness = initial_brightness;
	props.scale = BACKLIGHT_SCALE_LINEAR;
	props.power = ret;

	ret = max25014_configure(maxim, ret);
	if (ret)
	return dev_err_probe(&maxim->client->dev, ret, "device config error");

	bl = devm_backlight_device_register(&maxim->client->dev, id->name,
	&maxim->client->dev, maxim,
	&max25014_bl_ops, &props);
	if (IS_ERR(bl))
	return dev_err_probe(&maxim->client->dev, PTR_ERR(bl),
	"failed to register backlight\n");

	maxim->bl = bl;

	backlight_update_status(maxim->bl);

	return 0;
	}

	static void max25014_remove(struct i2c_client *cl)
	{
	struct max25014 *maxim = i2c_get_clientdata(cl);

	backlight_device_set_brightness(maxim->bl, 0);
	gpiod_set_value_cansleep(maxim->enable, 0);
	}

	static const struct of_device_id max25014_dt_ids[] = {
	{ .compatible = "maxim,max25014", },
	{ }
	};
	MODULE_DEVICE_TABLE(of, max25014_dt_ids);

	static const struct i2c_device_id max25014_ids[] = {
	{ "max25014" },
	{ }
	};
	MODULE_DEVICE_TABLE(i2c, max25014_ids);

	static struct i2c_driver max25014_driver = {
	.driver = {
	.name = KBUILD_MODNAME,
	.of_match_table = of_match_ptr(max25014_dt_ids),
	},
	.probe = max25014_probe,
	.remove = max25014_remove,
	.id_table = max25014_ids,
	};
	module_i2c_driver(max25014_driver);

	MODULE_DESCRIPTION("Maxim MAX25014 backlight driver");
	MODULE_AUTHOR("Maud Spierings <maudspierings@gocontroll.com>");
	MODULE_LICENSE("GPL");